blob: 02170f6df864fcba897ce6ed30ded3cc5a891e97 (
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
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
|
// 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)".
//
// Type trees aren't as general as s-expressions even if they look like them:
// the first element of a type tree is always an atom, and it can never be
// dotted (right->right->right->...->right is always NULL).
//
// For now you can't use the simpler 'colon-based' representation inside type
// trees. Once you start typing parens, keep on typing parens.
void test_dilated_reagent_with_nested_brackets() {
load(
"def main [\n"
" {1: number, foo: (bar (baz quux))} <- copy 34\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
"parse: product: {1: \"number\", \"foo\": (\"bar\" (\"baz\" \"quux\"))}\n"
);
}
:(before "End Parsing Dilated Reagent Property(value)")
value = parse_string_tree(value);
:(before "End Parsing Dilated Reagent Type Property(type_names)")
type_names = parse_string_tree(type_names);
:(code)
string_tree* parse_string_tree(string_tree* s) {
assert(s->atom);
if (!starts_with(s->value, "(")) 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 s = next_word(in);
if (s.empty()) {
assert(!has_data(in));
raise << "incomplete string tree at end of file (0)\n" << end();
return NULL;
}
string_tree* result = new string_tree(s);
return result;
}
in.get(); // skip '('
string_tree* result = NULL;
string_tree** curr = &result;
while (true) {
skip_whitespace_but_not_newline(in);
assert(has_data(in));
if (in.peek() == ')') break;
*curr = new string_tree(NULL, NULL);
if (in.peek() == '(') {
(*curr)->left = parse_string_tree(in);
}
else {
string s = next_word(in);
if (s.empty()) {
assert(!has_data(in));
raise << "incomplete string tree at end of file (1)\n" << end();
return NULL;
}
(*curr)->left = new string_tree(s);
}
curr = &(*curr)->right;
}
in.get(); // skip ')'
assert(*curr == NULL);
return result;
}
void test_dilated_reagent_with_type_tree() {
Hide_errors = true; // 'map' isn't defined yet
load(
"def main [\n"
" {1: (foo (address array character) (bar number))} <- copy 34\n"
"]\n"
"container foo [\n"
"]\n"
"container bar [\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
"parse: product: {1: (\"foo\" (\"address\" \"array\" \"character\") (\"bar\" \"number\"))}\n"
);
}
void test_dilated_empty_tree() {
load(
"def main [\n"
" {1: number, foo: ()} <- copy 34\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
"parse: product: {1: \"number\", \"foo\": ()}\n"
);
}
void test_dilated_singleton_tree() {
load(
"def main [\n"
" {1: number, foo: (bar)} <- copy 34\n"
"]\n"
);
CHECK_TRACE_CONTENTS(
"parse: product: {1: \"number\", \"foo\": (\"bar\")}\n"
);
}
|