about summary refs log tree commit diff stats
path: root/cpp/014arithmetic
diff options
context:
space:
mode:
authorKartik K. Agaram <vc@akkartik.com>2015-03-27 10:51:27 -0700
committerKartik K. Agaram <vc@akkartik.com>2015-03-27 10:51:27 -0700
commite2240eb4e89721928fef4e694524e350fb0140cb (patch)
treed5ede45295705c9e50e72e46436dfec6e16017e1 /cpp/014arithmetic
parent67bd9b1ba1f84c9a6d73378daf764355a09f3c4f (diff)
downloadmu-e2240eb4e89721928fef4e694524e350fb0140cb.tar.gz
987 - c++: memory allocator
Diffstat (limited to 'cpp/014arithmetic')
0 files changed, 0 insertions, 0 deletions
 

generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-07-03 23:59:54 +0000


 


g the type system' href='/akkartik/mu/commit/054dilated_reagent.cc?h=main&id=a796831f3e5697de7194607cfff3efddc588978a'>a796831f ^

21c27706 ^

1ead3562 ^

21c27706 ^





d5f89e0f ^

1ead3562 ^

d5f89e0f ^


acc4792d ^

d5f89e0f ^



1ead3562 ^

d5f89e0f ^




a796831f ^


8619c618 ^

d18d1d3d ^





a796831f ^




a796831f ^


b24eb476 ^

a796831f ^

1f7e3c05 ^

79eef536 ^

21c27706 ^

79eef536 ^

a796831f ^



































d5f89e0f ^

a796831f ^





4ad0f652 ^

a796831f ^



c4e143d6 ^


9dcbec39 ^

c4e143d6 ^



9dcbec39 ^

c4e143d6 ^








08cf048f ^

79eef536 ^

b74443e5 ^

eb4eecea ^

a17f9186 ^

79eef536 ^

a17f9186 ^

a796831f ^

a796831f ^




79eef536 ^

a796831f ^

a072f674 ^

eb4eecea ^

a072f674 ^


a796831f ^




1

2
3

4
5
6

7

8
9

10

11

12

13

14
15
16
17
18

19

20

21
22

23

24
25
26

27

28
29
30
31

32
33

34

35
36
37
38
39

40
41
42
43

44
45

46

47

48

49

50

51

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

87

88
89
90
91
92

93

94
95
96

97
98

99

100
101
102

103

104
105
106
107
108
109
110
111

112

113

114

115

116

117

118

119

120
121
122
123

124

125

126

127

128
129

130
131



                                                                             

                                                                          


                           
          

                                  
                                              
 
                                                   
          




                                     
                                        
          

                                                  
                                              


                                                              
          



                                                

                                                                
                                       




                                                             



                                                                          

                                            
                       
                         
                                      
                        
                
                      


































                                                                            
                                                   




                                    
                             


                        

                       
                                                                       


                    
                                                              







                                                        
                        
                               
                              
                             
                                                        
                                          
                                                                 
   



         
                               
                                
                                                    
                       

                                                

                
//: An alternative syntax for reagents that permits whitespace in properties,
//: grouped by brackets. We'll use this ability in the next layer, when we
//: generalize types from lists to trees of properties.

:(scenarios load)
:(scenario dilated_reagent)
def main [
  {1: number, foo: bar} <- copy 34
]
+parse:   product: {1: "number", "foo": "bar"}

:(scenario load_trailing_space_after_curly_bracket)
def main [
  # line below has a space at the end
  { 
]
# successfully parsed

:(scenario dilated_reagent_with_comment)
def main [
  {1: number, foo: bar} <- copy 34  # test comment
]
+parse:   product: {1: "number", "foo": "bar"}
$error: 0

:(scenario dilated_reagent_with_comment_immediately_following)
def main [
  1:number <- copy {34: literal}  # test comment
]
$error: 0

//: First augment next_word to group balanced brackets together.

:(before "End next_word Special-cases")
if (in.peek() == '(')
  return slurp_balanced_bracket(in);
// treat curlies mostly like parens, but don't mess up labels
if (start_of_dilated_reagent(in))
  return slurp_balanced_bracket(in);

:(code)
// A curly is considered a label if it's the last thing on a line. Dilated
// reagents should remain all on one line.
bool start_of_dilated_reagent(istream& in) {
  if (in.peek() != '{') return false;
  int pos = in.tellg();
  in.get();  // slurp '{'
  skip_whitespace_but_not_newline(in);
  char next = in.peek();
  in.seekg(pos);
  return next != '\n';
}

// Assume the first letter is an open bracket, and read everything until the
// matching close bracket.
// We balance {} () and []. And we skip one character after '\'.
string slurp_balanced_bracket(istream& in) {
  ostringstream result;
  char c;
  list<char> open_brackets;
  while (in >> c) {
    if (c == '\\') {
      // always silently skip the next character
      result << c;
      if (!(in >> c)) break;
      result << c;
      continue;
    }
    if (c == '(') open_brackets.push_back(c);
    if (c == ')') {
      assert(open_brackets.back() == '(');
      open_brackets.pop_back();
    }
    if (c == '[') open_brackets.push_back(c);
    if (c == ']') {
      assert(open_brackets.back() == '[');
      open_brackets.pop_back();
    }
    if (c == '{') open_brackets.push_back(c);
    if (c == '}') {
      assert(open_brackets.back() == '{');
      open_brackets.pop_back();
    }
    result << c;
    if (open_brackets.empty()) break;
  }
  skip_whitespace_and_comments_but_not_newline(in);
  return result.str();
}

:(after "Parsing reagent(string s)")
if (s.at(0) == '{') {
  assert(properties.empty());
  istringstream in(s);
  in >> std::noskipws;
  in.get();  // skip '{'
  name = slurp_key(in);
  if (name.empty()) {
    raise << "invalid reagent '" << s << "' without a name\n" << end();
    return;
  }
  if (name == "}") {
    raise << "invalid empty reagent '" << s << "'\n" << end();
    return;
  }
  {
    string_tree* value = new string_tree(next_word(in));
    // End Parsing Reagent Type Property(value)
    type = new_type_tree(value);
    delete value;
  }
  while (has_data(in)) {
    string key = slurp_key(in);
    if (key.empty()) continue;
    if (key == "}") continue;
    string_tree* value = new string_tree(next_word(in));
    // End Parsing Reagent Property(value)
    properties.push_back(pair<string, string_tree*>(key, value));
  }
  return;
}

:(code)
string slurp_key(istream& in) {
  string result = next_word(in);
  while (!result.empty() && *result.rbegin() == ':')
    strip_last(result);
  while (isspace(in.peek()) || in.peek() == ':')
    in.get();
  return result;
}