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

1516 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" // 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* Obj::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("Obj"));
472 List<Field*>* L = out_node->fields;
473
474 if (this->prototype) { // Optional
475 hnode_t* x0 = this->prototype->PrettyTree(do_abbrev, seen);
476 L->append(Alloc<Field>(StrFromC("prototype"), x0));
477 }
478
479 if (this->d != nullptr) { // Dict
480 auto* unnamed = NewList<hnode_t*>();
481 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
482 StrFromC("}"),
483 NewList<Field*>(), unnamed);
484 for (DictIter<BigStr*, value_t*> it(this->d); !it.Done(); it.Next()) {
485 auto k = it.Key();
486 auto v = it.Value();
487 unnamed->append(ToPretty(k));
488 unnamed->append(v->PrettyTree(do_abbrev, seen));
489 }
490 L->append(Alloc<Field>(StrFromC("d"), hdict));
491 }
492
493 return out_node;
494}
495
496BigStr* value_str(int tag, bool dot) {
497 char buf[32];
498 const char* v = nullptr;
499 switch (tag) {
500 case value_e::Interrupted:
501 v = "Interrupted"; break;
502 case value_e::Stdin:
503 v = "Stdin"; break;
504 case value_e::Slice:
505 v = "Slice"; break;
506 case value_e::Undef:
507 v = "Undef"; break;
508 case value_e::Str:
509 v = "Str"; break;
510 case value_e::InitializerList:
511 v = "InitializerList"; break;
512 case value_e::InternalStringArray:
513 v = "InternalStringArray"; break;
514 case value_e::BashArray:
515 v = "BashArray"; break;
516 case value_e::BashAssoc:
517 v = "BashAssoc"; break;
518 case value_e::Null:
519 v = "Null"; break;
520 case value_e::Bool:
521 v = "Bool"; break;
522 case value_e::Int:
523 v = "Int"; break;
524 case value_e::Float:
525 v = "Float"; break;
526 case value_e::List:
527 v = "List"; break;
528 case value_e::Dict:
529 v = "Dict"; break;
530 case value_e::Obj:
531 v = "Obj"; break;
532 case value_e::Range:
533 v = "Range"; break;
534 case value_e::Eggex:
535 v = "Eggex"; break;
536 case value_e::Match:
537 v = "Match"; break;
538 case value_e::Place:
539 v = "Place"; break;
540 case value_e::Frame:
541 v = "Frame"; break;
542 case value_e::DebugFrame:
543 v = "DebugFrame"; break;
544 case value_e::BoundFunc:
545 v = "BoundFunc"; break;
546 case value_e::BuiltinFunc:
547 v = "BuiltinFunc"; break;
548 case value_e::Func:
549 v = "Func"; break;
550 case value_e::BuiltinProc:
551 v = "BuiltinProc"; break;
552 case value_e::Proc:
553 v = "Proc"; break;
554 case value_e::Expr:
555 v = "Expr"; break;
556 case value_e::CommandFrag:
557 v = "CommandFrag"; break;
558 case value_e::Command:
559 v = "Command"; break;
560 default:
561 assert(0);
562 }
563 if (dot) {
564 snprintf(buf, 32, "value.%s", v);
565 return StrFromC(buf);
566 } else {
567 return StrFromC(v);
568 }
569}
570
571value__Interrupted* value::Interrupted = &gvalue__Interrupted.obj;
572
573GcGlobal<value__Interrupted> gvalue__Interrupted =
574 { ObjHeader::Global(value_e::Interrupted) };
575
576value__Stdin* value::Stdin = &gvalue__Stdin.obj;
577
578GcGlobal<value__Stdin> gvalue__Stdin =
579 { ObjHeader::Global(value_e::Stdin) };
580
581value__Undef* value::Undef = &gvalue__Undef.obj;
582
583GcGlobal<value__Undef> gvalue__Undef =
584 { ObjHeader::Global(value_e::Undef) };
585
586value__Null* value::Null = &gvalue__Null.obj;
587
588GcGlobal<value__Null> gvalue__Null =
589 { ObjHeader::Global(value_e::Null) };
590
591hnode_t* value__Interrupted::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
592 seen = seen ? seen : Alloc<Dict<int, bool>>();
593 int heap_id = ObjectId(this);
594 if (dict_contains(seen, heap_id)) {
595 return Alloc<hnode::AlreadySeen>(heap_id);
596 }
597 seen->set(heap_id, true);
598
599 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
600 return out_node;
601}
602
603
604hnode_t* value__Stdin::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
605 seen = seen ? seen : Alloc<Dict<int, bool>>();
606 int heap_id = ObjectId(this);
607 if (dict_contains(seen, heap_id)) {
608 return Alloc<hnode::AlreadySeen>(heap_id);
609 }
610 seen->set(heap_id, true);
611
612 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
613 return out_node;
614}
615
616
617hnode_t* value__Slice::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
618 seen = seen ? seen : Alloc<Dict<int, bool>>();
619 int heap_id = ObjectId(this);
620 if (dict_contains(seen, heap_id)) {
621 return Alloc<hnode::AlreadySeen>(heap_id);
622 }
623 seen->set(heap_id, true);
624
625 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
626 List<Field*>* L = out_node->fields;
627
628 if (this->lower) { // Optional
629 hnode_t* x0 = this->lower->PrettyTree(do_abbrev, seen);
630 L->append(Alloc<Field>(StrFromC("lower"), x0));
631 }
632
633 if (this->upper) { // Optional
634 hnode_t* x1 = this->upper->PrettyTree(do_abbrev, seen);
635 L->append(Alloc<Field>(StrFromC("upper"), x1));
636 }
637
638 return out_node;
639}
640
641
642hnode_t* value__Undef::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
643 seen = seen ? seen : Alloc<Dict<int, bool>>();
644 int heap_id = ObjectId(this);
645 if (dict_contains(seen, heap_id)) {
646 return Alloc<hnode::AlreadySeen>(heap_id);
647 }
648 seen->set(heap_id, true);
649
650 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
651 return out_node;
652}
653
654
655hnode_t* value__Str::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
656 seen = seen ? seen : Alloc<Dict<int, bool>>();
657 int heap_id = ObjectId(this);
658 if (dict_contains(seen, heap_id)) {
659 return Alloc<hnode::AlreadySeen>(heap_id);
660 }
661 seen->set(heap_id, true);
662
663 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
664 List<Field*>* L = out_node->fields;
665
666 hnode_t* x0 = ToPretty(this->s);
667 L->append(Alloc<Field>(StrFromC("s"), x0));
668
669 return out_node;
670}
671
672
673hnode_t* value__InitializerList::PrettyTree(bool do_abbrev, Dict<int, bool>*
674 seen) {
675 seen = seen ? seen : Alloc<Dict<int, bool>>();
676 int heap_id = ObjectId(this);
677 if (dict_contains(seen, heap_id)) {
678 return Alloc<hnode::AlreadySeen>(heap_id);
679 }
680 seen->set(heap_id, true);
681
682 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
683 List<Field*>* L = out_node->fields;
684
685 if (this->assigns != nullptr) { // List
686 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
687 for (ListIter<InitializerValue*> it(this->assigns); !it.Done(); it.Next()) {
688 InitializerValue* v_ = it.Value();
689 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
690 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
691 x0->children->append(h);
692 }
693 L->append(Alloc<Field>(StrFromC("assigns"), x0));
694 }
695
696 return out_node;
697}
698
699
700hnode_t* value__InternalStringArray::PrettyTree(bool do_abbrev, Dict<int,
701 bool>* seen) {
702 seen = seen ? seen : Alloc<Dict<int, bool>>();
703 int heap_id = ObjectId(this);
704 if (dict_contains(seen, heap_id)) {
705 return Alloc<hnode::AlreadySeen>(heap_id);
706 }
707 seen->set(heap_id, true);
708
709 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
710 List<Field*>* L = out_node->fields;
711
712 if (this->strs != nullptr) { // List
713 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
714 for (ListIter<BigStr*> it(this->strs); !it.Done(); it.Next()) {
715 BigStr* v_ = it.Value();
716 hnode_t* h = ToPretty(v_);
717 x0->children->append(h);
718 }
719 L->append(Alloc<Field>(StrFromC("strs"), x0));
720 }
721
722 return out_node;
723}
724
725
726hnode_t* value__BashArray::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
727 seen = seen ? seen : Alloc<Dict<int, bool>>();
728 int heap_id = ObjectId(this);
729 if (dict_contains(seen, heap_id)) {
730 return Alloc<hnode::AlreadySeen>(heap_id);
731 }
732 seen->set(heap_id, true);
733
734 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
735 List<Field*>* L = out_node->fields;
736
737 if (this->d != nullptr) { // Dict
738 auto* unnamed = NewList<hnode_t*>();
739 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
740 StrFromC("}"),
741 NewList<Field*>(), unnamed);
742 for (DictIter<mops::BigInt, BigStr*> it(this->d); !it.Done(); it.Next()) {
743 auto k = it.Key();
744 auto v = it.Value();
745 unnamed->append(ToPretty(k));
746 unnamed->append(ToPretty(v));
747 }
748 L->append(Alloc<Field>(StrFromC("d"), hdict));
749 }
750
751 hnode_t* x1 = ToPretty(this->max_index);
752 L->append(Alloc<Field>(StrFromC("max_index"), x1));
753
754 return out_node;
755}
756
757
758hnode_t* value__BashAssoc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
759 seen = seen ? seen : Alloc<Dict<int, bool>>();
760 int heap_id = ObjectId(this);
761 if (dict_contains(seen, heap_id)) {
762 return Alloc<hnode::AlreadySeen>(heap_id);
763 }
764 seen->set(heap_id, true);
765
766 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
767 List<Field*>* L = out_node->fields;
768
769 if (this->d != nullptr) { // Dict
770 auto* unnamed = NewList<hnode_t*>();
771 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
772 StrFromC("}"),
773 NewList<Field*>(), unnamed);
774 for (DictIter<BigStr*, BigStr*> it(this->d); !it.Done(); it.Next()) {
775 auto k = it.Key();
776 auto v = it.Value();
777 unnamed->append(ToPretty(k));
778 unnamed->append(ToPretty(v));
779 }
780 L->append(Alloc<Field>(StrFromC("d"), hdict));
781 }
782
783 return out_node;
784}
785
786
787hnode_t* value__Null::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
788 seen = seen ? seen : Alloc<Dict<int, bool>>();
789 int heap_id = ObjectId(this);
790 if (dict_contains(seen, heap_id)) {
791 return Alloc<hnode::AlreadySeen>(heap_id);
792 }
793 seen->set(heap_id, true);
794
795 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
796 return out_node;
797}
798
799
800hnode_t* value__Bool::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 hnode_t* x0 = ToPretty(this->b);
812 L->append(Alloc<Field>(StrFromC("b"), x0));
813
814 return out_node;
815}
816
817
818hnode_t* value__Int::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
819 seen = seen ? seen : Alloc<Dict<int, bool>>();
820 int heap_id = ObjectId(this);
821 if (dict_contains(seen, heap_id)) {
822 return Alloc<hnode::AlreadySeen>(heap_id);
823 }
824 seen->set(heap_id, true);
825
826 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
827 List<Field*>* L = out_node->fields;
828
829 hnode_t* x0 = ToPretty(this->i);
830 L->append(Alloc<Field>(StrFromC("i"), x0));
831
832 return out_node;
833}
834
835
836hnode_t* value__Float::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
837 seen = seen ? seen : Alloc<Dict<int, bool>>();
838 int heap_id = ObjectId(this);
839 if (dict_contains(seen, heap_id)) {
840 return Alloc<hnode::AlreadySeen>(heap_id);
841 }
842 seen->set(heap_id, true);
843
844 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
845 List<Field*>* L = out_node->fields;
846
847 hnode_t* x0 = ToPretty(this->f);
848 L->append(Alloc<Field>(StrFromC("f"), x0));
849
850 return out_node;
851}
852
853
854hnode_t* value__List::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
855 seen = seen ? seen : Alloc<Dict<int, bool>>();
856 int heap_id = ObjectId(this);
857 if (dict_contains(seen, heap_id)) {
858 return Alloc<hnode::AlreadySeen>(heap_id);
859 }
860 seen->set(heap_id, true);
861
862 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
863 List<Field*>* L = out_node->fields;
864
865 if (this->items != nullptr) { // List
866 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
867 for (ListIter<value_t*> it(this->items); !it.Done(); it.Next()) {
868 value_t* v_ = it.Value();
869 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
870 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
871 x0->children->append(h);
872 }
873 L->append(Alloc<Field>(StrFromC("items"), x0));
874 }
875
876 return out_node;
877}
878
879
880hnode_t* value__Dict::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
881 seen = seen ? seen : Alloc<Dict<int, bool>>();
882 int heap_id = ObjectId(this);
883 if (dict_contains(seen, heap_id)) {
884 return Alloc<hnode::AlreadySeen>(heap_id);
885 }
886 seen->set(heap_id, true);
887
888 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
889 List<Field*>* L = out_node->fields;
890
891 if (this->d != nullptr) { // Dict
892 auto* unnamed = NewList<hnode_t*>();
893 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
894 StrFromC("}"),
895 NewList<Field*>(), unnamed);
896 for (DictIter<BigStr*, value_t*> it(this->d); !it.Done(); it.Next()) {
897 auto k = it.Key();
898 auto v = it.Value();
899 unnamed->append(ToPretty(k));
900 unnamed->append(v->PrettyTree(do_abbrev, seen));
901 }
902 L->append(Alloc<Field>(StrFromC("d"), hdict));
903 }
904
905 return out_node;
906}
907
908
909hnode_t* value__Range::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
910 seen = seen ? seen : Alloc<Dict<int, bool>>();
911 int heap_id = ObjectId(this);
912 if (dict_contains(seen, heap_id)) {
913 return Alloc<hnode::AlreadySeen>(heap_id);
914 }
915 seen->set(heap_id, true);
916
917 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
918 List<Field*>* L = out_node->fields;
919
920 hnode_t* x0 = ToPretty(this->lower);
921 L->append(Alloc<Field>(StrFromC("lower"), x0));
922
923 hnode_t* x1 = ToPretty(this->upper);
924 L->append(Alloc<Field>(StrFromC("upper"), x1));
925
926 return out_node;
927}
928
929
930hnode_t* value__Eggex::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
931 seen = seen ? seen : Alloc<Dict<int, bool>>();
932 int heap_id = ObjectId(this);
933 if (dict_contains(seen, heap_id)) {
934 return Alloc<hnode::AlreadySeen>(heap_id);
935 }
936 seen->set(heap_id, true);
937
938 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
939 List<Field*>* L = out_node->fields;
940
941 hnode_t* x0 = this->spliced->PrettyTree(do_abbrev, seen);
942 L->append(Alloc<Field>(StrFromC("spliced"), x0));
943
944 hnode_t* x1 = ToPretty(this->canonical_flags);
945 L->append(Alloc<Field>(StrFromC("canonical_flags"), x1));
946
947 if (this->convert_funcs != nullptr) { // List
948 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
949 for (ListIter<value_t*> it(this->convert_funcs); !it.Done(); it.Next()) {
950 value_t* v_ = it.Value();
951 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
952 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
953 x2->children->append(h);
954 }
955 L->append(Alloc<Field>(StrFromC("convert_funcs"), x2));
956 }
957
958 if (this->convert_toks != nullptr) { // List
959 hnode::Array* x3 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
960 for (ListIter<syntax_asdl::Token*> it(this->convert_toks); !it.Done();
961 it.Next()) {
962 syntax_asdl::Token* v_ = it.Value();
963 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
964 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
965 x3->children->append(h);
966 }
967 L->append(Alloc<Field>(StrFromC("convert_toks"), x3));
968 }
969
970 if (this->as_ere) { // Optional
971 hnode_t* x4 = ToPretty(this->as_ere);
972 L->append(Alloc<Field>(StrFromC("as_ere"), x4));
973 }
974
975 if (this->capture_names != nullptr) { // List
976 hnode::Array* x5 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
977 for (ListIter<BigStr*> it(this->capture_names); !it.Done(); it.Next()) {
978 BigStr* v_ = it.Value();
979 hnode_t* h = ToPretty(v_);
980 x5->children->append(h);
981 }
982 L->append(Alloc<Field>(StrFromC("capture_names"), x5));
983 }
984
985 return out_node;
986}
987
988
989hnode_t* value__Place::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
990 seen = seen ? seen : Alloc<Dict<int, bool>>();
991 int heap_id = ObjectId(this);
992 if (dict_contains(seen, heap_id)) {
993 return Alloc<hnode::AlreadySeen>(heap_id);
994 }
995 seen->set(heap_id, true);
996
997 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
998 List<Field*>* L = out_node->fields;
999
1000 hnode_t* x0 = this->lval->PrettyTree(do_abbrev, seen);
1001 L->append(Alloc<Field>(StrFromC("lval"), x0));
1002
1003 if (this->frame != nullptr) { // Dict
1004 auto* unnamed = NewList<hnode_t*>();
1005 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1006 StrFromC("}"),
1007 NewList<Field*>(), unnamed);
1008 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->frame); !it.Done();
1009 it.Next()) {
1010 auto k = it.Key();
1011 auto v = it.Value();
1012 unnamed->append(ToPretty(k));
1013 unnamed->append(v->PrettyTree(do_abbrev, seen));
1014 }
1015 L->append(Alloc<Field>(StrFromC("frame"), hdict));
1016 }
1017
1018 return out_node;
1019}
1020
1021
1022hnode_t* value__Frame::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1023 seen = seen ? seen : Alloc<Dict<int, bool>>();
1024 int heap_id = ObjectId(this);
1025 if (dict_contains(seen, heap_id)) {
1026 return Alloc<hnode::AlreadySeen>(heap_id);
1027 }
1028 seen->set(heap_id, true);
1029
1030 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1031 List<Field*>* L = out_node->fields;
1032
1033 if (this->frame != nullptr) { // Dict
1034 auto* unnamed = NewList<hnode_t*>();
1035 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1036 StrFromC("}"),
1037 NewList<Field*>(), unnamed);
1038 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->frame); !it.Done();
1039 it.Next()) {
1040 auto k = it.Key();
1041 auto v = it.Value();
1042 unnamed->append(ToPretty(k));
1043 unnamed->append(v->PrettyTree(do_abbrev, seen));
1044 }
1045 L->append(Alloc<Field>(StrFromC("frame"), hdict));
1046 }
1047
1048 return out_node;
1049}
1050
1051
1052hnode_t* value__DebugFrame::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1053 seen = seen ? seen : Alloc<Dict<int, bool>>();
1054 int heap_id = ObjectId(this);
1055 if (dict_contains(seen, heap_id)) {
1056 return Alloc<hnode::AlreadySeen>(heap_id);
1057 }
1058 seen->set(heap_id, true);
1059
1060 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1061 List<Field*>* L = out_node->fields;
1062
1063 hnode_t* x0 = this->frame->PrettyTree(do_abbrev, seen);
1064 L->append(Alloc<Field>(StrFromC("frame"), x0));
1065
1066 return out_node;
1067}
1068
1069
1070hnode_t* value__BoundFunc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1071 seen = seen ? seen : Alloc<Dict<int, bool>>();
1072 int heap_id = ObjectId(this);
1073 if (dict_contains(seen, heap_id)) {
1074 return Alloc<hnode::AlreadySeen>(heap_id);
1075 }
1076 seen->set(heap_id, true);
1077
1078 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1079 List<Field*>* L = out_node->fields;
1080
1081 hnode_t* x0 = this->me->PrettyTree(do_abbrev, seen);
1082 L->append(Alloc<Field>(StrFromC("me"), x0));
1083
1084 hnode_t* x1 = this->func->PrettyTree(do_abbrev, seen);
1085 L->append(Alloc<Field>(StrFromC("func"), x1));
1086
1087 return out_node;
1088}
1089
1090
1091hnode_t* value__BuiltinFunc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1092 seen = seen ? seen : Alloc<Dict<int, bool>>();
1093 int heap_id = ObjectId(this);
1094 if (dict_contains(seen, heap_id)) {
1095 return Alloc<hnode::AlreadySeen>(heap_id);
1096 }
1097 seen->set(heap_id, true);
1098
1099 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1100 List<Field*>* L = out_node->fields;
1101
1102 hnode_t* x0 = Alloc<hnode::Leaf>(StrFromC("<extern>"), color_e::External);
1103 L->append(Alloc<Field>(StrFromC("callable"), x0));
1104
1105 return out_node;
1106}
1107
1108
1109hnode_t* value__Func::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1110 seen = seen ? seen : Alloc<Dict<int, bool>>();
1111 int heap_id = ObjectId(this);
1112 if (dict_contains(seen, heap_id)) {
1113 return Alloc<hnode::AlreadySeen>(heap_id);
1114 }
1115 seen->set(heap_id, true);
1116
1117 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1118 List<Field*>* L = out_node->fields;
1119
1120 hnode_t* x0 = ToPretty(this->name);
1121 L->append(Alloc<Field>(StrFromC("name"), x0));
1122
1123 hnode_t* x1 = this->parsed->PrettyTree(do_abbrev, seen);
1124 L->append(Alloc<Field>(StrFromC("parsed"), x1));
1125
1126 if (this->pos_defaults != nullptr) { // List
1127 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
1128 for (ListIter<value_t*> it(this->pos_defaults); !it.Done(); it.Next()) {
1129 value_t* v_ = it.Value();
1130 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
1131 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
1132 x2->children->append(h);
1133 }
1134 L->append(Alloc<Field>(StrFromC("pos_defaults"), x2));
1135 }
1136
1137 if (this->named_defaults != nullptr) { // Dict
1138 auto* unnamed = NewList<hnode_t*>();
1139 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1140 StrFromC("}"),
1141 NewList<Field*>(), unnamed);
1142 for (DictIter<BigStr*, value_t*> it(this->named_defaults); !it.Done();
1143 it.Next()) {
1144 auto k = it.Key();
1145 auto v = it.Value();
1146 unnamed->append(ToPretty(k));
1147 unnamed->append(v->PrettyTree(do_abbrev, seen));
1148 }
1149 L->append(Alloc<Field>(StrFromC("named_defaults"), hdict));
1150 }
1151
1152 if (this->captured_frame != nullptr) { // Dict
1153 auto* unnamed = NewList<hnode_t*>();
1154 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1155 StrFromC("}"),
1156 NewList<Field*>(), unnamed);
1157 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->captured_frame);
1158 !it.Done(); it.Next()) {
1159 auto k = it.Key();
1160 auto v = it.Value();
1161 unnamed->append(ToPretty(k));
1162 unnamed->append(v->PrettyTree(do_abbrev, seen));
1163 }
1164 L->append(Alloc<Field>(StrFromC("captured_frame"), hdict));
1165 }
1166
1167 if (this->module_frame != nullptr) { // Dict
1168 auto* unnamed = NewList<hnode_t*>();
1169 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1170 StrFromC("}"),
1171 NewList<Field*>(), unnamed);
1172 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_frame);
1173 !it.Done(); it.Next()) {
1174 auto k = it.Key();
1175 auto v = it.Value();
1176 unnamed->append(ToPretty(k));
1177 unnamed->append(v->PrettyTree(do_abbrev, seen));
1178 }
1179 L->append(Alloc<Field>(StrFromC("module_frame"), hdict));
1180 }
1181
1182 return out_node;
1183}
1184
1185
1186hnode_t* value__BuiltinProc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1187 seen = seen ? seen : Alloc<Dict<int, bool>>();
1188 int heap_id = ObjectId(this);
1189 if (dict_contains(seen, heap_id)) {
1190 return Alloc<hnode::AlreadySeen>(heap_id);
1191 }
1192 seen->set(heap_id, true);
1193
1194 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1195 List<Field*>* L = out_node->fields;
1196
1197 hnode_t* x0 = Alloc<hnode::Leaf>(StrFromC("<extern>"), color_e::External);
1198 L->append(Alloc<Field>(StrFromC("builtin"), x0));
1199
1200 return out_node;
1201}
1202
1203
1204hnode_t* value__Proc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1205 seen = seen ? seen : Alloc<Dict<int, bool>>();
1206 int heap_id = ObjectId(this);
1207 if (dict_contains(seen, heap_id)) {
1208 return Alloc<hnode::AlreadySeen>(heap_id);
1209 }
1210 seen->set(heap_id, true);
1211
1212 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1213 List<Field*>* L = out_node->fields;
1214
1215 hnode_t* x0 = ToPretty(this->name);
1216 L->append(Alloc<Field>(StrFromC("name"), x0));
1217
1218 hnode_t* x1 = this->name_tok->PrettyTree(do_abbrev, seen);
1219 L->append(Alloc<Field>(StrFromC("name_tok"), x1));
1220
1221 hnode_t* x2 = this->sig->PrettyTree(do_abbrev, seen);
1222 L->append(Alloc<Field>(StrFromC("sig"), x2));
1223
1224 hnode_t* x3 = this->body->PrettyTree(do_abbrev, seen);
1225 L->append(Alloc<Field>(StrFromC("body"), x3));
1226
1227 if (this->defaults) { // Optional
1228 hnode_t* x4 = this->defaults->PrettyTree(do_abbrev, seen);
1229 L->append(Alloc<Field>(StrFromC("defaults"), x4));
1230 }
1231
1232 hnode_t* x5 = ToPretty(this->sh_compat);
1233 L->append(Alloc<Field>(StrFromC("sh_compat"), x5));
1234
1235 if (this->captured_frame != nullptr) { // Dict
1236 auto* unnamed = NewList<hnode_t*>();
1237 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1238 StrFromC("}"),
1239 NewList<Field*>(), unnamed);
1240 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->captured_frame);
1241 !it.Done(); it.Next()) {
1242 auto k = it.Key();
1243 auto v = it.Value();
1244 unnamed->append(ToPretty(k));
1245 unnamed->append(v->PrettyTree(do_abbrev, seen));
1246 }
1247 L->append(Alloc<Field>(StrFromC("captured_frame"), hdict));
1248 }
1249
1250 if (this->module_frame != nullptr) { // Dict
1251 auto* unnamed = NewList<hnode_t*>();
1252 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1253 StrFromC("}"),
1254 NewList<Field*>(), unnamed);
1255 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_frame);
1256 !it.Done(); it.Next()) {
1257 auto k = it.Key();
1258 auto v = it.Value();
1259 unnamed->append(ToPretty(k));
1260 unnamed->append(v->PrettyTree(do_abbrev, seen));
1261 }
1262 L->append(Alloc<Field>(StrFromC("module_frame"), hdict));
1263 }
1264
1265 if (this->code_str) { // Optional
1266 hnode_t* x8 = ToPretty(this->code_str);
1267 L->append(Alloc<Field>(StrFromC("code_str"), x8));
1268 }
1269
1270 return out_node;
1271}
1272
1273
1274hnode_t* value__Expr::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1275 seen = seen ? seen : Alloc<Dict<int, bool>>();
1276 int heap_id = ObjectId(this);
1277 if (dict_contains(seen, heap_id)) {
1278 return Alloc<hnode::AlreadySeen>(heap_id);
1279 }
1280 seen->set(heap_id, true);
1281
1282 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1283 List<Field*>* L = out_node->fields;
1284
1285 hnode_t* x0 = this->e->PrettyTree(do_abbrev, seen);
1286 L->append(Alloc<Field>(StrFromC("e"), x0));
1287
1288 if (this->captured_frame != nullptr) { // Dict
1289 auto* unnamed = NewList<hnode_t*>();
1290 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1291 StrFromC("}"),
1292 NewList<Field*>(), unnamed);
1293 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->captured_frame);
1294 !it.Done(); it.Next()) {
1295 auto k = it.Key();
1296 auto v = it.Value();
1297 unnamed->append(ToPretty(k));
1298 unnamed->append(v->PrettyTree(do_abbrev, seen));
1299 }
1300 L->append(Alloc<Field>(StrFromC("captured_frame"), hdict));
1301 }
1302
1303 if (this->module_frame != nullptr) { // Dict
1304 auto* unnamed = NewList<hnode_t*>();
1305 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1306 StrFromC("}"),
1307 NewList<Field*>(), unnamed);
1308 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_frame);
1309 !it.Done(); it.Next()) {
1310 auto k = it.Key();
1311 auto v = it.Value();
1312 unnamed->append(ToPretty(k));
1313 unnamed->append(v->PrettyTree(do_abbrev, seen));
1314 }
1315 L->append(Alloc<Field>(StrFromC("module_frame"), hdict));
1316 }
1317
1318 return out_node;
1319}
1320
1321
1322hnode_t* value__CommandFrag::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1323 seen = seen ? seen : Alloc<Dict<int, bool>>();
1324 int heap_id = ObjectId(this);
1325 if (dict_contains(seen, heap_id)) {
1326 return Alloc<hnode::AlreadySeen>(heap_id);
1327 }
1328 seen->set(heap_id, true);
1329
1330 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1331 List<Field*>* L = out_node->fields;
1332
1333 hnode_t* x0 = this->c->PrettyTree(do_abbrev, seen);
1334 L->append(Alloc<Field>(StrFromC("c"), x0));
1335
1336 return out_node;
1337}
1338
1339
1340hnode_t* value__Command::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1341 seen = seen ? seen : Alloc<Dict<int, bool>>();
1342 int heap_id = ObjectId(this);
1343 if (dict_contains(seen, heap_id)) {
1344 return Alloc<hnode::AlreadySeen>(heap_id);
1345 }
1346 seen->set(heap_id, true);
1347
1348 hnode::Record* out_node = runtime::NewRecord(value_str(this->tag()));
1349 List<Field*>* L = out_node->fields;
1350
1351 hnode_t* x0 = this->frag->PrettyTree(do_abbrev, seen);
1352 L->append(Alloc<Field>(StrFromC("frag"), x0));
1353
1354 if (this->captured_frame != nullptr) { // Dict
1355 auto* unnamed = NewList<hnode_t*>();
1356 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1357 StrFromC("}"),
1358 NewList<Field*>(), unnamed);
1359 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->captured_frame);
1360 !it.Done(); it.Next()) {
1361 auto k = it.Key();
1362 auto v = it.Value();
1363 unnamed->append(ToPretty(k));
1364 unnamed->append(v->PrettyTree(do_abbrev, seen));
1365 }
1366 L->append(Alloc<Field>(StrFromC("captured_frame"), hdict));
1367 }
1368
1369 if (this->module_frame != nullptr) { // Dict
1370 auto* unnamed = NewList<hnode_t*>();
1371 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1372 StrFromC("}"),
1373 NewList<Field*>(), unnamed);
1374 for (DictIter<BigStr*, runtime_asdl::Cell*> it(this->module_frame);
1375 !it.Done(); it.Next()) {
1376 auto k = it.Key();
1377 auto v = it.Value();
1378 unnamed->append(ToPretty(k));
1379 unnamed->append(v->PrettyTree(do_abbrev, seen));
1380 }
1381 L->append(Alloc<Field>(StrFromC("module_frame"), hdict));
1382 }
1383
1384 return out_node;
1385}
1386
1387
1388hnode_t* value_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1389 switch (this->tag()) {
1390 case value_e::Interrupted: {
1391 value__Interrupted* obj = static_cast<value__Interrupted*>(this);
1392 return obj->PrettyTree(do_abbrev, seen);
1393 }
1394 case value_e::Stdin: {
1395 value__Stdin* obj = static_cast<value__Stdin*>(this);
1396 return obj->PrettyTree(do_abbrev, seen);
1397 }
1398 case value_e::Slice: {
1399 value__Slice* obj = static_cast<value__Slice*>(this);
1400 return obj->PrettyTree(do_abbrev, seen);
1401 }
1402 case value_e::Undef: {
1403 value__Undef* obj = static_cast<value__Undef*>(this);
1404 return obj->PrettyTree(do_abbrev, seen);
1405 }
1406 case value_e::Str: {
1407 value__Str* obj = static_cast<value__Str*>(this);
1408 return obj->PrettyTree(do_abbrev, seen);
1409 }
1410 case value_e::InitializerList: {
1411 value__InitializerList* obj = static_cast<value__InitializerList*>(this);
1412 return obj->PrettyTree(do_abbrev, seen);
1413 }
1414 case value_e::InternalStringArray: {
1415 value__InternalStringArray* obj =
1416static_cast<value__InternalStringArray*>(this);
1417 return obj->PrettyTree(do_abbrev, seen);
1418 }
1419 case value_e::BashArray: {
1420 value__BashArray* obj = static_cast<value__BashArray*>(this);
1421 return obj->PrettyTree(do_abbrev, seen);
1422 }
1423 case value_e::BashAssoc: {
1424 value__BashAssoc* obj = static_cast<value__BashAssoc*>(this);
1425 return obj->PrettyTree(do_abbrev, seen);
1426 }
1427 case value_e::Null: {
1428 value__Null* obj = static_cast<value__Null*>(this);
1429 return obj->PrettyTree(do_abbrev, seen);
1430 }
1431 case value_e::Bool: {
1432 value__Bool* obj = static_cast<value__Bool*>(this);
1433 return obj->PrettyTree(do_abbrev, seen);
1434 }
1435 case value_e::Int: {
1436 value__Int* obj = static_cast<value__Int*>(this);
1437 return obj->PrettyTree(do_abbrev, seen);
1438 }
1439 case value_e::Float: {
1440 value__Float* obj = static_cast<value__Float*>(this);
1441 return obj->PrettyTree(do_abbrev, seen);
1442 }
1443 case value_e::List: {
1444 value__List* obj = static_cast<value__List*>(this);
1445 return obj->PrettyTree(do_abbrev, seen);
1446 }
1447 case value_e::Dict: {
1448 value__Dict* obj = static_cast<value__Dict*>(this);
1449 return obj->PrettyTree(do_abbrev, seen);
1450 }
1451 case value_e::Obj: {
1452 Obj* obj = static_cast<Obj*>(this);
1453 return obj->PrettyTree(do_abbrev, seen);
1454 }
1455 case value_e::Range: {
1456 value__Range* obj = static_cast<value__Range*>(this);
1457 return obj->PrettyTree(do_abbrev, seen);
1458 }
1459 case value_e::Eggex: {
1460 value__Eggex* obj = static_cast<value__Eggex*>(this);
1461 return obj->PrettyTree(do_abbrev, seen);
1462 }
1463 case value_e::Match: {
1464 RegexMatch* obj = static_cast<RegexMatch*>(this);
1465 return obj->PrettyTree(do_abbrev, seen);
1466 }
1467 case value_e::Place: {
1468 value__Place* obj = static_cast<value__Place*>(this);
1469 return obj->PrettyTree(do_abbrev, seen);
1470 }
1471 case value_e::Frame: {
1472 value__Frame* obj = static_cast<value__Frame*>(this);
1473 return obj->PrettyTree(do_abbrev, seen);
1474 }
1475 case value_e::DebugFrame: {
1476 value__DebugFrame* obj = static_cast<value__DebugFrame*>(this);
1477 return obj->PrettyTree(do_abbrev, seen);
1478 }
1479 case value_e::BoundFunc: {
1480 value__BoundFunc* obj = static_cast<value__BoundFunc*>(this);
1481 return obj->PrettyTree(do_abbrev, seen);
1482 }
1483 case value_e::BuiltinFunc: {
1484 value__BuiltinFunc* obj = static_cast<value__BuiltinFunc*>(this);
1485 return obj->PrettyTree(do_abbrev, seen);
1486 }
1487 case value_e::Func: {
1488 value__Func* obj = static_cast<value__Func*>(this);
1489 return obj->PrettyTree(do_abbrev, seen);
1490 }
1491 case value_e::BuiltinProc: {
1492 value__BuiltinProc* obj = static_cast<value__BuiltinProc*>(this);
1493 return obj->PrettyTree(do_abbrev, seen);
1494 }
1495 case value_e::Proc: {
1496 value__Proc* obj = static_cast<value__Proc*>(this);
1497 return obj->PrettyTree(do_abbrev, seen);
1498 }
1499 case value_e::Expr: {
1500 value__Expr* obj = static_cast<value__Expr*>(this);
1501 return obj->PrettyTree(do_abbrev, seen);
1502 }
1503 case value_e::CommandFrag: {
1504 value__CommandFrag* obj = static_cast<value__CommandFrag*>(this);
1505 return obj->PrettyTree(do_abbrev, seen);
1506 }
1507 case value_e::Command: {
1508 value__Command* obj = static_cast<value__Command*>(this);
1509 return obj->PrettyTree(do_abbrev, seen);
1510 }
1511 default:
1512 assert(0);
1513 }
1514}
1515
1516} // namespace value_asdl