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

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