OILS / _gen / core / value.asdl.cc View on Github | oils.pub

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