OILS / _gen / asdl / examples / shared_variant.asdl.cc View on Github | oils.pub

381 lines, 254 significant
1// _gen/asdl/examples/shared_variant.asdl.cc is generated by asdl_main.py
2
3#include "_gen/asdl/examples/shared_variant.asdl.h"
4#include <assert.h>
5#include "prebuilt/asdl/runtime.mycpp.h" // from mycpp
6
7// Generated code uses these types
8using hnode_asdl::hnode;
9using hnode_asdl::Field;
10using hnode_asdl::color_e;
11
12namespace shared_variant_asdl {
13
14
15hnode_t* prod::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
16 seen = seen ? seen : Alloc<Dict<int, bool>>();
17 int heap_id = ObjectId(this);
18 if (dict_contains(seen, heap_id)) {
19 return Alloc<hnode::AlreadySeen>(heap_id);
20 }
21 seen->set(heap_id, true);
22
23 hnode::Record* out_node = runtime::NewRecord(StrFromC("prod"));
24 List<Field*>* L = out_node->fields;
25
26 hnode_t* x0 = ToPretty(this->a);
27 L->append(Alloc<Field>(StrFromC("a"), x0));
28
29 hnode_t* x1 = ToPretty(this->b);
30 L->append(Alloc<Field>(StrFromC("b"), x1));
31
32 return out_node;
33}
34
35
36hnode_t* DoubleQuoted::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
37 seen = seen ? seen : Alloc<Dict<int, bool>>();
38 int heap_id = ObjectId(this);
39 if (dict_contains(seen, heap_id)) {
40 return Alloc<hnode::AlreadySeen>(heap_id);
41 }
42 seen->set(heap_id, true);
43
44 hnode::Record* out_node = runtime::NewRecord(StrFromC("DoubleQuoted"));
45 List<Field*>* L = out_node->fields;
46
47 hnode_t* x0 = ToPretty(this->left);
48 L->append(Alloc<Field>(StrFromC("left"), x0));
49
50 if (this->tokens != nullptr) { // List
51 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
52 for (ListIter<BigStr*> it(this->tokens); !it.Done(); it.Next()) {
53 BigStr* v_ = it.Value();
54 hnode_t* h = ToPretty(v_);
55 x1->children->append(h);
56 }
57 L->append(Alloc<Field>(StrFromC("tokens"), x1));
58 }
59
60 return out_node;
61}
62
63BigStr* expr_str(int tag, bool dot) {
64 char buf[32];
65 const char* v = nullptr;
66 switch (tag) {
67 case expr_e::Binary:
68 v = "Binary"; break;
69 case expr_e::DoubleQuoted:
70 v = "DoubleQuoted"; break;
71 default:
72 assert(0);
73 }
74 if (dot) {
75 snprintf(buf, 32, "expr.%s", v);
76 return StrFromC(buf);
77 } else {
78 return StrFromC(v);
79 }
80}
81
82hnode_t* expr__Binary::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
83 seen = seen ? seen : Alloc<Dict<int, bool>>();
84 int heap_id = ObjectId(this);
85 if (dict_contains(seen, heap_id)) {
86 return Alloc<hnode::AlreadySeen>(heap_id);
87 }
88 seen->set(heap_id, true);
89
90 hnode::Record* out_node = runtime::NewRecord(expr_str(this->tag()));
91 List<Field*>* L = out_node->fields;
92
93 hnode_t* x0 = this->left->PrettyTree(do_abbrev, seen);
94 L->append(Alloc<Field>(StrFromC("left"), x0));
95
96 hnode_t* x1 = this->right->PrettyTree(do_abbrev, seen);
97 L->append(Alloc<Field>(StrFromC("right"), x1));
98
99 return out_node;
100}
101
102
103hnode_t* expr_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
104 switch (this->tag()) {
105 case expr_e::Binary: {
106 expr__Binary* obj = static_cast<expr__Binary*>(this);
107 return obj->PrettyTree(do_abbrev, seen);
108 }
109 case expr_e::DoubleQuoted: {
110 DoubleQuoted* obj = static_cast<DoubleQuoted*>(this);
111 return obj->PrettyTree(do_abbrev, seen);
112 }
113 default:
114 assert(0);
115 }
116}
117
118hnode_t* Token::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
119 seen = seen ? seen : Alloc<Dict<int, bool>>();
120 int heap_id = ObjectId(this);
121 if (dict_contains(seen, heap_id)) {
122 return Alloc<hnode::AlreadySeen>(heap_id);
123 }
124 seen->set(heap_id, true);
125
126 hnode::Record* out_node = runtime::NewRecord(StrFromC("Token"));
127 List<Field*>* L = out_node->fields;
128
129 hnode_t* x0 = ToPretty(this->id);
130 L->append(Alloc<Field>(StrFromC("id"), x0));
131
132 hnode_t* x1 = ToPretty(this->val);
133 L->append(Alloc<Field>(StrFromC("val"), x1));
134
135 return out_node;
136}
137
138BigStr* tok_str(int tag, bool dot) {
139 char buf[32];
140 const char* v = nullptr;
141 switch (tag) {
142 case tok_e::Eof:
143 v = "Eof"; break;
144 case tok_e::Token:
145 v = "Token"; break;
146 default:
147 assert(0);
148 }
149 if (dot) {
150 snprintf(buf, 32, "tok.%s", v);
151 return StrFromC(buf);
152 } else {
153 return StrFromC(v);
154 }
155}
156
157tok__Eof* tok::Eof = &gtok__Eof.obj;
158
159GcGlobal<tok__Eof> gtok__Eof =
160 { ObjHeader::Global(tok_e::Eof) };
161
162hnode_t* tok__Eof::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
163 seen = seen ? seen : Alloc<Dict<int, bool>>();
164 int heap_id = ObjectId(this);
165 if (dict_contains(seen, heap_id)) {
166 return Alloc<hnode::AlreadySeen>(heap_id);
167 }
168 seen->set(heap_id, true);
169
170 hnode::Record* out_node = runtime::NewRecord(tok_str(this->tag()));
171 return out_node;
172}
173
174
175hnode_t* tok_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
176 switch (this->tag()) {
177 case tok_e::Eof: {
178 tok__Eof* obj = static_cast<tok__Eof*>(this);
179 return obj->PrettyTree(do_abbrev, seen);
180 }
181 case tok_e::Token: {
182 Token* obj = static_cast<Token*>(this);
183 return obj->PrettyTree(do_abbrev, seen);
184 }
185 default:
186 assert(0);
187 }
188}
189
190hnode_t* tok_struct::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
191 seen = seen ? seen : Alloc<Dict<int, bool>>();
192 int heap_id = ObjectId(this);
193 if (dict_contains(seen, heap_id)) {
194 return Alloc<hnode::AlreadySeen>(heap_id);
195 }
196 seen->set(heap_id, true);
197
198 hnode::Record* out_node = runtime::NewRecord(StrFromC("tok_struct"));
199 List<Field*>* L = out_node->fields;
200
201 hnode_t* x0 = this->token->PrettyTree(do_abbrev, seen);
202 L->append(Alloc<Field>(StrFromC("token"), x0));
203
204 hnode_t* x1 = ToPretty(this->x);
205 L->append(Alloc<Field>(StrFromC("x"), x1));
206
207 return out_node;
208}
209
210
211hnode_t* tok_array::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
212 seen = seen ? seen : Alloc<Dict<int, bool>>();
213 int heap_id = ObjectId(this);
214 if (dict_contains(seen, heap_id)) {
215 return Alloc<hnode::AlreadySeen>(heap_id);
216 }
217 seen->set(heap_id, true);
218
219 hnode::Record* out_node = runtime::NewRecord(StrFromC("tok_array"));
220 List<Field*>* L = out_node->fields;
221
222 if (this->tokens != nullptr) { // List
223 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
224 for (ListIter<tok_t*> it(this->tokens); !it.Done(); it.Next()) {
225 tok_t* v_ = it.Value();
226 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
227 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
228 x0->children->append(h);
229 }
230 L->append(Alloc<Field>(StrFromC("tokens"), x0));
231 }
232
233 return out_node;
234}
235
236BigStr* word_part_str(int tag, bool dot) {
237 char buf[32];
238 const char* v = nullptr;
239 switch (tag) {
240 case word_part_e::Literal:
241 v = "Literal"; break;
242 case word_part_e::DoubleQuoted:
243 v = "DoubleQuoted"; break;
244 default:
245 assert(0);
246 }
247 if (dot) {
248 snprintf(buf, 32, "word_part.%s", v);
249 return StrFromC(buf);
250 } else {
251 return StrFromC(v);
252 }
253}
254
255hnode_t* word_part__Literal::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
256 seen = seen ? seen : Alloc<Dict<int, bool>>();
257 int heap_id = ObjectId(this);
258 if (dict_contains(seen, heap_id)) {
259 return Alloc<hnode::AlreadySeen>(heap_id);
260 }
261 seen->set(heap_id, true);
262
263 hnode::Record* out_node = runtime::NewRecord(word_part_str(this->tag()));
264 List<Field*>* L = out_node->fields;
265
266 hnode_t* x0 = ToPretty(this->s);
267 L->append(Alloc<Field>(StrFromC("s"), x0));
268
269 return out_node;
270}
271
272
273hnode_t* word_part_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
274 switch (this->tag()) {
275 case word_part_e::Literal: {
276 word_part__Literal* obj = static_cast<word_part__Literal*>(this);
277 return obj->PrettyTree(do_abbrev, seen);
278 }
279 case word_part_e::DoubleQuoted: {
280 DoubleQuoted* obj = static_cast<DoubleQuoted*>(this);
281 return obj->PrettyTree(do_abbrev, seen);
282 }
283 default:
284 assert(0);
285 }
286}
287BigStr* cflow_str(int tag, bool dot) {
288 char buf[32];
289 const char* v = nullptr;
290 switch (tag) {
291 case cflow_e::Break:
292 v = "Break"; break;
293 case cflow_e::Continue:
294 v = "Continue"; break;
295 case cflow_e::Return:
296 v = "Return"; break;
297 default:
298 assert(0);
299 }
300 if (dot) {
301 snprintf(buf, 32, "cflow.%s", v);
302 return StrFromC(buf);
303 } else {
304 return StrFromC(v);
305 }
306}
307
308cflow__Break* cflow::Break = &gcflow__Break.obj;
309
310GcGlobal<cflow__Break> gcflow__Break =
311 { ObjHeader::Global(cflow_e::Break) };
312
313cflow__Continue* cflow::Continue = &gcflow__Continue.obj;
314
315GcGlobal<cflow__Continue> gcflow__Continue =
316 { ObjHeader::Global(cflow_e::Continue) };
317
318hnode_t* cflow__Break::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
319 seen = seen ? seen : Alloc<Dict<int, bool>>();
320 int heap_id = ObjectId(this);
321 if (dict_contains(seen, heap_id)) {
322 return Alloc<hnode::AlreadySeen>(heap_id);
323 }
324 seen->set(heap_id, true);
325
326 hnode::Record* out_node = runtime::NewRecord(cflow_str(this->tag()));
327 return out_node;
328}
329
330
331hnode_t* cflow__Continue::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
332 seen = seen ? seen : Alloc<Dict<int, bool>>();
333 int heap_id = ObjectId(this);
334 if (dict_contains(seen, heap_id)) {
335 return Alloc<hnode::AlreadySeen>(heap_id);
336 }
337 seen->set(heap_id, true);
338
339 hnode::Record* out_node = runtime::NewRecord(cflow_str(this->tag()));
340 return out_node;
341}
342
343
344hnode_t* cflow__Return::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
345 seen = seen ? seen : Alloc<Dict<int, bool>>();
346 int heap_id = ObjectId(this);
347 if (dict_contains(seen, heap_id)) {
348 return Alloc<hnode::AlreadySeen>(heap_id);
349 }
350 seen->set(heap_id, true);
351
352 hnode::Record* out_node = runtime::NewRecord(cflow_str(this->tag()));
353 List<Field*>* L = out_node->fields;
354
355 hnode_t* x0 = ToPretty(this->val);
356 L->append(Alloc<Field>(StrFromC("val"), x0));
357
358 return out_node;
359}
360
361
362hnode_t* cflow_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
363 switch (this->tag()) {
364 case cflow_e::Break: {
365 cflow__Break* obj = static_cast<cflow__Break*>(this);
366 return obj->PrettyTree(do_abbrev, seen);
367 }
368 case cflow_e::Continue: {
369 cflow__Continue* obj = static_cast<cflow__Continue*>(this);
370 return obj->PrettyTree(do_abbrev, seen);
371 }
372 case cflow_e::Return: {
373 cflow__Return* obj = static_cast<cflow__Return*>(this);
374 return obj->PrettyTree(do_abbrev, seen);
375 }
376 default:
377 assert(0);
378 }
379}
380
381} // namespace shared_variant_asdl