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

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