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

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