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

1295 lines, 906 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}
421
422hnode_t* Dict_::PrettyTree(Dict<int, bool>* seen) {
423 seen = seen ? seen : Alloc<Dict<int, bool>>();
424 int heap_id = ObjectId(this);
425 if (dict_contains(seen, heap_id)) {
426 return Alloc<hnode::AlreadySeen>(heap_id);
427 }
428 seen->set(heap_id, true);
429 hnode::Record* out_node = runtime::NewRecord(StrFromC("Dict_"));
430 List<Field*>* L = out_node->fields;
431
432 if (this->d) { // Dict
433 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
434 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
435 for (DictIter<BigStr*, value_t*> it(this->d); !it.Done(); it.Next()) {
436 auto k0 = it.Key();
437 auto v0 = it.Value();
438 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
439 x0->children->append(v0->PrettyTree(seen));
440 }
441 L->append(Alloc<Field>(StrFromC ("d"), x0));
442 }
443
444 if (this->prototype) { // Optional
445 hnode_t* x1 = this->prototype->PrettyTree(seen);
446 L->append(Alloc<Field>(StrFromC("prototype"), x1));
447 }
448
449 return out_node;
450}
451
452
453hnode_t* Obj::PrettyTree(Dict<int, bool>* seen) {
454 seen = seen ? seen : Alloc<Dict<int, bool>>();
455 int heap_id = ObjectId(this);
456 if (dict_contains(seen, heap_id)) {
457 return Alloc<hnode::AlreadySeen>(heap_id);
458 }
459 seen->set(heap_id, true);
460 hnode::Record* out_node = runtime::NewRecord(StrFromC("Obj"));
461 List<Field*>* L = out_node->fields;
462
463 if (this->d) { // Dict
464 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
465 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
466 for (DictIter<BigStr*, value_t*> it(this->d); !it.Done(); it.Next()) {
467 auto k0 = it.Key();
468 auto v0 = it.Value();
469 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
470 x0->children->append(v0->PrettyTree(seen));
471 }
472 L->append(Alloc<Field>(StrFromC ("d"), x0));
473 }
474
475 if (this->prototype) { // Optional
476 hnode_t* x1 = this->prototype->PrettyTree(seen);
477 L->append(Alloc<Field>(StrFromC("prototype"), x1));
478 }
479
480 return out_node;
481}
482
483BigStr* value_str(int tag, bool dot) {
484 char buf[32];
485 const char* v = nullptr;
486 switch (tag) {
487 case value_e::Interrupted:
488 v = "Interrupted"; break;
489 case value_e::Stdin:
490 v = "Stdin"; break;
491 case value_e::Undef:
492 v = "Undef"; break;
493 case value_e::Str:
494 v = "Str"; break;
495 case value_e::BashArray:
496 v = "BashArray"; break;
497 case value_e::SparseArray:
498 v = "SparseArray"; break;
499 case value_e::BashAssoc:
500 v = "BashAssoc"; break;
501 case value_e::Null:
502 v = "Null"; break;
503 case value_e::Bool:
504 v = "Bool"; break;
505 case value_e::Int:
506 v = "Int"; break;
507 case value_e::Float:
508 v = "Float"; break;
509 case value_e::List:
510 v = "List"; break;
511 case value_e::Dict:
512 v = "Dict"; break;
513 case value_e::Obj:
514 v = "Obj"; break;
515 case value_e::Eggex:
516 v = "Eggex"; break;
517 case value_e::Match:
518 v = "Match"; break;
519 case value_e::Expr:
520 v = "Expr"; break;
521 case value_e::Command:
522 v = "Command"; break;
523 case value_e::Block:
524 v = "Block"; break;
525 case value_e::Place:
526 v = "Place"; break;
527 case value_e::Module:
528 v = "Module"; break;
529 case value_e::IO:
530 v = "IO"; break;
531 case value_e::Guts:
532 v = "Guts"; break;
533 case value_e::BuiltinFunc:
534 v = "BuiltinFunc"; break;
535 case value_e::BoundFunc:
536 v = "BoundFunc"; break;
537 case value_e::Proc:
538 v = "Proc"; break;
539 case value_e::Func:
540 v = "Func"; break;
541 case value_e::Slice:
542 v = "Slice"; break;
543 case value_e::Range:
544 v = "Range"; break;
545 default:
546 assert(0);
547 }
548 if (dot) {
549 snprintf(buf, 32, "value.%s", v);
550 return StrFromC(buf);
551 } else {
552 return StrFromC(v);
553 }
554}
555
556value__Interrupted* value::Interrupted = &gvalue__Interrupted.obj;
557
558GcGlobal<value__Interrupted> gvalue__Interrupted =
559 { ObjHeader::Global(value_e::Interrupted) };
560
561value__Stdin* value::Stdin = &gvalue__Stdin.obj;
562
563GcGlobal<value__Stdin> gvalue__Stdin =
564 { ObjHeader::Global(value_e::Stdin) };
565
566value__Undef* value::Undef = &gvalue__Undef.obj;
567
568GcGlobal<value__Undef> gvalue__Undef =
569 { ObjHeader::Global(value_e::Undef) };
570
571value__Null* value::Null = &gvalue__Null.obj;
572
573GcGlobal<value__Null> gvalue__Null =
574 { ObjHeader::Global(value_e::Null) };
575
576hnode_t* value__Interrupted::PrettyTree(Dict<int, bool>* seen) {
577 seen = seen ? seen : Alloc<Dict<int, bool>>();
578 int heap_id = ObjectId(this);
579 if (dict_contains(seen, heap_id)) {
580 return Alloc<hnode::AlreadySeen>(heap_id);
581 }
582 seen->set(heap_id, true);
583 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
584 return out_node;
585}
586
587
588hnode_t* value__Stdin::PrettyTree(Dict<int, bool>* seen) {
589 seen = seen ? seen : Alloc<Dict<int, bool>>();
590 int heap_id = ObjectId(this);
591 if (dict_contains(seen, heap_id)) {
592 return Alloc<hnode::AlreadySeen>(heap_id);
593 }
594 seen->set(heap_id, true);
595 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
596 return out_node;
597}
598
599
600hnode_t* value__Undef::PrettyTree(Dict<int, bool>* seen) {
601 seen = seen ? seen : Alloc<Dict<int, bool>>();
602 int heap_id = ObjectId(this);
603 if (dict_contains(seen, heap_id)) {
604 return Alloc<hnode::AlreadySeen>(heap_id);
605 }
606 seen->set(heap_id, true);
607 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
608 return out_node;
609}
610
611
612hnode_t* value__Str::PrettyTree(Dict<int, bool>* seen) {
613 seen = seen ? seen : Alloc<Dict<int, bool>>();
614 int heap_id = ObjectId(this);
615 if (dict_contains(seen, heap_id)) {
616 return Alloc<hnode::AlreadySeen>(heap_id);
617 }
618 seen->set(heap_id, true);
619 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
620 List<Field*>* L = out_node->fields;
621
622 hnode_t* x0 = runtime::NewLeaf(this->s, color_e::StringConst);
623 L->append(Alloc<Field>(StrFromC("s"), x0));
624
625 return out_node;
626}
627
628
629hnode_t* value__BashArray::PrettyTree(Dict<int, bool>* seen) {
630 seen = seen ? seen : Alloc<Dict<int, bool>>();
631 int heap_id = ObjectId(this);
632 if (dict_contains(seen, heap_id)) {
633 return Alloc<hnode::AlreadySeen>(heap_id);
634 }
635 seen->set(heap_id, true);
636 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
637 List<Field*>* L = out_node->fields;
638
639 if (this->strs != nullptr) { // List
640 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
641 for (ListIter<BigStr*> it(this->strs); !it.Done(); it.Next()) {
642 BigStr* i0 = it.Value();
643 x0->children->append(runtime::NewLeaf(i0, color_e::StringConst));
644 }
645 L->append(Alloc<Field>(StrFromC("strs"), x0));
646 }
647
648 return out_node;
649}
650
651
652hnode_t* value__SparseArray::PrettyTree(Dict<int, bool>* seen) {
653 seen = seen ? seen : Alloc<Dict<int, bool>>();
654 int heap_id = ObjectId(this);
655 if (dict_contains(seen, heap_id)) {
656 return Alloc<hnode::AlreadySeen>(heap_id);
657 }
658 seen->set(heap_id, true);
659 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
660 List<Field*>* L = out_node->fields;
661
662 if (this->d) { // Dict
663 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
664 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
665 for (DictIter<mops::BigInt, BigStr*> it(this->d); !it.Done(); it.Next()) {
666 auto k0 = it.Key();
667 auto v0 = it.Value();
668 x0->children->append(Alloc<hnode::Leaf>(mops::ToStr(k0),
669 color_e::OtherConst));
670 x0->children->append(runtime::NewLeaf(v0, color_e::StringConst));
671 }
672 L->append(Alloc<Field>(StrFromC ("d"), x0));
673 }
674
675 hnode_t* x1 = Alloc<hnode::Leaf>(mops::ToStr(this->max_index),
676 color_e::OtherConst);
677 L->append(Alloc<Field>(StrFromC("max_index"), x1));
678
679 return out_node;
680}
681
682
683hnode_t* value__BashAssoc::PrettyTree(Dict<int, bool>* seen) {
684 seen = seen ? seen : Alloc<Dict<int, bool>>();
685 int heap_id = ObjectId(this);
686 if (dict_contains(seen, heap_id)) {
687 return Alloc<hnode::AlreadySeen>(heap_id);
688 }
689 seen->set(heap_id, true);
690 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
691 List<Field*>* L = out_node->fields;
692
693 if (this->d) { // Dict
694 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
695 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
696 for (DictIter<BigStr*, BigStr*> it(this->d); !it.Done(); it.Next()) {
697 auto k0 = it.Key();
698 auto v0 = it.Value();
699 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
700 x0->children->append(runtime::NewLeaf(v0, color_e::StringConst));
701 }
702 L->append(Alloc<Field>(StrFromC ("d"), x0));
703 }
704
705 return out_node;
706}
707
708
709hnode_t* value__Null::PrettyTree(Dict<int, bool>* seen) {
710 seen = seen ? seen : Alloc<Dict<int, bool>>();
711 int heap_id = ObjectId(this);
712 if (dict_contains(seen, heap_id)) {
713 return Alloc<hnode::AlreadySeen>(heap_id);
714 }
715 seen->set(heap_id, true);
716 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
717 return out_node;
718}
719
720
721hnode_t* value__Bool::PrettyTree(Dict<int, bool>* seen) {
722 seen = seen ? seen : Alloc<Dict<int, bool>>();
723 int heap_id = ObjectId(this);
724 if (dict_contains(seen, heap_id)) {
725 return Alloc<hnode::AlreadySeen>(heap_id);
726 }
727 seen->set(heap_id, true);
728 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
729 List<Field*>* L = out_node->fields;
730
731 hnode_t* x0 = Alloc<hnode::Leaf>(this->b ? runtime::TRUE_STR :
732 runtime::FALSE_STR, color_e::OtherConst);
733 L->append(Alloc<Field>(StrFromC("b"), x0));
734
735 return out_node;
736}
737
738
739hnode_t* value__Int::PrettyTree(Dict<int, bool>* seen) {
740 seen = seen ? seen : Alloc<Dict<int, bool>>();
741 int heap_id = ObjectId(this);
742 if (dict_contains(seen, heap_id)) {
743 return Alloc<hnode::AlreadySeen>(heap_id);
744 }
745 seen->set(heap_id, true);
746 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
747 List<Field*>* L = out_node->fields;
748
749 hnode_t* x0 = Alloc<hnode::Leaf>(mops::ToStr(this->i), color_e::OtherConst);
750 L->append(Alloc<Field>(StrFromC("i"), x0));
751
752 return out_node;
753}
754
755
756hnode_t* value__Float::PrettyTree(Dict<int, bool>* seen) {
757 seen = seen ? seen : Alloc<Dict<int, bool>>();
758 int heap_id = ObjectId(this);
759 if (dict_contains(seen, heap_id)) {
760 return Alloc<hnode::AlreadySeen>(heap_id);
761 }
762 seen->set(heap_id, true);
763 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
764 List<Field*>* L = out_node->fields;
765
766 hnode_t* x0 = Alloc<hnode::Leaf>(str(this->f), color_e::OtherConst);
767 L->append(Alloc<Field>(StrFromC("f"), x0));
768
769 return out_node;
770}
771
772
773hnode_t* value__List::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 if (this->items != nullptr) { // List
784 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
785 for (ListIter<value_t*> it(this->items); !it.Done(); it.Next()) {
786 value_t* i0 = it.Value();
787 hnode_t* h = (i0 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
788 color_e::OtherConst) : i0->PrettyTree(seen);
789 x0->children->append(h);
790 }
791 L->append(Alloc<Field>(StrFromC("items"), x0));
792 }
793
794 return out_node;
795}
796
797
798hnode_t* value__Eggex::PrettyTree(Dict<int, bool>* seen) {
799 seen = seen ? seen : Alloc<Dict<int, bool>>();
800 int heap_id = ObjectId(this);
801 if (dict_contains(seen, heap_id)) {
802 return Alloc<hnode::AlreadySeen>(heap_id);
803 }
804 seen->set(heap_id, true);
805 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
806 List<Field*>* L = out_node->fields;
807
808 hnode_t* x0 = this->spliced->PrettyTree(seen);
809 L->append(Alloc<Field>(StrFromC("spliced"), x0));
810
811 hnode_t* x1 = runtime::NewLeaf(this->canonical_flags, color_e::StringConst);
812 L->append(Alloc<Field>(StrFromC("canonical_flags"), x1));
813
814 if (this->convert_funcs != nullptr) { // List
815 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
816 for (ListIter<value_t*> it(this->convert_funcs); !it.Done(); it.Next()) {
817 value_t* i2 = it.Value();
818 hnode_t* h = (i2 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
819 color_e::OtherConst) : i2->PrettyTree(seen);
820 x2->children->append(h);
821 }
822 L->append(Alloc<Field>(StrFromC("convert_funcs"), x2));
823 }
824
825 if (this->convert_toks != nullptr) { // List
826 hnode::Array* x3 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
827 for (ListIter<syntax_asdl::Token*> it(this->convert_toks); !it.Done();
828 it.Next()) {
829 syntax_asdl::Token* i3 = it.Value();
830 hnode_t* h = (i3 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
831 color_e::OtherConst) : i3->PrettyTree(seen);
832 x3->children->append(h);
833 }
834 L->append(Alloc<Field>(StrFromC("convert_toks"), x3));
835 }
836
837 if (this->as_ere) { // Optional
838 hnode_t* x4 = runtime::NewLeaf(this->as_ere, color_e::StringConst);
839 L->append(Alloc<Field>(StrFromC("as_ere"), x4));
840 }
841
842 if (this->capture_names != nullptr) { // List
843 hnode::Array* x5 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
844 for (ListIter<BigStr*> it(this->capture_names); !it.Done(); it.Next()) {
845 BigStr* i5 = it.Value();
846 x5->children->append(runtime::NewLeaf(i5, color_e::StringConst));
847 }
848 L->append(Alloc<Field>(StrFromC("capture_names"), x5));
849 }
850
851 return out_node;
852}
853
854
855hnode_t* value__Expr::PrettyTree(Dict<int, bool>* seen) {
856 seen = seen ? seen : Alloc<Dict<int, bool>>();
857 int heap_id = ObjectId(this);
858 if (dict_contains(seen, heap_id)) {
859 return Alloc<hnode::AlreadySeen>(heap_id);
860 }
861 seen->set(heap_id, true);
862 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
863 List<Field*>* L = out_node->fields;
864
865 hnode_t* x0 = this->e->PrettyTree(seen);
866 L->append(Alloc<Field>(StrFromC("e"), x0));
867
868 return out_node;
869}
870
871
872hnode_t* value__Command::PrettyTree(Dict<int, bool>* seen) {
873 seen = seen ? seen : Alloc<Dict<int, bool>>();
874 int heap_id = ObjectId(this);
875 if (dict_contains(seen, heap_id)) {
876 return Alloc<hnode::AlreadySeen>(heap_id);
877 }
878 seen->set(heap_id, true);
879 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
880 List<Field*>* L = out_node->fields;
881
882 hnode_t* x0 = this->c->PrettyTree(seen);
883 L->append(Alloc<Field>(StrFromC("c"), x0));
884
885 return out_node;
886}
887
888
889hnode_t* value__Block::PrettyTree(Dict<int, bool>* seen) {
890 seen = seen ? seen : Alloc<Dict<int, bool>>();
891 int heap_id = ObjectId(this);
892 if (dict_contains(seen, heap_id)) {
893 return Alloc<hnode::AlreadySeen>(heap_id);
894 }
895 seen->set(heap_id, true);
896 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
897 List<Field*>* L = out_node->fields;
898
899 hnode_t* x0 = this->block->PrettyTree(seen);
900 L->append(Alloc<Field>(StrFromC("block"), x0));
901
902 return out_node;
903}
904
905
906hnode_t* value__Place::PrettyTree(Dict<int, bool>* seen) {
907 seen = seen ? seen : Alloc<Dict<int, bool>>();
908 int heap_id = ObjectId(this);
909 if (dict_contains(seen, heap_id)) {
910 return Alloc<hnode::AlreadySeen>(heap_id);
911 }
912 seen->set(heap_id, true);
913 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
914 List<Field*>* L = out_node->fields;
915
916 hnode_t* x0 = this->lval->PrettyTree(seen);
917 L->append(Alloc<Field>(StrFromC("lval"), x0));
918
919 if (this->frame) { // Dict
920 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
921 hnode::Array* x1 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
922 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->frame); !it.Done();
923 it.Next()) {
924 auto k1 = it.Key();
925 auto v1 = it.Value();
926 x1->children->append(runtime::NewLeaf(k1, color_e::StringConst));
927 x1->children->append(v1->PrettyTree(seen));
928 }
929 L->append(Alloc<Field>(StrFromC ("frame"), x1));
930 }
931
932 return out_node;
933}
934
935
936hnode_t* value__Module::PrettyTree(Dict<int, bool>* seen) {
937 seen = seen ? seen : Alloc<Dict<int, bool>>();
938 int heap_id = ObjectId(this);
939 if (dict_contains(seen, heap_id)) {
940 return Alloc<hnode::AlreadySeen>(heap_id);
941 }
942 seen->set(heap_id, true);
943 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
944 List<Field*>* L = out_node->fields;
945
946 if (this->defs) { // Dict
947 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
948 hnode::Array* x0 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
949 for (DictIter<BigStr*, value_t*> it(this->defs); !it.Done(); it.Next()) {
950 auto k0 = it.Key();
951 auto v0 = it.Value();
952 x0->children->append(runtime::NewLeaf(k0, color_e::StringConst));
953 x0->children->append(v0->PrettyTree(seen));
954 }
955 L->append(Alloc<Field>(StrFromC ("defs"), x0));
956 }
957
958 return out_node;
959}
960
961
962hnode_t* value__IO::PrettyTree(Dict<int, bool>* seen) {
963 seen = seen ? seen : Alloc<Dict<int, bool>>();
964 int heap_id = ObjectId(this);
965 if (dict_contains(seen, heap_id)) {
966 return Alloc<hnode::AlreadySeen>(heap_id);
967 }
968 seen->set(heap_id, true);
969 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
970 List<Field*>* L = out_node->fields;
971
972 hnode_t* x0 = Alloc<hnode::External>(this->cmd_ev);
973 L->append(Alloc<Field>(StrFromC("cmd_ev"), x0));
974
975 hnode_t* x1 = Alloc<hnode::External>(this->prompt_ev);
976 L->append(Alloc<Field>(StrFromC("prompt_ev"), x1));
977
978 return out_node;
979}
980
981
982hnode_t* value__Guts::PrettyTree(Dict<int, bool>* seen) {
983 seen = seen ? seen : Alloc<Dict<int, bool>>();
984 int heap_id = ObjectId(this);
985 if (dict_contains(seen, heap_id)) {
986 return Alloc<hnode::AlreadySeen>(heap_id);
987 }
988 seen->set(heap_id, true);
989 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
990 List<Field*>* L = out_node->fields;
991
992 hnode_t* x0 = Alloc<hnode::External>(this->vm);
993 L->append(Alloc<Field>(StrFromC("vm"), x0));
994
995 return out_node;
996}
997
998
999hnode_t* value__BuiltinFunc::PrettyTree(Dict<int, bool>* seen) {
1000 seen = seen ? seen : Alloc<Dict<int, bool>>();
1001 int heap_id = ObjectId(this);
1002 if (dict_contains(seen, heap_id)) {
1003 return Alloc<hnode::AlreadySeen>(heap_id);
1004 }
1005 seen->set(heap_id, true);
1006 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1007 List<Field*>* L = out_node->fields;
1008
1009 hnode_t* x0 = Alloc<hnode::External>(this->callable);
1010 L->append(Alloc<Field>(StrFromC("callable"), x0));
1011
1012 return out_node;
1013}
1014
1015
1016hnode_t* value__BoundFunc::PrettyTree(Dict<int, bool>* seen) {
1017 seen = seen ? seen : Alloc<Dict<int, bool>>();
1018 int heap_id = ObjectId(this);
1019 if (dict_contains(seen, heap_id)) {
1020 return Alloc<hnode::AlreadySeen>(heap_id);
1021 }
1022 seen->set(heap_id, true);
1023 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1024 List<Field*>* L = out_node->fields;
1025
1026 hnode_t* x0 = this->me->PrettyTree(seen);
1027 L->append(Alloc<Field>(StrFromC("me"), x0));
1028
1029 hnode_t* x1 = this->func->PrettyTree(seen);
1030 L->append(Alloc<Field>(StrFromC("func"), x1));
1031
1032 return out_node;
1033}
1034
1035
1036hnode_t* value__Proc::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 = runtime::NewLeaf(this->name, color_e::StringConst);
1047 L->append(Alloc<Field>(StrFromC("name"), x0));
1048
1049 hnode_t* x1 = this->name_tok->PrettyTree(seen);
1050 L->append(Alloc<Field>(StrFromC("name_tok"), x1));
1051
1052 hnode_t* x2 = this->sig->PrettyTree(seen);
1053 L->append(Alloc<Field>(StrFromC("sig"), x2));
1054
1055 hnode_t* x3 = this->body->PrettyTree(seen);
1056 L->append(Alloc<Field>(StrFromC("body"), x3));
1057
1058 if (this->defaults) { // Optional
1059 hnode_t* x4 = this->defaults->PrettyTree(seen);
1060 L->append(Alloc<Field>(StrFromC("defaults"), x4));
1061 }
1062
1063 hnode_t* x5 = Alloc<hnode::Leaf>(this->sh_compat ? runtime::TRUE_STR :
1064 runtime::FALSE_STR, color_e::OtherConst);
1065 L->append(Alloc<Field>(StrFromC("sh_compat"), x5));
1066
1067 return out_node;
1068}
1069
1070
1071hnode_t* value__Func::PrettyTree(Dict<int, bool>* seen) {
1072 seen = seen ? seen : Alloc<Dict<int, bool>>();
1073 int heap_id = ObjectId(this);
1074 if (dict_contains(seen, heap_id)) {
1075 return Alloc<hnode::AlreadySeen>(heap_id);
1076 }
1077 seen->set(heap_id, true);
1078 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1079 List<Field*>* L = out_node->fields;
1080
1081 hnode_t* x0 = runtime::NewLeaf(this->name, color_e::StringConst);
1082 L->append(Alloc<Field>(StrFromC("name"), x0));
1083
1084 hnode_t* x1 = this->parsed->PrettyTree(seen);
1085 L->append(Alloc<Field>(StrFromC("parsed"), x1));
1086
1087 if (this->pos_defaults != nullptr) { // List
1088 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
1089 for (ListIter<value_t*> it(this->pos_defaults); !it.Done(); it.Next()) {
1090 value_t* i2 = it.Value();
1091 hnode_t* h = (i2 == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
1092 color_e::OtherConst) : i2->PrettyTree(seen);
1093 x2->children->append(h);
1094 }
1095 L->append(Alloc<Field>(StrFromC("pos_defaults"), x2));
1096 }
1097
1098 if (this->named_defaults) { // Dict
1099 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
1100 hnode::Array* x3 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
1101 for (DictIter<BigStr*, value_t*> it(this->named_defaults); !it.Done();
1102 it.Next()) {
1103 auto k3 = it.Key();
1104 auto v3 = it.Value();
1105 x3->children->append(runtime::NewLeaf(k3, color_e::StringConst));
1106 x3->children->append(v3->PrettyTree(seen));
1107 }
1108 L->append(Alloc<Field>(StrFromC ("named_defaults"), x3));
1109 }
1110
1111 if (this->module_) { // Dict
1112 auto m = Alloc<hnode::Leaf>(StrFromC("Dict"), color_e::OtherConst);
1113 hnode::Array* x4 = Alloc<hnode::Array>(NewList<hnode_t*>({m}));
1114 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_); !it.Done();
1115 it.Next()) {
1116 auto k4 = it.Key();
1117 auto v4 = it.Value();
1118 x4->children->append(runtime::NewLeaf(k4, color_e::StringConst));
1119 x4->children->append(v4->PrettyTree(seen));
1120 }
1121 L->append(Alloc<Field>(StrFromC ("module_"), x4));
1122 }
1123
1124 return out_node;
1125}
1126
1127
1128hnode_t* value__Slice::PrettyTree(Dict<int, bool>* seen) {
1129 seen = seen ? seen : Alloc<Dict<int, bool>>();
1130 int heap_id = ObjectId(this);
1131 if (dict_contains(seen, heap_id)) {
1132 return Alloc<hnode::AlreadySeen>(heap_id);
1133 }
1134 seen->set(heap_id, true);
1135 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1136 List<Field*>* L = out_node->fields;
1137
1138 if (this->lower) { // Optional
1139 hnode_t* x0 = this->lower->PrettyTree(seen);
1140 L->append(Alloc<Field>(StrFromC("lower"), x0));
1141 }
1142
1143 if (this->upper) { // Optional
1144 hnode_t* x1 = this->upper->PrettyTree(seen);
1145 L->append(Alloc<Field>(StrFromC("upper"), x1));
1146 }
1147
1148 return out_node;
1149}
1150
1151
1152hnode_t* value__Range::PrettyTree(Dict<int, bool>* seen) {
1153 seen = seen ? seen : Alloc<Dict<int, bool>>();
1154 int heap_id = ObjectId(this);
1155 if (dict_contains(seen, heap_id)) {
1156 return Alloc<hnode::AlreadySeen>(heap_id);
1157 }
1158 seen->set(heap_id, true);
1159 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1160 List<Field*>* L = out_node->fields;
1161
1162 hnode_t* x0 = Alloc<hnode::Leaf>(str(this->lower), color_e::OtherConst);
1163 L->append(Alloc<Field>(StrFromC("lower"), x0));
1164
1165 hnode_t* x1 = Alloc<hnode::Leaf>(str(this->upper), color_e::OtherConst);
1166 L->append(Alloc<Field>(StrFromC("upper"), x1));
1167
1168 return out_node;
1169}
1170
1171
1172hnode_t* value_t::PrettyTree(Dict<int, bool>* seen) {
1173 switch (this->tag()) {
1174 case value_e::Interrupted: {
1175 value__Interrupted* obj = static_cast<value__Interrupted*>(this);
1176 return obj->PrettyTree(seen);
1177 }
1178 case value_e::Stdin: {
1179 value__Stdin* obj = static_cast<value__Stdin*>(this);
1180 return obj->PrettyTree(seen);
1181 }
1182 case value_e::Undef: {
1183 value__Undef* obj = static_cast<value__Undef*>(this);
1184 return obj->PrettyTree(seen);
1185 }
1186 case value_e::Str: {
1187 value__Str* obj = static_cast<value__Str*>(this);
1188 return obj->PrettyTree(seen);
1189 }
1190 case value_e::BashArray: {
1191 value__BashArray* obj = static_cast<value__BashArray*>(this);
1192 return obj->PrettyTree(seen);
1193 }
1194 case value_e::SparseArray: {
1195 value__SparseArray* obj = static_cast<value__SparseArray*>(this);
1196 return obj->PrettyTree(seen);
1197 }
1198 case value_e::BashAssoc: {
1199 value__BashAssoc* obj = static_cast<value__BashAssoc*>(this);
1200 return obj->PrettyTree(seen);
1201 }
1202 case value_e::Null: {
1203 value__Null* obj = static_cast<value__Null*>(this);
1204 return obj->PrettyTree(seen);
1205 }
1206 case value_e::Bool: {
1207 value__Bool* obj = static_cast<value__Bool*>(this);
1208 return obj->PrettyTree(seen);
1209 }
1210 case value_e::Int: {
1211 value__Int* obj = static_cast<value__Int*>(this);
1212 return obj->PrettyTree(seen);
1213 }
1214 case value_e::Float: {
1215 value__Float* obj = static_cast<value__Float*>(this);
1216 return obj->PrettyTree(seen);
1217 }
1218 case value_e::List: {
1219 value__List* obj = static_cast<value__List*>(this);
1220 return obj->PrettyTree(seen);
1221 }
1222 case value_e::Dict: {
1223 Dict_* obj = static_cast<Dict_*>(this);
1224 return obj->PrettyTree(seen);
1225 }
1226 case value_e::Obj: {
1227 Obj* obj = static_cast<Obj*>(this);
1228 return obj->PrettyTree(seen);
1229 }
1230 case value_e::Eggex: {
1231 value__Eggex* obj = static_cast<value__Eggex*>(this);
1232 return obj->PrettyTree(seen);
1233 }
1234 case value_e::Match: {
1235 RegexMatch* obj = static_cast<RegexMatch*>(this);
1236 return obj->PrettyTree(seen);
1237 }
1238 case value_e::Expr: {
1239 value__Expr* obj = static_cast<value__Expr*>(this);
1240 return obj->PrettyTree(seen);
1241 }
1242 case value_e::Command: {
1243 value__Command* obj = static_cast<value__Command*>(this);
1244 return obj->PrettyTree(seen);
1245 }
1246 case value_e::Block: {
1247 value__Block* obj = static_cast<value__Block*>(this);
1248 return obj->PrettyTree(seen);
1249 }
1250 case value_e::Place: {
1251 value__Place* obj = static_cast<value__Place*>(this);
1252 return obj->PrettyTree(seen);
1253 }
1254 case value_e::Module: {
1255 value__Module* obj = static_cast<value__Module*>(this);
1256 return obj->PrettyTree(seen);
1257 }
1258 case value_e::IO: {
1259 value__IO* obj = static_cast<value__IO*>(this);
1260 return obj->PrettyTree(seen);
1261 }
1262 case value_e::Guts: {
1263 value__Guts* obj = static_cast<value__Guts*>(this);
1264 return obj->PrettyTree(seen);
1265 }
1266 case value_e::BuiltinFunc: {
1267 value__BuiltinFunc* obj = static_cast<value__BuiltinFunc*>(this);
1268 return obj->PrettyTree(seen);
1269 }
1270 case value_e::BoundFunc: {
1271 value__BoundFunc* obj = static_cast<value__BoundFunc*>(this);
1272 return obj->PrettyTree(seen);
1273 }
1274 case value_e::Proc: {
1275 value__Proc* obj = static_cast<value__Proc*>(this);
1276 return obj->PrettyTree(seen);
1277 }
1278 case value_e::Func: {
1279 value__Func* obj = static_cast<value__Func*>(this);
1280 return obj->PrettyTree(seen);
1281 }
1282 case value_e::Slice: {
1283 value__Slice* obj = static_cast<value__Slice*>(this);
1284 return obj->PrettyTree(seen);
1285 }
1286 case value_e::Range: {
1287 value__Range* obj = static_cast<value__Range*>(this);
1288 return obj->PrettyTree(seen);
1289 }
1290 default:
1291 assert(0);
1292 }
1293}
1294
1295} // namespace value_asdl