OILS / _devbuild / gen / runtime_asdl.py View on Github | oils.pub

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