blob: b5082e58bd7b767bcfd9672b06df1741a714e6d5 (
plain) (
blame)
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
|
// So far instructions can only contain linear lists of properties. Now we add
// support for more complex trees of properties in dilated reagents. This will
// come in handy later for expressing complex types, like "a dictionary from
// (address to array of charaters) to (list of numbers)".
:(scenario dilated_reagent_with_nested_brackets)
def main [
{1: number, foo: (bar (baz quux))} <- copy 34
]
+parse: product: {1: "number", "foo": ("bar" ("baz" "quux"))}
:(before "End Parsing Reagent Property(value)")
value = parse_string_tree(value);
:(before "End Parsing Reagent Type Property(value)")
value = parse_string_tree(value);
:(code)
string_tree* parse_string_tree(string_tree* s) {
assert(!s->left && !s->right);
if (s->value.at(0) != '(') return s;
string_tree* result = parse_string_tree(s->value);
delete s;
return result;
}
string_tree* parse_string_tree(const string& s) {
istringstream in(s);
in >> std::noskipws;
return parse_string_tree(in);
}
string_tree* parse_string_tree(istream& in) {
skip_whitespace_but_not_newline(in);
if (!has_data(in)) return NULL;
if (in.peek() == ')') {
in.get();
return NULL;
}
if (in.peek() != '(') {
string_tree* result = new string_tree(next_word(in));
return result;
}
in.get(); // skip '('
string_tree* result = NULL;
string_tree** curr = &result;
while (in.peek() != ')') {
assert(has_data(in));
*curr = new string_tree("");
skip_whitespace_but_not_newline(in);
if (in.peek() == '(')
(*curr)->left = parse_string_tree(in);
else
(*curr)->value = next_word(in);
curr = &(*curr)->right;
}
in.get(); // skip ')'
return result;
}
:(scenario dilated_reagent_with_type_tree)
% Hide_errors = true; // 'map' isn't defined yet
def main [
{1: (foo (address array character) (bar number))} <- copy 34
]
# just to avoid errors
container foo [
]
container bar [
]
+parse: product: {1: ("foo" ("address" "array" "character") ("bar" "number"))}
:(scenario dilated_reagent_in_static_array)
def main [
{1: (array (address number) 3)} <- create-array
5:address:number <- new number:type
{1: (array (address number) 3)} <- put-index {1: (array (address number) 3)}, 0, 5:address:number
*5:address:number <- copy 34
6:number <- copy *5:address:number
]
+run: creating array of size 4
+mem: storing 34 in location 6
//: an exception is 'new', which takes a type tree as its ingredient *value*
:(scenario dilated_reagent_with_new)
def main [
x:address:address:number <- new {(address number): type}
]
+new: size of ("address" "number") is 1
:(before "End Post-processing(expected_product) When Checking 'new'")
{
string_tree* tmp_type_names = parse_string_tree(expected_product.type->name);
delete expected_product.type;
expected_product.type = new_type_tree(tmp_type_names);
delete tmp_type_names;
}
:(before "End Post-processing(type_name) When Converting 'new'")
type_name = parse_string_tree(type_name);
|