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

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