OILS / _gen / core / value.asdl.cc View on Github | oilshell.org

1358 lines, 953 significant
1// _gen/core/value.asdl.cc is generated by asdl_main.py
2
3#include "_gen/core/value.asdl.h"
4#include <assert.h>
5#include "prebuilt/asdl/runtime.mycpp.h" // generated code uses wrappers here
6#include "_gen/frontend/syntax.asdl.h" // "use" in ASDL
7#include "_gen/core/runtime.asdl.h" // "use" in ASDL
8
9// Generated code uses these types
10using hnode_asdl::hnode;
11using hnode_asdl::Field;
12using hnode_asdl::color_e;
13
14
15namespace value_asdl {
16
17
18hnode_t* IntBox::PrettyTree(Dict<int, bool>* seen) {
19 seen = seen ? seen : Alloc<Dict<int, bool>>();
20 int heap_id = ObjectId(this);
21 if (dict_contains(seen, heap_id)) {
22 return Alloc<hnode::AlreadySeen>(heap_id);
23 }
24 seen->set(heap_id, true);
25 hnode::Record* out_node = runtime::NewRecord(StrFromC("IntBox"));
26 List<Field*>* L = out_node->fields;
27
28 hnode_t* x0 = Alloc<hnode::Leaf>(str(this->i), color_e::OtherConst);
29 L->append(Alloc<Field>(StrFromC("i"), x0));
30
31 return out_node;
32}
33
34
35hnode_t* ProcDefaults::PrettyTree(Dict<int, bool>* seen) {
36 seen = seen ? seen : Alloc<Dict<int, bool>>();
37 int heap_id = ObjectId(this);
38 if (dict_contains(seen, heap_id)) {
39 return Alloc<hnode::AlreadySeen>(heap_id);
40 }
41 seen->set(heap_id, true);
42 hnode::Record* out_node = runtime::NewRecord(StrFromC("ProcDefaults"));
43 List<Field*>* L = out_node->fields;
44
45 if (this->for_word != nullptr) { // List
46 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
47 for (ListIter<value_t*> it(this->for_word); !it.Done(); it.Next()) {
48 value_t* i0 = it.Value();
49 hnode_t* h = (i0 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
50 color_e::OtherConst) : i0->PrettyTree(seen);
51 x0->children->append(h);
52 }
53 L->append(Alloc<Field>(StrFromC("for_word"), x0));
54 }
55
56 if (this->for_typed != nullptr) { // List
57 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
58 for (ListIter<value_t*> it(this->for_typed); !it.Done(); it.Next()) {
59 value_t* i1 = it.Value();
60 hnode_t* h = (i1 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
61 color_e::OtherConst) : i1->PrettyTree(seen);
62 x1->children->append(h);
63 }
64 L->append(Alloc<Field>(StrFromC("for_typed"), x1));
65 }
66
67 if (this->for_named) { // Dict
68 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
69 hnode::Array* x2 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
70 for (DictIter<BigStr*, value_t*> it(this->for_named); !it.Done();
71 it.Next()) {
72 auto k2 = it.Key();
73 auto v2 = it.Value();
74 x2->children->append(runtime::NewLeaf(k2, color_e::StringConst));
75 x2->children->append(v2->PrettyTree(seen));
76 }
77 L->append(Alloc<Field>(StrFromC ("for_named"), x2));
78 }
79
80 if (this->for_block) { // Optional
81 hnode_t* x3 = this->for_block->PrettyTree(seen);
82 L->append(Alloc<Field>(StrFromC("for_block"), x3));
83 }
84
85 return out_node;
86}
87
88
89hnode_t* LeftName::PrettyTree(Dict<int, bool>* seen) {
90 seen = seen ? seen : Alloc<Dict<int, bool>>();
91 int heap_id = ObjectId(this);
92 if (dict_contains(seen, heap_id)) {
93 return Alloc<hnode::AlreadySeen>(heap_id);
94 }
95 seen->set(heap_id, true);
96 hnode::Record* out_node = runtime::NewRecord(StrFromC("LeftName"));
97 List<Field*>* L = out_node->fields;
98
99 hnode_t* x0 = runtime::NewLeaf(this->name, color_e::StringConst);
100 L->append(Alloc<Field>(StrFromC("name"), x0));
101
102 hnode_t* x1 = this->blame_loc->PrettyTree(seen);
103 L->append(Alloc<Field>(StrFromC("blame_loc"), x1));
104
105 return out_node;
106}
107
108BigStr* y_lvalue_str(int tag, bool dot) {
109 char buf[32];
110 const char* v = nullptr;
111 switch (tag) {
112 case y_lvalue_e::Local:
113 v = "Local"; break;
114 case y_lvalue_e::Container:
115 v = "Container"; break;
116 default:
117 assert(0);
118 }
119 if (dot) {
120 snprintf(buf, 32, "y_lvalue.%s", v);
121 return StrFromC(buf);
122 } else {
123 return StrFromC(v);
124 }
125}
126
127hnode_t* y_lvalue__Container::PrettyTree(Dict<int, bool>* seen) {
128 seen = seen ? seen : Alloc<Dict<int, bool>>();
129 int heap_id = ObjectId(this);
130 if (dict_contains(seen, heap_id)) {
131 return Alloc<hnode::AlreadySeen>(heap_id);
132 }
133 seen->set(heap_id, true);
134 hnode::Record* out_node = runtime::NewRecord(y_lvalue_str(this->tag()));
135 List<Field*>* L = out_node->fields;
136
137 hnode_t* x0 = this->obj->PrettyTree(seen);
138 L->append(Alloc<Field>(StrFromC("obj"), x0));
139
140 hnode_t* x1 = this->index->PrettyTree(seen);
141 L->append(Alloc<Field>(StrFromC("index"), x1));
142
143 return out_node;
144}
145
146
147hnode_t* y_lvalue_t::PrettyTree(Dict<int, bool>* seen) {
148 switch (this->tag()) {
149 case y_lvalue_e::Local: {
150 LeftName* obj = static_cast<LeftName*>(this);
151 return obj->PrettyTree(seen);
152 }
153 case y_lvalue_e::Container: {
154 y_lvalue__Container* obj = static_cast<y_lvalue__Container*>(this);
155 return obj->PrettyTree(seen);
156 }
157 default:
158 assert(0);
159 }
160}
161BigStr* sh_lvalue_str(int tag, bool dot) {
162 char buf[32];
163 const char* v = nullptr;
164 switch (tag) {
165 case sh_lvalue_e::Var:
166 v = "Var"; break;
167 case sh_lvalue_e::Indexed:
168 v = "Indexed"; break;
169 case sh_lvalue_e::Keyed:
170 v = "Keyed"; break;
171 default:
172 assert(0);
173 }
174 if (dot) {
175 snprintf(buf, 32, "sh_lvalue.%s", v);
176 return StrFromC(buf);
177 } else {
178 return StrFromC(v);
179 }
180}
181
182hnode_t* sh_lvalue__Indexed::PrettyTree(Dict<int, bool>* seen) {
183 seen = seen ? seen : Alloc<Dict<int, bool>>();
184 int heap_id = ObjectId(this);
185 if (dict_contains(seen, heap_id)) {
186 return Alloc<hnode::AlreadySeen>(heap_id);
187 }
188 seen->set(heap_id, true);
189 hnode::Record* out_node = runtime::NewRecord(sh_lvalue_str(this->tag()));
190 List<Field*>* L = out_node->fields;
191
192 hnode_t* x0 = runtime::NewLeaf(this->name, color_e::StringConst);
193 L->append(Alloc<Field>(StrFromC("name"), x0));
194
195 hnode_t* x1 = Alloc<hnode::Leaf>(str(this->index), color_e::OtherConst);
196 L->append(Alloc<Field>(StrFromC("index"), x1));
197
198 hnode_t* x2 = this->blame_loc->PrettyTree(seen);
199 L->append(Alloc<Field>(StrFromC("blame_loc"), x2));
200
201 return out_node;
202}
203
204
205hnode_t* sh_lvalue__Keyed::PrettyTree(Dict<int, bool>* seen) {
206 seen = seen ? seen : Alloc<Dict<int, bool>>();
207 int heap_id = ObjectId(this);
208 if (dict_contains(seen, heap_id)) {
209 return Alloc<hnode::AlreadySeen>(heap_id);
210 }
211 seen->set(heap_id, true);
212 hnode::Record* out_node = runtime::NewRecord(sh_lvalue_str(this->tag()));
213 List<Field*>* L = out_node->fields;
214
215 hnode_t* x0 = runtime::NewLeaf(this->name, color_e::StringConst);
216 L->append(Alloc<Field>(StrFromC("name"), x0));
217
218 hnode_t* x1 = runtime::NewLeaf(this->key, color_e::StringConst);
219 L->append(Alloc<Field>(StrFromC("key"), x1));
220
221 hnode_t* x2 = this->blame_loc->PrettyTree(seen);
222 L->append(Alloc<Field>(StrFromC("blame_loc"), x2));
223
224 return out_node;
225}
226
227
228hnode_t* sh_lvalue_t::PrettyTree(Dict<int, bool>* seen) {
229 switch (this->tag()) {
230 case sh_lvalue_e::Var: {
231 LeftName* obj = static_cast<LeftName*>(this);
232 return obj->PrettyTree(seen);
233 }
234 case sh_lvalue_e::Indexed: {
235 sh_lvalue__Indexed* obj = static_cast<sh_lvalue__Indexed*>(this);
236 return obj->PrettyTree(seen);
237 }
238 case sh_lvalue_e::Keyed: {
239 sh_lvalue__Keyed* obj = static_cast<sh_lvalue__Keyed*>(this);
240 return obj->PrettyTree(seen);
241 }
242 default:
243 assert(0);
244 }
245}
246BigStr* eggex_ops_str(int tag, bool dot) {
247 char buf[32];
248 const char* v = nullptr;
249 switch (tag) {
250 case eggex_ops_e::No:
251 v = "No"; break;
252 case eggex_ops_e::Yes:
253 v = "Yes"; break;
254 default:
255 assert(0);
256 }
257 if (dot) {
258 snprintf(buf, 32, "eggex_ops.%s", v);
259 return StrFromC(buf);
260 } else {
261 return StrFromC(v);
262 }
263}
264
265eggex_ops__No* eggex_ops::No = &geggex_ops__No.obj;
266
267GcGlobal<eggex_ops__No> geggex_ops__No =
268 { ObjHeader::Global(eggex_ops_e::No) };
269
270hnode_t* eggex_ops__No::PrettyTree(Dict<int, bool>* seen) {
271 seen = seen ? seen : Alloc<Dict<int, bool>>();
272 int heap_id = ObjectId(this);
273 if (dict_contains(seen, heap_id)) {
274 return Alloc<hnode::AlreadySeen>(heap_id);
275 }
276 seen->set(heap_id, true);
277 hnode::Record* out_node = runtime::NewRecord(eggex_ops_str(this->tag()));
278 return out_node;
279}
280
281
282hnode_t* eggex_ops__Yes::PrettyTree(Dict<int, bool>* seen) {
283 seen = seen ? seen : Alloc<Dict<int, bool>>();
284 int heap_id = ObjectId(this);
285 if (dict_contains(seen, heap_id)) {
286 return Alloc<hnode::AlreadySeen>(heap_id);
287 }
288 seen->set(heap_id, true);
289 hnode::Record* out_node = runtime::NewRecord(eggex_ops_str(this->tag()));
290 List<Field*>* L = out_node->fields;
291
292 if (this->convert_funcs != nullptr) { // List
293 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
294 for (ListIter<value_t*> it(this->convert_funcs); !it.Done(); it.Next()) {
295 value_t* i0 = it.Value();
296 hnode_t* h = (i0 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
297 color_e::OtherConst) : i0->PrettyTree(seen);
298 x0->children->append(h);
299 }
300 L->append(Alloc<Field>(StrFromC("convert_funcs"), x0));
301 }
302
303 if (this->convert_toks != nullptr) { // List
304 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
305 for (ListIter<syntax_asdl::Token*> it(this->convert_toks); !it.Done();
306 it.Next()) {
307 syntax_asdl::Token* i1 = it.Value();
308 hnode_t* h = (i1 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
309 color_e::OtherConst) : i1->PrettyTree(seen);
310 x1->children->append(h);
311 }
312 L->append(Alloc<Field>(StrFromC("convert_toks"), x1));
313 }
314
315 if (this->capture_names != nullptr) { // List
316 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
317 for (ListIter<BigStr*> it(this->capture_names); !it.Done(); it.Next()) {
318 BigStr* i2 = it.Value();
319 x2->children->append(runtime::NewLeaf(i2, color_e::StringConst));
320 }
321 L->append(Alloc<Field>(StrFromC("capture_names"), x2));
322 }
323
324 return out_node;
325}
326
327
328hnode_t* eggex_ops_t::PrettyTree(Dict<int, bool>* seen) {
329 switch (this->tag()) {
330 case eggex_ops_e::No: {
331 eggex_ops__No* obj = static_cast<eggex_ops__No*>(this);
332 return obj->PrettyTree(seen);
333 }
334 case eggex_ops_e::Yes: {
335 eggex_ops__Yes* obj = static_cast<eggex_ops__Yes*>(this);
336 return obj->PrettyTree(seen);
337 }
338 default:
339 assert(0);
340 }
341}
342
343hnode_t* RegexMatch::PrettyTree(Dict<int, bool>* seen) {
344 seen = seen ? seen : Alloc<Dict<int, bool>>();
345 int heap_id = ObjectId(this);
346 if (dict_contains(seen, heap_id)) {
347 return Alloc<hnode::AlreadySeen>(heap_id);
348 }
349 seen->set(heap_id, true);
350 hnode::Record* out_node = runtime::NewRecord(StrFromC("RegexMatch"));
351 List<Field*>* L = out_node->fields;
352
353 hnode_t* x0 = runtime::NewLeaf(this->s, color_e::StringConst);
354 L->append(Alloc<Field>(StrFromC("s"), x0));
355
356 if (this->indices != nullptr) { // List
357 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
358 for (ListIter<int> it(this->indices); !it.Done(); it.Next()) {
359 int i1 = it.Value();
360 x1->children->append(Alloc<hnode::Leaf>(str(i1), color_e::OtherConst));
361 }
362 L->append(Alloc<Field>(StrFromC("indices"), x1));
363 }
364
365 hnode_t* x2 = this->ops->PrettyTree(seen);
366 L->append(Alloc<Field>(StrFromC("ops"), x2));
367
368 return out_node;
369}
370
371BigStr* regex_match_str(int tag, bool dot) {
372 char buf[32];
373 const char* v = nullptr;
374 switch (tag) {
375 case regex_match_e::No:
376 v = "No"; break;
377 case regex_match_e::Yes:
378 v = "Yes"; break;
379 default:
380 assert(0);
381 }
382 if (dot) {
383 snprintf(buf, 32, "regex_match.%s", v);
384 return StrFromC(buf);
385 } else {
386 return StrFromC(v);
387 }
388}
389
390regex_match__No* regex_match::No = &gregex_match__No.obj;
391
392GcGlobal<regex_match__No> gregex_match__No =
393 { ObjHeader::Global(regex_match_e::No) };
394
395hnode_t* regex_match__No::PrettyTree(Dict<int, bool>* seen) {
396 seen = seen ? seen : Alloc<Dict<int, bool>>();
397 int heap_id = ObjectId(this);
398 if (dict_contains(seen, heap_id)) {
399 return Alloc<hnode::AlreadySeen>(heap_id);
400 }
401 seen->set(heap_id, true);
402 hnode::Record* out_node = runtime::NewRecord(regex_match_str(this->tag()));
403 return out_node;
404}
405
406
407hnode_t* regex_match_t::PrettyTree(Dict<int, bool>* seen) {
408 switch (this->tag()) {
409 case regex_match_e::No: {
410 regex_match__No* obj = static_cast<regex_match__No*>(this);
411 return obj->PrettyTree(seen);
412 }
413 case regex_match_e::Yes: {
414 RegexMatch* obj = static_cast<RegexMatch*>(this);
415 return obj->PrettyTree(seen);
416 }
417 default:
418 assert(0);
419 }
420}
421BigStr* block_val_str(int tag, bool dot) {
422 char buf[32];
423 const char* v = nullptr;
424 switch (tag) {
425 case block_val_e::Literal:
426 v = "Literal"; break;
427 case block_val_e::Expr:
428 v = "Expr"; break;
429 default:
430 assert(0);
431 }
432 if (dot) {
433 snprintf(buf, 32, "block_val.%s", v);
434 return StrFromC(buf);
435 } else {
436 return StrFromC(v);
437 }
438}
439
440hnode_t* block_val__Literal::PrettyTree(Dict<int, bool>* seen) {
441 seen = seen ? seen : Alloc<Dict<int, bool>>();
442 int heap_id = ObjectId(this);
443 if (dict_contains(seen, heap_id)) {
444 return Alloc<hnode::AlreadySeen>(heap_id);
445 }
446 seen->set(heap_id, true);
447 hnode::Record* out_node = runtime::NewRecord(block_val_str(this->tag()));
448 List<Field*>* L = out_node->fields;
449
450 hnode_t* x0 = this->b->PrettyTree(seen);
451 L->append(Alloc<Field>(StrFromC("b"), x0));
452
453 return out_node;
454}
455
456
457hnode_t* block_val__Expr::PrettyTree(Dict<int, bool>* seen) {
458 seen = seen ? seen : Alloc<Dict<int, bool>>();
459 int heap_id = ObjectId(this);
460 if (dict_contains(seen, heap_id)) {
461 return Alloc<hnode::AlreadySeen>(heap_id);
462 }
463 seen->set(heap_id, true);
464 hnode::Record* out_node = runtime::NewRecord(block_val_str(this->tag()));
465 List<Field*>* L = out_node->fields;
466
467 hnode_t* x0 = this->c->PrettyTree(seen);
468 L->append(Alloc<Field>(StrFromC("c"), x0));
469
470 return out_node;
471}
472
473
474hnode_t* block_val_t::PrettyTree(Dict<int, bool>* seen) {
475 switch (this->tag()) {
476 case block_val_e::Literal: {
477 block_val__Literal* obj = static_cast<block_val__Literal*>(this);
478 return obj->PrettyTree(seen);
479 }
480 case block_val_e::Expr: {
481 block_val__Expr* obj = static_cast<block_val__Expr*>(this);
482 return obj->PrettyTree(seen);
483 }
484 default:
485 assert(0);
486 }
487}
488
489hnode_t* Obj::PrettyTree(Dict<int, bool>* seen) {
490 seen = seen ? seen : Alloc<Dict<int, bool>>();
491 int heap_id = ObjectId(this);
492 if (dict_contains(seen, heap_id)) {
493 return Alloc<hnode::AlreadySeen>(heap_id);
494 }
495 seen->set(heap_id, true);
496 hnode::Record* out_node = runtime::NewRecord(StrFromC("Obj"));
497 List<Field*>* L = out_node->fields;
498
499 if (this->prototype) { // Optional
500 hnode_t* x0 = this->prototype->PrettyTree(seen);
501 L->append(Alloc<Field>(StrFromC("prototype"), x0));
502 }
503
504 if (this->d) { // Dict
505 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
506 hnode::Array* x1 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
507 for (DictIter<BigStr*, value_t*> it(this->d); !it.Done(); it.Next()) {
508 auto k1 = it.Key();
509 auto v1 = it.Value();
510 x1->children->append(runtime::NewLeaf(k1, color_e::StringConst));
511 x1->children->append(v1->PrettyTree(seen));
512 }
513 L->append(Alloc<Field>(StrFromC ("d"), x1));
514 }
515
516 return out_node;
517}
518
519BigStr* value_str(int tag, bool dot) {
520 char buf[32];
521 const char* v = nullptr;
522 switch (tag) {
523 case value_e::Interrupted:
524 v = "Interrupted"; break;
525 case value_e::Stdin:
526 v = "Stdin"; break;
527 case value_e::Undef:
528 v = "Undef"; break;
529 case value_e::Str:
530 v = "Str"; break;
531 case value_e::BashArray:
532 v = "BashArray"; break;
533 case value_e::SparseArray:
534 v = "SparseArray"; break;
535 case value_e::BashAssoc:
536 v = "BashAssoc"; break;
537 case value_e::Null:
538 v = "Null"; break;
539 case value_e::Bool:
540 v = "Bool"; break;
541 case value_e::Int:
542 v = "Int"; break;
543 case value_e::Float:
544 v = "Float"; break;
545 case value_e::List:
546 v = "List"; break;
547 case value_e::Dict:
548 v = "Dict"; break;
549 case value_e::Obj:
550 v = "Obj"; break;
551 case value_e::Eggex:
552 v = "Eggex"; break;
553 case value_e::Match:
554 v = "Match"; break;
555 case value_e::Expr:
556 v = "Expr"; break;
557 case value_e::Command:
558 v = "Command"; break;
559 case value_e::Block:
560 v = "Block"; break;
561 case value_e::Place:
562 v = "Place"; break;
563 case value_e::Frame:
564 v = "Frame"; break;
565 case value_e::BuiltinFunc:
566 v = "BuiltinFunc"; break;
567 case value_e::BoundFunc:
568 v = "BoundFunc"; break;
569 case value_e::Func:
570 v = "Func"; break;
571 case value_e::BuiltinProc:
572 v = "BuiltinProc"; break;
573 case value_e::Proc:
574 v = "Proc"; break;
575 case value_e::Range:
576 v = "Range"; break;
577 case value_e::Slice:
578 v = "Slice"; break;
579 default:
580 assert(0);
581 }
582 if (dot) {
583 snprintf(buf, 32, "value.%s", v);
584 return StrFromC(buf);
585 } else {
586 return StrFromC(v);
587 }
588}
589
590value__Interrupted* value::Interrupted = &gvalue__Interrupted.obj;
591
592GcGlobal<value__Interrupted> gvalue__Interrupted =
593 { ObjHeader::Global(value_e::Interrupted) };
594
595value__Stdin* value::Stdin = &gvalue__Stdin.obj;
596
597GcGlobal<value__Stdin> gvalue__Stdin =
598 { ObjHeader::Global(value_e::Stdin) };
599
600value__Undef* value::Undef = &gvalue__Undef.obj;
601
602GcGlobal<value__Undef> gvalue__Undef =
603 { ObjHeader::Global(value_e::Undef) };
604
605value__Null* value::Null = &gvalue__Null.obj;
606
607GcGlobal<value__Null> gvalue__Null =
608 { ObjHeader::Global(value_e::Null) };
609
610hnode_t* value__Interrupted::PrettyTree(Dict<int, bool>* seen) {
611 seen = seen ? seen : Alloc<Dict<int, bool>>();
612 int heap_id = ObjectId(this);
613 if (dict_contains(seen, heap_id)) {
614 return Alloc<hnode::AlreadySeen>(heap_id);
615 }
616 seen->set(heap_id, true);
617 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
618 return out_node;
619}
620
621
622hnode_t* value__Stdin::PrettyTree(Dict<int, bool>* seen) {
623 seen = seen ? seen : Alloc<Dict<int, bool>>();
624 int heap_id = ObjectId(this);
625 if (dict_contains(seen, heap_id)) {
626 return Alloc<hnode::AlreadySeen>(heap_id);
627 }
628 seen->set(heap_id, true);
629 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
630 return out_node;
631}
632
633
634hnode_t* value__Undef::PrettyTree(Dict<int, bool>* seen) {
635 seen = seen ? seen : Alloc<Dict<int, bool>>();
636 int heap_id = ObjectId(this);
637 if (dict_contains(seen, heap_id)) {
638 return Alloc<hnode::AlreadySeen>(heap_id);
639 }
640 seen->set(heap_id, true);
641 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
642 return out_node;
643}
644
645
646hnode_t* value__Str::PrettyTree(Dict<int, bool>* seen) {
647 seen = seen ? seen : Alloc<Dict<int, bool>>();
648 int heap_id = ObjectId(this);
649 if (dict_contains(seen, heap_id)) {
650 return Alloc<hnode::AlreadySeen>(heap_id);
651 }
652 seen->set(heap_id, true);
653 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
654 List<Field*>* L = out_node->fields;
655
656 hnode_t* x0 = runtime::NewLeaf(this->s, color_e::StringConst);
657 L->append(Alloc<Field>(StrFromC("s"), x0));
658
659 return out_node;
660}
661
662
663hnode_t* value__BashArray::PrettyTree(Dict<int, bool>* seen) {
664 seen = seen ? seen : Alloc<Dict<int, bool>>();
665 int heap_id = ObjectId(this);
666 if (dict_contains(seen, heap_id)) {
667 return Alloc<hnode::AlreadySeen>(heap_id);
668 }
669 seen->set(heap_id, true);
670 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
671 List<Field*>* L = out_node->fields;
672
673 if (this->strs != nullptr) { // List
674 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
675 for (ListIter<BigStr*> it(this->strs); !it.Done(); it.Next()) {
676 BigStr* i0 = it.Value();
677 x0->children->append(runtime::NewLeaf(i0, color_e::StringConst));
678 }
679 L->append(Alloc<Field>(StrFromC("strs"), x0));
680 }
681
682 return out_node;
683}
684
685
686hnode_t* value__SparseArray::PrettyTree(Dict<int, bool>* seen) {
687 seen = seen ? seen : Alloc<Dict<int, bool>>();
688 int heap_id = ObjectId(this);
689 if (dict_contains(seen, heap_id)) {
690 return Alloc<hnode::AlreadySeen>(heap_id);
691 }
692 seen->set(heap_id, true);
693 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
694 List<Field*>* L = out_node->fields;
695
696 if (this->d) { // Dict
697 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
698 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
699 for (DictIter<mops::BigInt, BigStr*> it(this->d); !it.Done(); it.Next()) {
700 auto k0 = it.Key();
701 auto v0 = it.Value();
702 x0->children->append(Alloc<hnode::Leaf>(mops::ToStr(k0),
703 color_e::OtherConst));
704 x0->children->append(runtime::NewLeaf(v0, color_e::StringConst));
705 }
706 L->append(Alloc<Field>(StrFromC ("d"), x0));
707 }
708
709 hnode_t* x1 = Alloc<hnode::Leaf>(mops::ToStr(this->max_index),
710 color_e::OtherConst);
711 L->append(Alloc<Field>(StrFromC("max_index"), x1));
712
713 return out_node;
714}
715
716
717hnode_t* value__BashAssoc::PrettyTree(Dict<int, bool>* seen) {
718 seen = seen ? seen : Alloc<Dict<int, bool>>();
719 int heap_id = ObjectId(this);
720 if (dict_contains(seen, heap_id)) {
721 return Alloc<hnode::AlreadySeen>(heap_id);
722 }
723 seen->set(heap_id, true);
724 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
725 List<Field*>* L = out_node->fields;
726
727 if (this->d) { // Dict
728 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
729 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
730 for (DictIter<BigStr*, BigStr*> it(this->d); !it.Done(); it.Next()) {
731 auto k0 = it.Key();
732 auto v0 = it.Value();
733 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
734 x0->children->append(runtime::NewLeaf(v0, color_e::StringConst));
735 }
736 L->append(Alloc<Field>(StrFromC ("d"), x0));
737 }
738
739 return out_node;
740}
741
742
743hnode_t* value__Null::PrettyTree(Dict<int, bool>* seen) {
744 seen = seen ? seen : Alloc<Dict<int, bool>>();
745 int heap_id = ObjectId(this);
746 if (dict_contains(seen, heap_id)) {
747 return Alloc<hnode::AlreadySeen>(heap_id);
748 }
749 seen->set(heap_id, true);
750 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
751 return out_node;
752}
753
754
755hnode_t* value__Bool::PrettyTree(Dict<int, bool>* seen) {
756 seen = seen ? seen : Alloc<Dict<int, bool>>();
757 int heap_id = ObjectId(this);
758 if (dict_contains(seen, heap_id)) {
759 return Alloc<hnode::AlreadySeen>(heap_id);
760 }
761 seen->set(heap_id, true);
762 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
763 List<Field*>* L = out_node->fields;
764
765 hnode_t* x0 = Alloc<hnode::Leaf>(this->b ? runtime::TRUE_STR :
766 runtime::FALSE_STR, color_e::OtherConst);
767 L->append(Alloc<Field>(StrFromC("b"), x0));
768
769 return out_node;
770}
771
772
773hnode_t* value__Int::PrettyTree(Dict<int, bool>* seen) {
774 seen = seen ? seen : Alloc<Dict<int, bool>>();
775 int heap_id = ObjectId(this);
776 if (dict_contains(seen, heap_id)) {
777 return Alloc<hnode::AlreadySeen>(heap_id);
778 }
779 seen->set(heap_id, true);
780 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
781 List<Field*>* L = out_node->fields;
782
783 hnode_t* x0 = Alloc<hnode::Leaf>(mops::ToStr(this->i), color_e::OtherConst);
784 L->append(Alloc<Field>(StrFromC("i"), x0));
785
786 return out_node;
787}
788
789
790hnode_t* value__Float::PrettyTree(Dict<int, bool>* seen) {
791 seen = seen ? seen : Alloc<Dict<int, bool>>();
792 int heap_id = ObjectId(this);
793 if (dict_contains(seen, heap_id)) {
794 return Alloc<hnode::AlreadySeen>(heap_id);
795 }
796 seen->set(heap_id, true);
797 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
798 List<Field*>* L = out_node->fields;
799
800 hnode_t* x0 = Alloc<hnode::Leaf>(str(this->f), color_e::OtherConst);
801 L->append(Alloc<Field>(StrFromC("f"), x0));
802
803 return out_node;
804}
805
806
807hnode_t* value__List::PrettyTree(Dict<int, bool>* seen) {
808 seen = seen ? seen : Alloc<Dict<int, bool>>();
809 int heap_id = ObjectId(this);
810 if (dict_contains(seen, heap_id)) {
811 return Alloc<hnode::AlreadySeen>(heap_id);
812 }
813 seen->set(heap_id, true);
814 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
815 List<Field*>* L = out_node->fields;
816
817 if (this->items != nullptr) { // List
818 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
819 for (ListIter<value_t*> it(this->items); !it.Done(); it.Next()) {
820 value_t* i0 = it.Value();
821 hnode_t* h = (i0 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
822 color_e::OtherConst) : i0->PrettyTree(seen);
823 x0->children->append(h);
824 }
825 L->append(Alloc<Field>(StrFromC("items"), x0));
826 }
827
828 return out_node;
829}
830
831
832hnode_t* value__Dict::PrettyTree(Dict<int, bool>* seen) {
833 seen = seen ? seen : Alloc<Dict<int, bool>>();
834 int heap_id = ObjectId(this);
835 if (dict_contains(seen, heap_id)) {
836 return Alloc<hnode::AlreadySeen>(heap_id);
837 }
838 seen->set(heap_id, true);
839 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
840 List<Field*>* L = out_node->fields;
841
842 if (this->d) { // Dict
843 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
844 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
845 for (DictIter<BigStr*, value_t*> it(this->d); !it.Done(); it.Next()) {
846 auto k0 = it.Key();
847 auto v0 = it.Value();
848 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
849 x0->children->append(v0->PrettyTree(seen));
850 }
851 L->append(Alloc<Field>(StrFromC ("d"), x0));
852 }
853
854 return out_node;
855}
856
857
858hnode_t* value__Eggex::PrettyTree(Dict<int, bool>* seen) {
859 seen = seen ? seen : Alloc<Dict<int, bool>>();
860 int heap_id = ObjectId(this);
861 if (dict_contains(seen, heap_id)) {
862 return Alloc<hnode::AlreadySeen>(heap_id);
863 }
864 seen->set(heap_id, true);
865 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
866 List<Field*>* L = out_node->fields;
867
868 hnode_t* x0 = this->spliced->PrettyTree(seen);
869 L->append(Alloc<Field>(StrFromC("spliced"), x0));
870
871 hnode_t* x1 = runtime::NewLeaf(this->canonical_flags, color_e::StringConst);
872 L->append(Alloc<Field>(StrFromC("canonical_flags"), x1));
873
874 if (this->convert_funcs != nullptr) { // List
875 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
876 for (ListIter<value_t*> it(this->convert_funcs); !it.Done(); it.Next()) {
877 value_t* i2 = it.Value();
878 hnode_t* h = (i2 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
879 color_e::OtherConst) : i2->PrettyTree(seen);
880 x2->children->append(h);
881 }
882 L->append(Alloc<Field>(StrFromC("convert_funcs"), x2));
883 }
884
885 if (this->convert_toks != nullptr) { // List
886 hnode::Array* x3 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
887 for (ListIter<syntax_asdl::Token*> it(this->convert_toks); !it.Done();
888 it.Next()) {
889 syntax_asdl::Token* i3 = it.Value();
890 hnode_t* h = (i3 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
891 color_e::OtherConst) : i3->PrettyTree(seen);
892 x3->children->append(h);
893 }
894 L->append(Alloc<Field>(StrFromC("convert_toks"), x3));
895 }
896
897 if (this->as_ere) { // Optional
898 hnode_t* x4 = runtime::NewLeaf(this->as_ere, color_e::StringConst);
899 L->append(Alloc<Field>(StrFromC("as_ere"), x4));
900 }
901
902 if (this->capture_names != nullptr) { // List
903 hnode::Array* x5 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
904 for (ListIter<BigStr*> it(this->capture_names); !it.Done(); it.Next()) {
905 BigStr* i5 = it.Value();
906 x5->children->append(runtime::NewLeaf(i5, color_e::StringConst));
907 }
908 L->append(Alloc<Field>(StrFromC("capture_names"), x5));
909 }
910
911 return out_node;
912}
913
914
915hnode_t* value__Expr::PrettyTree(Dict<int, bool>* seen) {
916 seen = seen ? seen : Alloc<Dict<int, bool>>();
917 int heap_id = ObjectId(this);
918 if (dict_contains(seen, heap_id)) {
919 return Alloc<hnode::AlreadySeen>(heap_id);
920 }
921 seen->set(heap_id, true);
922 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
923 List<Field*>* L = out_node->fields;
924
925 hnode_t* x0 = this->e->PrettyTree(seen);
926 L->append(Alloc<Field>(StrFromC("e"), x0));
927
928 return out_node;
929}
930
931
932hnode_t* value__Command::PrettyTree(Dict<int, bool>* seen) {
933 seen = seen ? seen : Alloc<Dict<int, bool>>();
934 int heap_id = ObjectId(this);
935 if (dict_contains(seen, heap_id)) {
936 return Alloc<hnode::AlreadySeen>(heap_id);
937 }
938 seen->set(heap_id, true);
939 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
940 List<Field*>* L = out_node->fields;
941
942 hnode_t* x0 = this->c->PrettyTree(seen);
943 L->append(Alloc<Field>(StrFromC("c"), x0));
944
945 return out_node;
946}
947
948
949hnode_t* value__Block::PrettyTree(Dict<int, bool>* seen) {
950 seen = seen ? seen : Alloc<Dict<int, bool>>();
951 int heap_id = ObjectId(this);
952 if (dict_contains(seen, heap_id)) {
953 return Alloc<hnode::AlreadySeen>(heap_id);
954 }
955 seen->set(heap_id, true);
956 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
957 List<Field*>* L = out_node->fields;
958
959 hnode_t* x0 = this->block->PrettyTree(seen);
960 L->append(Alloc<Field>(StrFromC("block"), x0));
961
962 if (this->captured_frame) { // Dict
963 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
964 hnode::Array* x1 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
965 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->captured_frame);
966 !it.Done(); it.Next()) {
967 auto k1 = it.Key();
968 auto v1 = it.Value();
969 x1->children->append(runtime::NewLeaf(k1, color_e::StringConst));
970 x1->children->append(v1->PrettyTree(seen));
971 }
972 L->append(Alloc<Field>(StrFromC ("captured_frame"), x1));
973 }
974
975 return out_node;
976}
977
978
979hnode_t* value__Place::PrettyTree(Dict<int, bool>* seen) {
980 seen = seen ? seen : Alloc<Dict<int, bool>>();
981 int heap_id = ObjectId(this);
982 if (dict_contains(seen, heap_id)) {
983 return Alloc<hnode::AlreadySeen>(heap_id);
984 }
985 seen->set(heap_id, true);
986 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
987 List<Field*>* L = out_node->fields;
988
989 hnode_t* x0 = this->lval->PrettyTree(seen);
990 L->append(Alloc<Field>(StrFromC("lval"), x0));
991
992 if (this->frame) { // Dict
993 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
994 hnode::Array* x1 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
995 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->frame); !it.Done();
996 it.Next()) {
997 auto k1 = it.Key();
998 auto v1 = it.Value();
999 x1->children->append(runtime::NewLeaf(k1, color_e::StringConst));
1000 x1->children->append(v1->PrettyTree(seen));
1001 }
1002 L->append(Alloc<Field>(StrFromC ("frame"), x1));
1003 }
1004
1005 return out_node;
1006}
1007
1008
1009hnode_t* value__Frame::PrettyTree(Dict<int, bool>* seen) {
1010 seen = seen ? seen : Alloc<Dict<int, bool>>();
1011 int heap_id = ObjectId(this);
1012 if (dict_contains(seen, heap_id)) {
1013 return Alloc<hnode::AlreadySeen>(heap_id);
1014 }
1015 seen->set(heap_id, true);
1016 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1017 List<Field*>* L = out_node->fields;
1018
1019 if (this->frame) { // Dict
1020 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
1021 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
1022 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->frame); !it.Done();
1023 it.Next()) {
1024 auto k0 = it.Key();
1025 auto v0 = it.Value();
1026 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
1027 x0->children->append(v0->PrettyTree(seen));
1028 }
1029 L->append(Alloc<Field>(StrFromC ("frame"), x0));
1030 }
1031
1032 return out_node;
1033}
1034
1035
1036hnode_t* value__BuiltinFunc::PrettyTree(Dict<int, bool>* seen) {
1037 seen = seen ? seen : Alloc<Dict<int, bool>>();
1038 int heap_id = ObjectId(this);
1039 if (dict_contains(seen, heap_id)) {
1040 return Alloc<hnode::AlreadySeen>(heap_id);
1041 }
1042 seen->set(heap_id, true);
1043 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1044 List<Field*>* L = out_node->fields;
1045
1046 hnode_t* x0 = Alloc<hnode::External>(this->callable);
1047 L->append(Alloc<Field>(StrFromC("callable"), x0));
1048
1049 return out_node;
1050}
1051
1052
1053hnode_t* value__BoundFunc::PrettyTree(Dict<int, bool>* seen) {
1054 seen = seen ? seen : Alloc<Dict<int, bool>>();
1055 int heap_id = ObjectId(this);
1056 if (dict_contains(seen, heap_id)) {
1057 return Alloc<hnode::AlreadySeen>(heap_id);
1058 }
1059 seen->set(heap_id, true);
1060 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1061 List<Field*>* L = out_node->fields;
1062
1063 hnode_t* x0 = this->me->PrettyTree(seen);
1064 L->append(Alloc<Field>(StrFromC("me"), x0));
1065
1066 hnode_t* x1 = this->func->PrettyTree(seen);
1067 L->append(Alloc<Field>(StrFromC("func"), x1));
1068
1069 return out_node;
1070}
1071
1072
1073hnode_t* value__Func::PrettyTree(Dict<int, bool>* seen) {
1074 seen = seen ? seen : Alloc<Dict<int, bool>>();
1075 int heap_id = ObjectId(this);
1076 if (dict_contains(seen, heap_id)) {
1077 return Alloc<hnode::AlreadySeen>(heap_id);
1078 }
1079 seen->set(heap_id, true);
1080 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1081 List<Field*>* L = out_node->fields;
1082
1083 hnode_t* x0 = runtime::NewLeaf(this->name, color_e::StringConst);
1084 L->append(Alloc<Field>(StrFromC("name"), x0));
1085
1086 hnode_t* x1 = this->parsed->PrettyTree(seen);
1087 L->append(Alloc<Field>(StrFromC("parsed"), x1));
1088
1089 if (this->pos_defaults != nullptr) { // List
1090 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
1091 for (ListIter<value_t*> it(this->pos_defaults); !it.Done(); it.Next()) {
1092 value_t* i2 = it.Value();
1093 hnode_t* h = (i2 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
1094 color_e::OtherConst) : i2->PrettyTree(seen);
1095 x2->children->append(h);
1096 }
1097 L->append(Alloc<Field>(StrFromC("pos_defaults"), x2));
1098 }
1099
1100 if (this->named_defaults) { // Dict
1101 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
1102 hnode::Array* x3 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
1103 for (DictIter<BigStr*, value_t*> it(this->named_defaults); !it.Done();
1104 it.Next()) {
1105 auto k3 = it.Key();
1106 auto v3 = it.Value();
1107 x3->children->append(runtime::NewLeaf(k3, color_e::StringConst));
1108 x3->children->append(v3->PrettyTree(seen));
1109 }
1110 L->append(Alloc<Field>(StrFromC ("named_defaults"), x3));
1111 }
1112
1113 if (this->module_frame) { // Dict
1114 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
1115 hnode::Array* x4 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
1116 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_frame);
1117 !it.Done(); it.Next()) {
1118 auto k4 = it.Key();
1119 auto v4 = it.Value();
1120 x4->children->append(runtime::NewLeaf(k4, color_e::StringConst));
1121 x4->children->append(v4->PrettyTree(seen));
1122 }
1123 L->append(Alloc<Field>(StrFromC ("module_frame"), x4));
1124 }
1125
1126 return out_node;
1127}
1128
1129
1130hnode_t* value__BuiltinProc::PrettyTree(Dict<int, bool>* seen) {
1131 seen = seen ? seen : Alloc<Dict<int, bool>>();
1132 int heap_id = ObjectId(this);
1133 if (dict_contains(seen, heap_id)) {
1134 return Alloc<hnode::AlreadySeen>(heap_id);
1135 }
1136 seen->set(heap_id, true);
1137 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1138 List<Field*>* L = out_node->fields;
1139
1140 hnode_t* x0 = Alloc<hnode::External>(this->builtin);
1141 L->append(Alloc<Field>(StrFromC("builtin"), x0));
1142
1143 return out_node;
1144}
1145
1146
1147hnode_t* value__Proc::PrettyTree(Dict<int, bool>* seen) {
1148 seen = seen ? seen : Alloc<Dict<int, bool>>();
1149 int heap_id = ObjectId(this);
1150 if (dict_contains(seen, heap_id)) {
1151 return Alloc<hnode::AlreadySeen>(heap_id);
1152 }
1153 seen->set(heap_id, true);
1154 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1155 List<Field*>* L = out_node->fields;
1156
1157 hnode_t* x0 = runtime::NewLeaf(this->name, color_e::StringConst);
1158 L->append(Alloc<Field>(StrFromC("name"), x0));
1159
1160 hnode_t* x1 = this->name_tok->PrettyTree(seen);
1161 L->append(Alloc<Field>(StrFromC("name_tok"), x1));
1162
1163 hnode_t* x2 = this->sig->PrettyTree(seen);
1164 L->append(Alloc<Field>(StrFromC("sig"), x2));
1165
1166 hnode_t* x3 = this->body->PrettyTree(seen);
1167 L->append(Alloc<Field>(StrFromC("body"), x3));
1168
1169 if (this->defaults) { // Optional
1170 hnode_t* x4 = this->defaults->PrettyTree(seen);
1171 L->append(Alloc<Field>(StrFromC("defaults"), x4));
1172 }
1173
1174 hnode_t* x5 = Alloc<hnode::Leaf>(this->sh_compat ? runtime::TRUE_STR :
1175 runtime::FALSE_STR, color_e::OtherConst);
1176 L->append(Alloc<Field>(StrFromC("sh_compat"), x5));
1177
1178 if (this->module_frame) { // Dict
1179 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
1180 hnode::Array* x6 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
1181 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_frame);
1182 !it.Done(); it.Next()) {
1183 auto k6 = it.Key();
1184 auto v6 = it.Value();
1185 x6->children->append(runtime::NewLeaf(k6, color_e::StringConst));
1186 x6->children->append(v6->PrettyTree(seen));
1187 }
1188 L->append(Alloc<Field>(StrFromC ("module_frame"), x6));
1189 }
1190
1191 return out_node;
1192}
1193
1194
1195hnode_t* value__Range::PrettyTree(Dict<int, bool>* seen) {
1196 seen = seen ? seen : Alloc<Dict<int, bool>>();
1197 int heap_id = ObjectId(this);
1198 if (dict_contains(seen, heap_id)) {
1199 return Alloc<hnode::AlreadySeen>(heap_id);
1200 }
1201 seen->set(heap_id, true);
1202 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1203 List<Field*>* L = out_node->fields;
1204
1205 hnode_t* x0 = Alloc<hnode::Leaf>(str(this->lower), color_e::OtherConst);
1206 L->append(Alloc<Field>(StrFromC("lower"), x0));
1207
1208 hnode_t* x1 = Alloc<hnode::Leaf>(str(this->upper), color_e::OtherConst);
1209 L->append(Alloc<Field>(StrFromC("upper"), x1));
1210
1211 return out_node;
1212}
1213
1214
1215hnode_t* value__Slice::PrettyTree(Dict<int, bool>* seen) {
1216 seen = seen ? seen : Alloc<Dict<int, bool>>();
1217 int heap_id = ObjectId(this);
1218 if (dict_contains(seen, heap_id)) {
1219 return Alloc<hnode::AlreadySeen>(heap_id);
1220 }
1221 seen->set(heap_id, true);
1222 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1223 List<Field*>* L = out_node->fields;
1224
1225 if (this->lower) { // Optional
1226 hnode_t* x0 = this->lower->PrettyTree(seen);
1227 L->append(Alloc<Field>(StrFromC("lower"), x0));
1228 }
1229
1230 if (this->upper) { // Optional
1231 hnode_t* x1 = this->upper->PrettyTree(seen);
1232 L->append(Alloc<Field>(StrFromC("upper"), x1));
1233 }
1234
1235 return out_node;
1236}
1237
1238
1239hnode_t* value_t::PrettyTree(Dict<int, bool>* seen) {
1240 switch (this->tag()) {
1241 case value_e::Interrupted: {
1242 value__Interrupted* obj = static_cast<value__Interrupted*>(this);
1243 return obj->PrettyTree(seen);
1244 }
1245 case value_e::Stdin: {
1246 value__Stdin* obj = static_cast<value__Stdin*>(this);
1247 return obj->PrettyTree(seen);
1248 }
1249 case value_e::Undef: {
1250 value__Undef* obj = static_cast<value__Undef*>(this);
1251 return obj->PrettyTree(seen);
1252 }
1253 case value_e::Str: {
1254 value__Str* obj = static_cast<value__Str*>(this);
1255 return obj->PrettyTree(seen);
1256 }
1257 case value_e::BashArray: {
1258 value__BashArray* obj = static_cast<value__BashArray*>(this);
1259 return obj->PrettyTree(seen);
1260 }
1261 case value_e::SparseArray: {
1262 value__SparseArray* obj = static_cast<value__SparseArray*>(this);
1263 return obj->PrettyTree(seen);
1264 }
1265 case value_e::BashAssoc: {
1266 value__BashAssoc* obj = static_cast<value__BashAssoc*>(this);
1267 return obj->PrettyTree(seen);
1268 }
1269 case value_e::Null: {
1270 value__Null* obj = static_cast<value__Null*>(this);
1271 return obj->PrettyTree(seen);
1272 }
1273 case value_e::Bool: {
1274 value__Bool* obj = static_cast<value__Bool*>(this);
1275 return obj->PrettyTree(seen);
1276 }
1277 case value_e::Int: {
1278 value__Int* obj = static_cast<value__Int*>(this);
1279 return obj->PrettyTree(seen);
1280 }
1281 case value_e::Float: {
1282 value__Float* obj = static_cast<value__Float*>(this);
1283 return obj->PrettyTree(seen);
1284 }
1285 case value_e::List: {
1286 value__List* obj = static_cast<value__List*>(this);
1287 return obj->PrettyTree(seen);
1288 }
1289 case value_e::Dict: {
1290 value__Dict* obj = static_cast<value__Dict*>(this);
1291 return obj->PrettyTree(seen);
1292 }
1293 case value_e::Obj: {
1294 Obj* obj = static_cast<Obj*>(this);
1295 return obj->PrettyTree(seen);
1296 }
1297 case value_e::Eggex: {
1298 value__Eggex* obj = static_cast<value__Eggex*>(this);
1299 return obj->PrettyTree(seen);
1300 }
1301 case value_e::Match: {
1302 RegexMatch* obj = static_cast<RegexMatch*>(this);
1303 return obj->PrettyTree(seen);
1304 }
1305 case value_e::Expr: {
1306 value__Expr* obj = static_cast<value__Expr*>(this);
1307 return obj->PrettyTree(seen);
1308 }
1309 case value_e::Command: {
1310 value__Command* obj = static_cast<value__Command*>(this);
1311 return obj->PrettyTree(seen);
1312 }
1313 case value_e::Block: {
1314 value__Block* obj = static_cast<value__Block*>(this);
1315 return obj->PrettyTree(seen);
1316 }
1317 case value_e::Place: {
1318 value__Place* obj = static_cast<value__Place*>(this);
1319 return obj->PrettyTree(seen);
1320 }
1321 case value_e::Frame: {
1322 value__Frame* obj = static_cast<value__Frame*>(this);
1323 return obj->PrettyTree(seen);
1324 }
1325 case value_e::BuiltinFunc: {
1326 value__BuiltinFunc* obj = static_cast<value__BuiltinFunc*>(this);
1327 return obj->PrettyTree(seen);
1328 }
1329 case value_e::BoundFunc: {
1330 value__BoundFunc* obj = static_cast<value__BoundFunc*>(this);
1331 return obj->PrettyTree(seen);
1332 }
1333 case value_e::Func: {
1334 value__Func* obj = static_cast<value__Func*>(this);
1335 return obj->PrettyTree(seen);
1336 }
1337 case value_e::BuiltinProc: {
1338 value__BuiltinProc* obj = static_cast<value__BuiltinProc*>(this);
1339 return obj->PrettyTree(seen);
1340 }
1341 case value_e::Proc: {
1342 value__Proc* obj = static_cast<value__Proc*>(this);
1343 return obj->PrettyTree(seen);
1344 }
1345 case value_e::Range: {
1346 value__Range* obj = static_cast<value__Range*>(this);
1347 return obj->PrettyTree(seen);
1348 }
1349 case value_e::Slice: {
1350 value__Slice* obj = static_cast<value__Slice*>(this);
1351 return obj->PrettyTree(seen);
1352 }
1353 default:
1354 assert(0);
1355 }
1356}
1357
1358} // namespace value_asdl