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

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