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

1423 lines, 1008 significant
1// _gen/core/runtime.asdl.cc is generated by asdl_main.py
2
3#include "_gen/core/runtime.asdl.h"
4#include <assert.h>
5#include "prebuilt/asdl/runtime.mycpp.h" // generated code uses wrappers here
6#include "_gen/frontend/id_kind.asdl.h" // "use" in ASDL
7using id_kind_asdl::Id_str;
8#include "_gen/frontend/syntax.asdl.h" // "use" in ASDL
9#include "_gen/core/value.asdl.h" // "use" in ASDL
10
11// Generated code uses these types
12using hnode_asdl::hnode;
13using hnode_asdl::Field;
14using hnode_asdl::color_e;
15
16
17namespace runtime_asdl {
18
19
20hnode_t* AssignArg::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
21 seen = seen ? seen : Alloc<Dict<int, bool>>();
22 int heap_id = ObjectId(this);
23 if (dict_contains(seen, heap_id)) {
24 return Alloc<hnode::AlreadySeen>(heap_id);
25 }
26 seen->set(heap_id, true);
27
28 hnode::Record* out_node = runtime::NewRecord(StrFromC("AssignArg"));
29 List<Field*>* L = out_node->fields;
30
31 hnode_t* x0 = ToPretty(this->var_name);
32 L->append(Alloc<Field>(StrFromC("var_name"), x0));
33
34 if (this->rval) { // Optional
35 hnode_t* x1 = this->rval->PrettyTree(do_abbrev, seen);
36 L->append(Alloc<Field>(StrFromC("rval"), x1));
37 }
38
39 hnode_t* x2 = ToPretty(this->plus_eq);
40 L->append(Alloc<Field>(StrFromC("plus_eq"), x2));
41
42 hnode_t* x3 = this->blame_word->PrettyTree(do_abbrev, seen);
43 L->append(Alloc<Field>(StrFromC("blame_word"), x3));
44
45 return out_node;
46}
47
48
49hnode_t* ProcArgs::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
50 seen = seen ? seen : Alloc<Dict<int, bool>>();
51 int heap_id = ObjectId(this);
52 if (dict_contains(seen, heap_id)) {
53 return Alloc<hnode::AlreadySeen>(heap_id);
54 }
55 seen->set(heap_id, true);
56
57 hnode::Record* out_node = runtime::NewRecord(StrFromC("ProcArgs"));
58 List<Field*>* L = out_node->fields;
59
60 hnode_t* x0 = this->typed_args->PrettyTree(do_abbrev, seen);
61 L->append(Alloc<Field>(StrFromC("typed_args"), x0));
62
63 if (this->pos_args != nullptr) { // List
64 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
65 for (ListIter<value_asdl::value_t*> it(this->pos_args); !it.Done();
66 it.Next()) {
67 value_asdl::value_t* v_ = it.Value();
68 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
69 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
70 x1->children->append(h);
71 }
72 L->append(Alloc<Field>(StrFromC("pos_args"), x1));
73 }
74
75 if (this->named_args != nullptr) { // Dict
76 auto* unnamed = NewList<hnode_t*>();
77 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
78 StrFromC("}"),
79 NewList<Field*>(), unnamed);
80 for (DictIter<BigStr*, value_asdl::value_t*> it(this->named_args);
81 !it.Done(); it.Next()) {
82 auto k = it.Key();
83 auto v = it.Value();
84 unnamed->append(ToPretty(k));
85 unnamed->append(v->PrettyTree(do_abbrev, seen));
86 }
87 L->append(Alloc<Field>(StrFromC("named_args"), hdict));
88 }
89
90 if (this->block_arg) { // Optional
91 hnode_t* x3 = this->block_arg->PrettyTree(do_abbrev, seen);
92 L->append(Alloc<Field>(StrFromC("block_arg"), x3));
93 }
94
95 return out_node;
96}
97
98BigStr* cmd_value_str(int tag, bool dot) {
99 char buf[32];
100 const char* v = nullptr;
101 switch (tag) {
102 case cmd_value_e::Argv:
103 v = "Argv"; break;
104 case cmd_value_e::Assign:
105 v = "Assign"; break;
106 default:
107 assert(0);
108 }
109 if (dot) {
110 snprintf(buf, 32, "cmd_value.%s", v);
111 return StrFromC(buf);
112 } else {
113 return StrFromC(v);
114 }
115}
116
117hnode_t* cmd_value__Argv::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
118 seen = seen ? seen : Alloc<Dict<int, bool>>();
119 int heap_id = ObjectId(this);
120 if (dict_contains(seen, heap_id)) {
121 return Alloc<hnode::AlreadySeen>(heap_id);
122 }
123 seen->set(heap_id, true);
124
125 hnode::Record* out_node = runtime::NewRecord(cmd_value_str(this->tag()));
126 List<Field*>* L = out_node->fields;
127
128 if (this->argv != nullptr) { // List
129 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
130 for (ListIter<BigStr*> it(this->argv); !it.Done(); it.Next()) {
131 BigStr* v_ = it.Value();
132 hnode_t* h = ToPretty(v_);
133 x0->children->append(h);
134 }
135 L->append(Alloc<Field>(StrFromC("argv"), x0));
136 }
137
138 if (this->arg_locs != nullptr) { // List
139 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
140 for (ListIter<syntax_asdl::CompoundWord*> it(this->arg_locs); !it.Done();
141 it.Next()) {
142 syntax_asdl::CompoundWord* v_ = it.Value();
143 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
144 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
145 x1->children->append(h);
146 }
147 L->append(Alloc<Field>(StrFromC("arg_locs"), x1));
148 }
149
150 hnode_t* x2 = ToPretty(this->is_last_cmd);
151 L->append(Alloc<Field>(StrFromC("is_last_cmd"), x2));
152
153 if (this->self_obj) { // Optional
154 hnode_t* x3 = this->self_obj->PrettyTree(do_abbrev, seen);
155 L->append(Alloc<Field>(StrFromC("self_obj"), x3));
156 }
157
158 if (this->proc_args) { // Optional
159 hnode_t* x4 = this->proc_args->PrettyTree(do_abbrev, seen);
160 L->append(Alloc<Field>(StrFromC("proc_args"), x4));
161 }
162
163 return out_node;
164}
165
166
167hnode_t* cmd_value__Assign::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
168 seen = seen ? seen : Alloc<Dict<int, bool>>();
169 int heap_id = ObjectId(this);
170 if (dict_contains(seen, heap_id)) {
171 return Alloc<hnode::AlreadySeen>(heap_id);
172 }
173 seen->set(heap_id, true);
174
175 hnode::Record* out_node = runtime::NewRecord(cmd_value_str(this->tag()));
176 List<Field*>* L = out_node->fields;
177
178 hnode_t* x0 = ToPretty(this->builtin_id);
179 L->append(Alloc<Field>(StrFromC("builtin_id"), x0));
180
181 if (this->argv != nullptr) { // List
182 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
183 for (ListIter<BigStr*> it(this->argv); !it.Done(); it.Next()) {
184 BigStr* v_ = it.Value();
185 hnode_t* h = ToPretty(v_);
186 x1->children->append(h);
187 }
188 L->append(Alloc<Field>(StrFromC("argv"), x1));
189 }
190
191 if (this->arg_locs != nullptr) { // List
192 hnode::Array* x2 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
193 for (ListIter<syntax_asdl::CompoundWord*> it(this->arg_locs); !it.Done();
194 it.Next()) {
195 syntax_asdl::CompoundWord* v_ = it.Value();
196 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
197 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
198 x2->children->append(h);
199 }
200 L->append(Alloc<Field>(StrFromC("arg_locs"), x2));
201 }
202
203 if (this->pairs != nullptr) { // List
204 hnode::Array* x3 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
205 for (ListIter<AssignArg*> it(this->pairs); !it.Done(); it.Next()) {
206 AssignArg* v_ = it.Value();
207 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
208 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
209 x3->children->append(h);
210 }
211 L->append(Alloc<Field>(StrFromC("pairs"), x3));
212 }
213
214 return out_node;
215}
216
217
218hnode_t* cmd_value_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
219 switch (this->tag()) {
220 case cmd_value_e::Argv: {
221 cmd_value__Argv* obj = static_cast<cmd_value__Argv*>(this);
222 return obj->PrettyTree(do_abbrev, seen);
223 }
224 case cmd_value_e::Assign: {
225 cmd_value__Assign* obj = static_cast<cmd_value__Assign*>(this);
226 return obj->PrettyTree(do_abbrev, seen);
227 }
228 default:
229 assert(0);
230 }
231}
232
233hnode_t* Piece::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
234 seen = seen ? seen : Alloc<Dict<int, bool>>();
235 int heap_id = ObjectId(this);
236 if (dict_contains(seen, heap_id)) {
237 return Alloc<hnode::AlreadySeen>(heap_id);
238 }
239 seen->set(heap_id, true);
240
241 hnode::Record* out_node = runtime::NewRecord(StrFromC("Piece"));
242 List<Field*>* L = out_node->fields;
243
244 hnode_t* x0 = ToPretty(this->s);
245 L->append(Alloc<Field>(StrFromC("s"), x0));
246
247 hnode_t* x1 = ToPretty(this->quoted);
248 L->append(Alloc<Field>(StrFromC("quoted"), x1));
249
250 hnode_t* x2 = ToPretty(this->do_split);
251 L->append(Alloc<Field>(StrFromC("do_split"), x2));
252
253 return out_node;
254}
255
256BigStr* part_value_str(int tag, bool dot) {
257 char buf[32];
258 const char* v = nullptr;
259 switch (tag) {
260 case part_value_e::String:
261 v = "String"; break;
262 case part_value_e::Array:
263 v = "Array"; break;
264 case part_value_e::ExtGlob:
265 v = "ExtGlob"; break;
266 default:
267 assert(0);
268 }
269 if (dot) {
270 snprintf(buf, 32, "part_value.%s", v);
271 return StrFromC(buf);
272 } else {
273 return StrFromC(v);
274 }
275}
276
277hnode_t* part_value__Array::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
278 seen = seen ? seen : Alloc<Dict<int, bool>>();
279 int heap_id = ObjectId(this);
280 if (dict_contains(seen, heap_id)) {
281 return Alloc<hnode::AlreadySeen>(heap_id);
282 }
283 seen->set(heap_id, true);
284
285 hnode::Record* out_node = runtime::NewRecord(part_value_str(this->tag()));
286 List<Field*>* L = out_node->fields;
287
288 if (this->strs != nullptr) { // List
289 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
290 for (ListIter<BigStr*> it(this->strs); !it.Done(); it.Next()) {
291 BigStr* v_ = it.Value();
292 hnode_t* h = ToPretty(v_);
293 x0->children->append(h);
294 }
295 L->append(Alloc<Field>(StrFromC("strs"), x0));
296 }
297
298 hnode_t* x1 = ToPretty(this->quoted);
299 L->append(Alloc<Field>(StrFromC("quoted"), x1));
300
301 return out_node;
302}
303
304
305hnode_t* part_value__ExtGlob::PrettyTree(bool do_abbrev, Dict<int, bool>* seen)
306 {
307 seen = seen ? seen : Alloc<Dict<int, bool>>();
308 int heap_id = ObjectId(this);
309 if (dict_contains(seen, heap_id)) {
310 return Alloc<hnode::AlreadySeen>(heap_id);
311 }
312 seen->set(heap_id, true);
313
314 hnode::Record* out_node = runtime::NewRecord(part_value_str(this->tag()));
315 List<Field*>* L = out_node->fields;
316
317 if (this->part_vals != nullptr) { // List
318 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
319 for (ListIter<part_value_t*> it(this->part_vals); !it.Done(); it.Next()) {
320 part_value_t* v_ = it.Value();
321 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
322 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
323 x0->children->append(h);
324 }
325 L->append(Alloc<Field>(StrFromC("part_vals"), x0));
326 }
327
328 return out_node;
329}
330
331
332hnode_t* part_value_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
333 switch (this->tag()) {
334 case part_value_e::String: {
335 Piece* obj = static_cast<Piece*>(this);
336 return obj->PrettyTree(do_abbrev, seen);
337 }
338 case part_value_e::Array: {
339 part_value__Array* obj = static_cast<part_value__Array*>(this);
340 return obj->PrettyTree(do_abbrev, seen);
341 }
342 case part_value_e::ExtGlob: {
343 part_value__ExtGlob* obj = static_cast<part_value__ExtGlob*>(this);
344 return obj->PrettyTree(do_abbrev, seen);
345 }
346 default:
347 assert(0);
348 }
349}
350BigStr* coerced_str(coerced_e tag, bool dot) {
351 char buf[32];
352 const char* v = nullptr;
353 switch (tag) {
354 case coerced_e::Int:
355 v = "Int"; break;
356 case coerced_e::Float:
357 v = "Float"; break;
358 case coerced_e::Neither:
359 v = "Neither"; break;
360 default:
361 assert(0);
362 }
363 if (dot) {
364 snprintf(buf, 32, "coerced.%s", v);
365 return StrFromC(buf);
366 } else {
367 return StrFromC(v);
368 }
369}
370
371hnode_t* VarSubState::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
372 seen = seen ? seen : Alloc<Dict<int, bool>>();
373 int heap_id = ObjectId(this);
374 if (dict_contains(seen, heap_id)) {
375 return Alloc<hnode::AlreadySeen>(heap_id);
376 }
377 seen->set(heap_id, true);
378
379 hnode::Record* out_node = runtime::NewRecord(StrFromC("VarSubState"));
380 List<Field*>* L = out_node->fields;
381
382 hnode_t* x0 = ToPretty(this->join_array);
383 L->append(Alloc<Field>(StrFromC("join_array"), x0));
384
385 hnode_t* x1 = this->h_value->PrettyTree(do_abbrev, seen);
386 L->append(Alloc<Field>(StrFromC("h_value"), x1));
387
388 hnode_t* x2 = this->array_ref->PrettyTree(do_abbrev, seen);
389 L->append(Alloc<Field>(StrFromC("array_ref"), x2));
390
391 return out_node;
392}
393
394
395hnode_t* Cell::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
396 seen = seen ? seen : Alloc<Dict<int, bool>>();
397 int heap_id = ObjectId(this);
398 if (dict_contains(seen, heap_id)) {
399 return Alloc<hnode::AlreadySeen>(heap_id);
400 }
401 seen->set(heap_id, true);
402
403 hnode::Record* out_node = runtime::NewRecord(StrFromC("Cell"));
404 List<Field*>* L = out_node->fields;
405
406 hnode_t* x0 = ToPretty(this->exported);
407 L->append(Alloc<Field>(StrFromC("exported"), x0));
408
409 hnode_t* x1 = ToPretty(this->readonly);
410 L->append(Alloc<Field>(StrFromC("readonly"), x1));
411
412 hnode_t* x2 = ToPretty(this->nameref);
413 L->append(Alloc<Field>(StrFromC("nameref"), x2));
414
415 hnode_t* x3 = this->val->PrettyTree(do_abbrev, seen);
416 L->append(Alloc<Field>(StrFromC("val"), x3));
417
418 return out_node;
419}
420
421BigStr* scope_str(scope_e tag, bool dot) {
422 char buf[32];
423 const char* v = nullptr;
424 switch (tag) {
425 case scope_e::Shopt:
426 v = "Shopt"; break;
427 case scope_e::Dynamic:
428 v = "Dynamic"; break;
429 case scope_e::LocalOrGlobal:
430 v = "LocalOrGlobal"; break;
431 case scope_e::LocalOnly:
432 v = "LocalOnly"; break;
433 case scope_e::GlobalOnly:
434 v = "GlobalOnly"; break;
435 default:
436 assert(0);
437 }
438 if (dot) {
439 snprintf(buf, 32, "scope.%s", v);
440 return StrFromC(buf);
441 } else {
442 return StrFromC(v);
443 }
444}
445BigStr* a_index_str(int tag, bool dot) {
446 char buf[32];
447 const char* v = nullptr;
448 switch (tag) {
449 case a_index_e::Str:
450 v = "Str"; break;
451 case a_index_e::Int:
452 v = "Int"; break;
453 default:
454 assert(0);
455 }
456 if (dot) {
457 snprintf(buf, 32, "a_index.%s", v);
458 return StrFromC(buf);
459 } else {
460 return StrFromC(v);
461 }
462}
463
464hnode_t* a_index__Str::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
465 seen = seen ? seen : Alloc<Dict<int, bool>>();
466 int heap_id = ObjectId(this);
467 if (dict_contains(seen, heap_id)) {
468 return Alloc<hnode::AlreadySeen>(heap_id);
469 }
470 seen->set(heap_id, true);
471
472 hnode::Record* out_node = runtime::NewRecord(a_index_str(this->tag()));
473 List<Field*>* L = out_node->fields;
474
475 hnode_t* x0 = ToPretty(this->s);
476 L->append(Alloc<Field>(StrFromC("s"), x0));
477
478 return out_node;
479}
480
481
482hnode_t* a_index__Int::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
483 seen = seen ? seen : Alloc<Dict<int, bool>>();
484 int heap_id = ObjectId(this);
485 if (dict_contains(seen, heap_id)) {
486 return Alloc<hnode::AlreadySeen>(heap_id);
487 }
488 seen->set(heap_id, true);
489
490 hnode::Record* out_node = runtime::NewRecord(a_index_str(this->tag()));
491 List<Field*>* L = out_node->fields;
492
493 hnode_t* x0 = ToPretty(this->i);
494 L->append(Alloc<Field>(StrFromC("i"), x0));
495
496 return out_node;
497}
498
499
500hnode_t* a_index_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
501 switch (this->tag()) {
502 case a_index_e::Str: {
503 a_index__Str* obj = static_cast<a_index__Str*>(this);
504 return obj->PrettyTree(do_abbrev, seen);
505 }
506 case a_index_e::Int: {
507 a_index__Int* obj = static_cast<a_index__Int*>(this);
508 return obj->PrettyTree(do_abbrev, seen);
509 }
510 default:
511 assert(0);
512 }
513}
514
515hnode_t* VTestPlace::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
516 seen = seen ? seen : Alloc<Dict<int, bool>>();
517 int heap_id = ObjectId(this);
518 if (dict_contains(seen, heap_id)) {
519 return Alloc<hnode::AlreadySeen>(heap_id);
520 }
521 seen->set(heap_id, true);
522
523 hnode::Record* out_node = runtime::NewRecord(StrFromC("VTestPlace"));
524 List<Field*>* L = out_node->fields;
525
526 if (this->name) { // Optional
527 hnode_t* x0 = ToPretty(this->name);
528 L->append(Alloc<Field>(StrFromC("name"), x0));
529 }
530
531 if (this->index) { // Optional
532 hnode_t* x1 = this->index->PrettyTree(do_abbrev, seen);
533 L->append(Alloc<Field>(StrFromC("index"), x1));
534 }
535
536 return out_node;
537}
538
539BigStr* redirect_arg_str(int tag, bool dot) {
540 char buf[32];
541 const char* v = nullptr;
542 switch (tag) {
543 case redirect_arg_e::Path:
544 v = "Path"; break;
545 case redirect_arg_e::CopyFd:
546 v = "CopyFd"; break;
547 case redirect_arg_e::MoveFd:
548 v = "MoveFd"; break;
549 case redirect_arg_e::CloseFd:
550 v = "CloseFd"; break;
551 case redirect_arg_e::HereDoc:
552 v = "HereDoc"; break;
553 default:
554 assert(0);
555 }
556 if (dot) {
557 snprintf(buf, 32, "redirect_arg.%s", v);
558 return StrFromC(buf);
559 } else {
560 return StrFromC(v);
561 }
562}
563
564redirect_arg__CloseFd* redirect_arg::CloseFd = &gredirect_arg__CloseFd.obj;
565
566GcGlobal<redirect_arg__CloseFd> gredirect_arg__CloseFd =
567 { ObjHeader::Global(redirect_arg_e::CloseFd) };
568
569hnode_t* redirect_arg__Path::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
570 seen = seen ? seen : Alloc<Dict<int, bool>>();
571 int heap_id = ObjectId(this);
572 if (dict_contains(seen, heap_id)) {
573 return Alloc<hnode::AlreadySeen>(heap_id);
574 }
575 seen->set(heap_id, true);
576
577 hnode::Record* out_node = runtime::NewRecord(redirect_arg_str(this->tag()));
578 List<Field*>* L = out_node->fields;
579
580 hnode_t* x0 = ToPretty(this->filename);
581 L->append(Alloc<Field>(StrFromC("filename"), x0));
582
583 return out_node;
584}
585
586
587hnode_t* redirect_arg__CopyFd::PrettyTree(bool do_abbrev, Dict<int, bool>*
588 seen) {
589 seen = seen ? seen : Alloc<Dict<int, bool>>();
590 int heap_id = ObjectId(this);
591 if (dict_contains(seen, heap_id)) {
592 return Alloc<hnode::AlreadySeen>(heap_id);
593 }
594 seen->set(heap_id, true);
595
596 hnode::Record* out_node = runtime::NewRecord(redirect_arg_str(this->tag()));
597 List<Field*>* L = out_node->fields;
598
599 hnode_t* x0 = ToPretty(this->target_fd);
600 L->append(Alloc<Field>(StrFromC("target_fd"), x0));
601
602 return out_node;
603}
604
605
606hnode_t* redirect_arg__MoveFd::PrettyTree(bool do_abbrev, Dict<int, bool>*
607 seen) {
608 seen = seen ? seen : Alloc<Dict<int, bool>>();
609 int heap_id = ObjectId(this);
610 if (dict_contains(seen, heap_id)) {
611 return Alloc<hnode::AlreadySeen>(heap_id);
612 }
613 seen->set(heap_id, true);
614
615 hnode::Record* out_node = runtime::NewRecord(redirect_arg_str(this->tag()));
616 List<Field*>* L = out_node->fields;
617
618 hnode_t* x0 = ToPretty(this->target_fd);
619 L->append(Alloc<Field>(StrFromC("target_fd"), x0));
620
621 return out_node;
622}
623
624
625hnode_t* redirect_arg__CloseFd::PrettyTree(bool do_abbrev, Dict<int, bool>*
626 seen) {
627 seen = seen ? seen : Alloc<Dict<int, bool>>();
628 int heap_id = ObjectId(this);
629 if (dict_contains(seen, heap_id)) {
630 return Alloc<hnode::AlreadySeen>(heap_id);
631 }
632 seen->set(heap_id, true);
633
634 hnode::Record* out_node = runtime::NewRecord(redirect_arg_str(this->tag()));
635 return out_node;
636}
637
638
639hnode_t* redirect_arg__HereDoc::PrettyTree(bool do_abbrev, Dict<int, bool>*
640 seen) {
641 seen = seen ? seen : Alloc<Dict<int, bool>>();
642 int heap_id = ObjectId(this);
643 if (dict_contains(seen, heap_id)) {
644 return Alloc<hnode::AlreadySeen>(heap_id);
645 }
646 seen->set(heap_id, true);
647
648 hnode::Record* out_node = runtime::NewRecord(redirect_arg_str(this->tag()));
649 List<Field*>* L = out_node->fields;
650
651 hnode_t* x0 = ToPretty(this->body);
652 L->append(Alloc<Field>(StrFromC("body"), x0));
653
654 return out_node;
655}
656
657
658hnode_t* redirect_arg_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
659 switch (this->tag()) {
660 case redirect_arg_e::Path: {
661 redirect_arg__Path* obj = static_cast<redirect_arg__Path*>(this);
662 return obj->PrettyTree(do_abbrev, seen);
663 }
664 case redirect_arg_e::CopyFd: {
665 redirect_arg__CopyFd* obj = static_cast<redirect_arg__CopyFd*>(this);
666 return obj->PrettyTree(do_abbrev, seen);
667 }
668 case redirect_arg_e::MoveFd: {
669 redirect_arg__MoveFd* obj = static_cast<redirect_arg__MoveFd*>(this);
670 return obj->PrettyTree(do_abbrev, seen);
671 }
672 case redirect_arg_e::CloseFd: {
673 redirect_arg__CloseFd* obj = static_cast<redirect_arg__CloseFd*>(this);
674 return obj->PrettyTree(do_abbrev, seen);
675 }
676 case redirect_arg_e::HereDoc: {
677 redirect_arg__HereDoc* obj = static_cast<redirect_arg__HereDoc*>(this);
678 return obj->PrettyTree(do_abbrev, seen);
679 }
680 default:
681 assert(0);
682 }
683}
684
685hnode_t* RedirValue::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
686 seen = seen ? seen : Alloc<Dict<int, bool>>();
687 int heap_id = ObjectId(this);
688 if (dict_contains(seen, heap_id)) {
689 return Alloc<hnode::AlreadySeen>(heap_id);
690 }
691 seen->set(heap_id, true);
692
693 hnode::Record* out_node = runtime::NewRecord(StrFromC("RedirValue"));
694 List<Field*>* L = out_node->fields;
695
696 hnode_t* x0 = Alloc<hnode::Leaf>(Id_str(this->op_id, false),
697 color_e::UserType);
698 L->append(Alloc<Field>(StrFromC("op_id"), x0));
699
700 hnode_t* x1 = this->op_loc->PrettyTree(do_abbrev, seen);
701 L->append(Alloc<Field>(StrFromC("op_loc"), x1));
702
703 hnode_t* x2 = this->loc->PrettyTree(do_abbrev, seen);
704 L->append(Alloc<Field>(StrFromC("loc"), x2));
705
706 hnode_t* x3 = this->arg->PrettyTree(do_abbrev, seen);
707 L->append(Alloc<Field>(StrFromC("arg"), x3));
708
709 return out_node;
710}
711
712
713hnode_t* StatusArray::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
714 seen = seen ? seen : Alloc<Dict<int, bool>>();
715 int heap_id = ObjectId(this);
716 if (dict_contains(seen, heap_id)) {
717 return Alloc<hnode::AlreadySeen>(heap_id);
718 }
719 seen->set(heap_id, true);
720
721 hnode::Record* out_node = runtime::NewRecord(StrFromC("StatusArray"));
722 List<Field*>* L = out_node->fields;
723
724 if (this->codes != nullptr) { // List
725 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
726 for (ListIter<int> it(this->codes); !it.Done(); it.Next()) {
727 int v_ = it.Value();
728 hnode_t* h = ToPretty(v_);
729 x0->children->append(h);
730 }
731 L->append(Alloc<Field>(StrFromC("codes"), x0));
732 }
733
734 if (this->locs != nullptr) { // List
735 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
736 for (ListIter<syntax_asdl::loc_t*> it(this->locs); !it.Done(); it.Next()) {
737 syntax_asdl::loc_t* v_ = it.Value();
738 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
739 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
740 x1->children->append(h);
741 }
742 L->append(Alloc<Field>(StrFromC("locs"), x1));
743 }
744
745 return out_node;
746}
747
748
749hnode_t* CommandStatus::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
750 seen = seen ? seen : Alloc<Dict<int, bool>>();
751 int heap_id = ObjectId(this);
752 if (dict_contains(seen, heap_id)) {
753 return Alloc<hnode::AlreadySeen>(heap_id);
754 }
755 seen->set(heap_id, true);
756
757 hnode::Record* out_node = runtime::NewRecord(StrFromC("CommandStatus"));
758 List<Field*>* L = out_node->fields;
759
760 hnode_t* x0 = ToPretty(this->check_errexit);
761 L->append(Alloc<Field>(StrFromC("check_errexit"), x0));
762
763 hnode_t* x1 = ToPretty(this->show_code);
764 L->append(Alloc<Field>(StrFromC("show_code"), x1));
765
766 hnode_t* x2 = ToPretty(this->pipe_negated);
767 L->append(Alloc<Field>(StrFromC("pipe_negated"), x2));
768
769 if (this->pipe_status != nullptr) { // List
770 hnode::Array* x3 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
771 for (ListIter<int> it(this->pipe_status); !it.Done(); it.Next()) {
772 int v_ = it.Value();
773 hnode_t* h = ToPretty(v_);
774 x3->children->append(h);
775 }
776 L->append(Alloc<Field>(StrFromC("pipe_status"), x3));
777 }
778
779 if (this->pipe_locs != nullptr) { // List
780 hnode::Array* x4 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
781 for (ListIter<syntax_asdl::loc_t*> it(this->pipe_locs); !it.Done();
782 it.Next()) {
783 syntax_asdl::loc_t* v_ = it.Value();
784 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
785 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
786 x4->children->append(h);
787 }
788 L->append(Alloc<Field>(StrFromC("pipe_locs"), x4));
789 }
790
791 return out_node;
792}
793
794BigStr* job_state_str(job_state_e tag, bool dot) {
795 char buf[32];
796 const char* v = nullptr;
797 switch (tag) {
798 case job_state_e::Running:
799 v = "Running"; break;
800 case job_state_e::Exited:
801 v = "Exited"; break;
802 case job_state_e::Stopped:
803 v = "Stopped"; break;
804 default:
805 assert(0);
806 }
807 if (dot) {
808 snprintf(buf, 32, "job_state.%s", v);
809 return StrFromC(buf);
810 } else {
811 return StrFromC(v);
812 }
813}
814BigStr* wait_status_str(int tag, bool dot) {
815 char buf[32];
816 const char* v = nullptr;
817 switch (tag) {
818 case wait_status_e::Proc:
819 v = "Proc"; break;
820 case wait_status_e::Pipeline:
821 v = "Pipeline"; break;
822 case wait_status_e::Cancelled:
823 v = "Cancelled"; break;
824 default:
825 assert(0);
826 }
827 if (dot) {
828 snprintf(buf, 32, "wait_status.%s", v);
829 return StrFromC(buf);
830 } else {
831 return StrFromC(v);
832 }
833}
834
835hnode_t* wait_status__Proc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
836 seen = seen ? seen : Alloc<Dict<int, bool>>();
837 int heap_id = ObjectId(this);
838 if (dict_contains(seen, heap_id)) {
839 return Alloc<hnode::AlreadySeen>(heap_id);
840 }
841 seen->set(heap_id, true);
842
843 hnode::Record* out_node = runtime::NewRecord(wait_status_str(this->tag()));
844 List<Field*>* L = out_node->fields;
845
846 hnode_t* x0 = Alloc<hnode::Leaf>(job_state_str(this->state),
847 color_e::TypeName);
848 L->append(Alloc<Field>(StrFromC("state"), x0));
849
850 hnode_t* x1 = ToPretty(this->code);
851 L->append(Alloc<Field>(StrFromC("code"), x1));
852
853 return out_node;
854}
855
856
857hnode_t* wait_status__Pipeline::PrettyTree(bool do_abbrev, Dict<int, bool>*
858 seen) {
859 seen = seen ? seen : Alloc<Dict<int, bool>>();
860 int heap_id = ObjectId(this);
861 if (dict_contains(seen, heap_id)) {
862 return Alloc<hnode::AlreadySeen>(heap_id);
863 }
864 seen->set(heap_id, true);
865
866 hnode::Record* out_node = runtime::NewRecord(wait_status_str(this->tag()));
867 List<Field*>* L = out_node->fields;
868
869 hnode_t* x0 = Alloc<hnode::Leaf>(job_state_str(this->state),
870 color_e::TypeName);
871 L->append(Alloc<Field>(StrFromC("state"), x0));
872
873 if (this->codes != nullptr) { // List
874 hnode::Array* x1 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
875 for (ListIter<int> it(this->codes); !it.Done(); it.Next()) {
876 int v_ = it.Value();
877 hnode_t* h = ToPretty(v_);
878 x1->children->append(h);
879 }
880 L->append(Alloc<Field>(StrFromC("codes"), x1));
881 }
882
883 return out_node;
884}
885
886
887hnode_t* wait_status__Cancelled::PrettyTree(bool do_abbrev, Dict<int, bool>*
888 seen) {
889 seen = seen ? seen : Alloc<Dict<int, bool>>();
890 int heap_id = ObjectId(this);
891 if (dict_contains(seen, heap_id)) {
892 return Alloc<hnode::AlreadySeen>(heap_id);
893 }
894 seen->set(heap_id, true);
895
896 hnode::Record* out_node = runtime::NewRecord(wait_status_str(this->tag()));
897 List<Field*>* L = out_node->fields;
898
899 hnode_t* x0 = ToPretty(this->sig_num);
900 L->append(Alloc<Field>(StrFromC("sig_num"), x0));
901
902 return out_node;
903}
904
905
906hnode_t* wait_status_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
907 switch (this->tag()) {
908 case wait_status_e::Proc: {
909 wait_status__Proc* obj = static_cast<wait_status__Proc*>(this);
910 return obj->PrettyTree(do_abbrev, seen);
911 }
912 case wait_status_e::Pipeline: {
913 wait_status__Pipeline* obj = static_cast<wait_status__Pipeline*>(this);
914 return obj->PrettyTree(do_abbrev, seen);
915 }
916 case wait_status_e::Cancelled: {
917 wait_status__Cancelled* obj = static_cast<wait_status__Cancelled*>(this);
918 return obj->PrettyTree(do_abbrev, seen);
919 }
920 default:
921 assert(0);
922 }
923}
924BigStr* flow_str(flow_e tag, bool dot) {
925 char buf[32];
926 const char* v = nullptr;
927 switch (tag) {
928 case flow_e::Nothing:
929 v = "Nothing"; break;
930 case flow_e::Break:
931 v = "Break"; break;
932 case flow_e::Raise:
933 v = "Raise"; break;
934 default:
935 assert(0);
936 }
937 if (dot) {
938 snprintf(buf, 32, "flow.%s", v);
939 return StrFromC(buf);
940 } else {
941 return StrFromC(v);
942 }
943}
944BigStr* span_str(span_e tag, bool dot) {
945 char buf[32];
946 const char* v = nullptr;
947 switch (tag) {
948 case span_e::Black:
949 v = "Black"; break;
950 case span_e::Delim:
951 v = "Delim"; break;
952 case span_e::Backslash:
953 v = "Backslash"; break;
954 default:
955 assert(0);
956 }
957 if (dot) {
958 snprintf(buf, 32, "span.%s", v);
959 return StrFromC(buf);
960 } else {
961 return StrFromC(v);
962 }
963}
964BigStr* emit_str(int tag, bool dot) {
965 char buf[32];
966 const char* v = nullptr;
967 switch (tag) {
968 case emit_i::Part:
969 v = "Part"; break;
970 case emit_i::Delim:
971 v = "Delim"; break;
972 case emit_i::Empty:
973 v = "Empty"; break;
974 case emit_i::Escape:
975 v = "Escape"; break;
976 case emit_i::Nothing:
977 v = "Nothing"; break;
978 default:
979 assert(0);
980 }
981 if (dot) {
982 snprintf(buf, 32, "emit.%s", v);
983 return StrFromC(buf);
984 } else {
985 return StrFromC(v);
986 }
987}
988BigStr* state_str(int tag, bool dot) {
989 char buf[32];
990 const char* v = nullptr;
991 switch (tag) {
992 case state_i::Invalid:
993 v = "Invalid"; break;
994 case state_i::Start:
995 v = "Start"; break;
996 case state_i::DE_White1:
997 v = "DE_White1"; break;
998 case state_i::DE_Gray:
999 v = "DE_Gray"; break;
1000 case state_i::DE_White2:
1001 v = "DE_White2"; break;
1002 case state_i::Black:
1003 v = "Black"; break;
1004 case state_i::Backslash:
1005 v = "Backslash"; break;
1006 case state_i::Done:
1007 v = "Done"; break;
1008 default:
1009 assert(0);
1010 }
1011 if (dot) {
1012 snprintf(buf, 32, "state.%s", v);
1013 return StrFromC(buf);
1014 } else {
1015 return StrFromC(v);
1016 }
1017}
1018BigStr* char_kind_str(int tag, bool dot) {
1019 char buf[32];
1020 const char* v = nullptr;
1021 switch (tag) {
1022 case char_kind_i::DE_White:
1023 v = "DE_White"; break;
1024 case char_kind_i::DE_Gray:
1025 v = "DE_Gray"; break;
1026 case char_kind_i::Black:
1027 v = "Black"; break;
1028 case char_kind_i::Backslash:
1029 v = "Backslash"; break;
1030 case char_kind_i::Sentinel:
1031 v = "Sentinel"; break;
1032 default:
1033 assert(0);
1034 }
1035 if (dot) {
1036 snprintf(buf, 32, "char_kind.%s", v);
1037 return StrFromC(buf);
1038 } else {
1039 return StrFromC(v);
1040 }
1041}
1042BigStr* error_code_str(error_code_e tag, bool dot) {
1043 char buf[32];
1044 const char* v = nullptr;
1045 switch (tag) {
1046 case error_code_e::OK:
1047 v = "OK"; break;
1048 case error_code_e::IndexOutOfRange:
1049 v = "IndexOutOfRange"; break;
1050 default:
1051 assert(0);
1052 }
1053 if (dot) {
1054 snprintf(buf, 32, "error_code.%s", v);
1055 return StrFromC(buf);
1056 } else {
1057 return StrFromC(v);
1058 }
1059}
1060BigStr* flag_type_str(flag_type_e tag, bool dot) {
1061 char buf[32];
1062 const char* v = nullptr;
1063 switch (tag) {
1064 case flag_type_e::Bool:
1065 v = "Bool"; break;
1066 case flag_type_e::Int:
1067 v = "Int"; break;
1068 case flag_type_e::Float:
1069 v = "Float"; break;
1070 case flag_type_e::Str:
1071 v = "Str"; break;
1072 default:
1073 assert(0);
1074 }
1075 if (dot) {
1076 snprintf(buf, 32, "flag_type.%s", v);
1077 return StrFromC(buf);
1078 } else {
1079 return StrFromC(v);
1080 }
1081}
1082BigStr* trace_str(int tag, bool dot) {
1083 char buf[32];
1084 const char* v = nullptr;
1085 switch (tag) {
1086 case trace_e::External:
1087 v = "External"; break;
1088 case trace_e::CommandSub:
1089 v = "CommandSub"; break;
1090 case trace_e::ForkWait:
1091 v = "ForkWait"; break;
1092 case trace_e::Fork:
1093 v = "Fork"; break;
1094 case trace_e::PipelinePart:
1095 v = "PipelinePart"; break;
1096 case trace_e::ProcessSub:
1097 v = "ProcessSub"; break;
1098 case trace_e::HereDoc:
1099 v = "HereDoc"; break;
1100 default:
1101 assert(0);
1102 }
1103 if (dot) {
1104 snprintf(buf, 32, "trace.%s", v);
1105 return StrFromC(buf);
1106 } else {
1107 return StrFromC(v);
1108 }
1109}
1110
1111trace__CommandSub* trace::CommandSub = &gtrace__CommandSub.obj;
1112
1113GcGlobal<trace__CommandSub> gtrace__CommandSub =
1114 { ObjHeader::Global(trace_e::CommandSub) };
1115
1116trace__ForkWait* trace::ForkWait = &gtrace__ForkWait.obj;
1117
1118GcGlobal<trace__ForkWait> gtrace__ForkWait =
1119 { ObjHeader::Global(trace_e::ForkWait) };
1120
1121trace__Fork* trace::Fork = &gtrace__Fork.obj;
1122
1123GcGlobal<trace__Fork> gtrace__Fork =
1124 { ObjHeader::Global(trace_e::Fork) };
1125
1126trace__PipelinePart* trace::PipelinePart = &gtrace__PipelinePart.obj;
1127
1128GcGlobal<trace__PipelinePart> gtrace__PipelinePart =
1129 { ObjHeader::Global(trace_e::PipelinePart) };
1130
1131trace__ProcessSub* trace::ProcessSub = &gtrace__ProcessSub.obj;
1132
1133GcGlobal<trace__ProcessSub> gtrace__ProcessSub =
1134 { ObjHeader::Global(trace_e::ProcessSub) };
1135
1136trace__HereDoc* trace::HereDoc = &gtrace__HereDoc.obj;
1137
1138GcGlobal<trace__HereDoc> gtrace__HereDoc =
1139 { ObjHeader::Global(trace_e::HereDoc) };
1140
1141hnode_t* trace__External::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1142 seen = seen ? seen : Alloc<Dict<int, bool>>();
1143 int heap_id = ObjectId(this);
1144 if (dict_contains(seen, heap_id)) {
1145 return Alloc<hnode::AlreadySeen>(heap_id);
1146 }
1147 seen->set(heap_id, true);
1148
1149 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1150 List<Field*>* L = out_node->fields;
1151
1152 if (this->argv != nullptr) { // List
1153 hnode::Array* x0 = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
1154 for (ListIter<BigStr*> it(this->argv); !it.Done(); it.Next()) {
1155 BigStr* v_ = it.Value();
1156 hnode_t* h = ToPretty(v_);
1157 x0->children->append(h);
1158 }
1159 L->append(Alloc<Field>(StrFromC("argv"), x0));
1160 }
1161
1162 return out_node;
1163}
1164
1165
1166hnode_t* trace__CommandSub::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1167 seen = seen ? seen : Alloc<Dict<int, bool>>();
1168 int heap_id = ObjectId(this);
1169 if (dict_contains(seen, heap_id)) {
1170 return Alloc<hnode::AlreadySeen>(heap_id);
1171 }
1172 seen->set(heap_id, true);
1173
1174 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1175 return out_node;
1176}
1177
1178
1179hnode_t* trace__ForkWait::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1180 seen = seen ? seen : Alloc<Dict<int, bool>>();
1181 int heap_id = ObjectId(this);
1182 if (dict_contains(seen, heap_id)) {
1183 return Alloc<hnode::AlreadySeen>(heap_id);
1184 }
1185 seen->set(heap_id, true);
1186
1187 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1188 return out_node;
1189}
1190
1191
1192hnode_t* trace__Fork::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1193 seen = seen ? seen : Alloc<Dict<int, bool>>();
1194 int heap_id = ObjectId(this);
1195 if (dict_contains(seen, heap_id)) {
1196 return Alloc<hnode::AlreadySeen>(heap_id);
1197 }
1198 seen->set(heap_id, true);
1199
1200 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1201 return out_node;
1202}
1203
1204
1205hnode_t* trace__PipelinePart::PrettyTree(bool do_abbrev, Dict<int, bool>* seen)
1206 {
1207 seen = seen ? seen : Alloc<Dict<int, bool>>();
1208 int heap_id = ObjectId(this);
1209 if (dict_contains(seen, heap_id)) {
1210 return Alloc<hnode::AlreadySeen>(heap_id);
1211 }
1212 seen->set(heap_id, true);
1213
1214 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1215 return out_node;
1216}
1217
1218
1219hnode_t* trace__ProcessSub::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1220 seen = seen ? seen : Alloc<Dict<int, bool>>();
1221 int heap_id = ObjectId(this);
1222 if (dict_contains(seen, heap_id)) {
1223 return Alloc<hnode::AlreadySeen>(heap_id);
1224 }
1225 seen->set(heap_id, true);
1226
1227 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1228 return out_node;
1229}
1230
1231
1232hnode_t* trace__HereDoc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1233 seen = seen ? seen : Alloc<Dict<int, bool>>();
1234 int heap_id = ObjectId(this);
1235 if (dict_contains(seen, heap_id)) {
1236 return Alloc<hnode::AlreadySeen>(heap_id);
1237 }
1238 seen->set(heap_id, true);
1239
1240 hnode::Record* out_node = runtime::NewRecord(trace_str(this->tag()));
1241 return out_node;
1242}
1243
1244
1245hnode_t* trace_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1246 switch (this->tag()) {
1247 case trace_e::External: {
1248 trace__External* obj = static_cast<trace__External*>(this);
1249 return obj->PrettyTree(do_abbrev, seen);
1250 }
1251 case trace_e::CommandSub: {
1252 trace__CommandSub* obj = static_cast<trace__CommandSub*>(this);
1253 return obj->PrettyTree(do_abbrev, seen);
1254 }
1255 case trace_e::ForkWait: {
1256 trace__ForkWait* obj = static_cast<trace__ForkWait*>(this);
1257 return obj->PrettyTree(do_abbrev, seen);
1258 }
1259 case trace_e::Fork: {
1260 trace__Fork* obj = static_cast<trace__Fork*>(this);
1261 return obj->PrettyTree(do_abbrev, seen);
1262 }
1263 case trace_e::PipelinePart: {
1264 trace__PipelinePart* obj = static_cast<trace__PipelinePart*>(this);
1265 return obj->PrettyTree(do_abbrev, seen);
1266 }
1267 case trace_e::ProcessSub: {
1268 trace__ProcessSub* obj = static_cast<trace__ProcessSub*>(this);
1269 return obj->PrettyTree(do_abbrev, seen);
1270 }
1271 case trace_e::HereDoc: {
1272 trace__HereDoc* obj = static_cast<trace__HereDoc*>(this);
1273 return obj->PrettyTree(do_abbrev, seen);
1274 }
1275 default:
1276 assert(0);
1277 }
1278}
1279BigStr* word_style_str(word_style_e tag, bool dot) {
1280 char buf[32];
1281 const char* v = nullptr;
1282 switch (tag) {
1283 case word_style_e::Expr:
1284 v = "Expr"; break;
1285 case word_style_e::Unquoted:
1286 v = "Unquoted"; break;
1287 case word_style_e::DQ:
1288 v = "DQ"; break;
1289 case word_style_e::SQ:
1290 v = "SQ"; break;
1291 default:
1292 assert(0);
1293 }
1294 if (dot) {
1295 snprintf(buf, 32, "word_style.%s", v);
1296 return StrFromC(buf);
1297 } else {
1298 return StrFromC(v);
1299 }
1300}
1301
1302hnode_t* HayNode::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1303 seen = seen ? seen : Alloc<Dict<int, bool>>();
1304 int heap_id = ObjectId(this);
1305 if (dict_contains(seen, heap_id)) {
1306 return Alloc<hnode::AlreadySeen>(heap_id);
1307 }
1308 seen->set(heap_id, true);
1309
1310 hnode::Record* out_node = runtime::NewRecord(StrFromC("HayNode"));
1311 List<Field*>* L = out_node->fields;
1312
1313 if (this->children != nullptr) { // Dict
1314 auto* unnamed = NewList<hnode_t*>();
1315 auto* hdict = Alloc<hnode::Record>(kEmptyString, StrFromC("{"),
1316 StrFromC("}"),
1317 NewList<Field*>(), unnamed);
1318 for (DictIter<BigStr*, HayNode*> it(this->children); !it.Done(); it.Next())
1319 {
1320 auto k = it.Key();
1321 auto v = it.Value();
1322 unnamed->append(ToPretty(k));
1323 unnamed->append(v->PrettyTree(do_abbrev, seen));
1324 }
1325 L->append(Alloc<Field>(StrFromC("children"), hdict));
1326 }
1327
1328 return out_node;
1329}
1330
1331BigStr* comp_action_str(comp_action_e tag, bool dot) {
1332 char buf[32];
1333 const char* v = nullptr;
1334 switch (tag) {
1335 case comp_action_e::Other:
1336 v = "Other"; break;
1337 case comp_action_e::FileSystem:
1338 v = "FileSystem"; break;
1339 case comp_action_e::BashFunc:
1340 v = "BashFunc"; break;
1341 default:
1342 assert(0);
1343 }
1344 if (dot) {
1345 snprintf(buf, 32, "comp_action.%s", v);
1346 return StrFromC(buf);
1347 } else {
1348 return StrFromC(v);
1349 }
1350}
1351BigStr* trap_action_str(int tag, bool dot) {
1352 char buf[32];
1353 const char* v = nullptr;
1354 switch (tag) {
1355 case trap_action_e::Ignored:
1356 v = "Ignored"; break;
1357 case trap_action_e::Command:
1358 v = "Command"; break;
1359 default:
1360 assert(0);
1361 }
1362 if (dot) {
1363 snprintf(buf, 32, "trap_action.%s", v);
1364 return StrFromC(buf);
1365 } else {
1366 return StrFromC(v);
1367 }
1368}
1369
1370trap_action__Ignored* trap_action::Ignored = &gtrap_action__Ignored.obj;
1371
1372GcGlobal<trap_action__Ignored> gtrap_action__Ignored =
1373 { ObjHeader::Global(trap_action_e::Ignored) };
1374
1375hnode_t* trap_action__Ignored::PrettyTree(bool do_abbrev, Dict<int, bool>*
1376 seen) {
1377 seen = seen ? seen : Alloc<Dict<int, bool>>();
1378 int heap_id = ObjectId(this);
1379 if (dict_contains(seen, heap_id)) {
1380 return Alloc<hnode::AlreadySeen>(heap_id);
1381 }
1382 seen->set(heap_id, true);
1383
1384 hnode::Record* out_node = runtime::NewRecord(trap_action_str(this->tag()));
1385 return out_node;
1386}
1387
1388
1389hnode_t* trap_action__Command::PrettyTree(bool do_abbrev, Dict<int, bool>*
1390 seen) {
1391 seen = seen ? seen : Alloc<Dict<int, bool>>();
1392 int heap_id = ObjectId(this);
1393 if (dict_contains(seen, heap_id)) {
1394 return Alloc<hnode::AlreadySeen>(heap_id);
1395 }
1396 seen->set(heap_id, true);
1397
1398 hnode::Record* out_node = runtime::NewRecord(trap_action_str(this->tag()));
1399 List<Field*>* L = out_node->fields;
1400
1401 hnode_t* x0 = this->c->PrettyTree(do_abbrev, seen);
1402 L->append(Alloc<Field>(StrFromC("c"), x0));
1403
1404 return out_node;
1405}
1406
1407
1408hnode_t* trap_action_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
1409 switch (this->tag()) {
1410 case trap_action_e::Ignored: {
1411 trap_action__Ignored* obj = static_cast<trap_action__Ignored*>(this);
1412 return obj->PrettyTree(do_abbrev, seen);
1413 }
1414 case trap_action_e::Command: {
1415 trap_action__Command* obj = static_cast<trap_action__Command*>(this);
1416 return obj->PrettyTree(do_abbrev, seen);
1417 }
1418 default:
1419 assert(0);
1420 }
1421}
1422
1423} // namespace runtime_asdl