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

1539 lines, 1106 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 job_state_t(pybase.SimpleObj):
548 pass
549
550class job_state_e(object):
551 Running = job_state_t(1)
552 Exited = job_state_t(2)
553 Stopped = job_state_t(3)
554
555_job_state_str = {
556 1: 'Running',
557 2: 'Exited',
558 3: 'Stopped',
559}
560
561def job_state_str(val, dot=True):
562 # type: (job_state_t, bool) -> str
563 v = _job_state_str[val]
564 if dot:
565 return "job_state.%s" % v
566 else:
567 return v
568
569class wait_status_e(object):
570 Proc = 1
571 Pipeline = 2
572 Cancelled = 3
573
574_wait_status_str = {
575 1: 'Proc',
576 2: 'Pipeline',
577 3: 'Cancelled',
578}
579
580def wait_status_str(tag, dot=True):
581 # type: (int, bool) -> str
582 v = _wait_status_str[tag]
583 if dot:
584 return "wait_status.%s" % v
585 else:
586 return v
587
588class wait_status_t(pybase.CompoundObj):
589 def tag(self):
590 # type: () -> int
591 return self._type_tag
592
593class wait_status(object):
594 class Proc(wait_status_t):
595 _type_tag = 1
596 __slots__ = ('state', 'code')
597
598 def __init__(self, state, code):
599 # type: (job_state_t, int) -> None
600 self.state = state
601 self.code = code
602
603 @staticmethod
604 def CreateNull(alloc_lists=False):
605 # type: () -> wait_status.Proc
606 return wait_status.Proc(job_state_e.Running, -1)
607
608 def PrettyTree(self, do_abbrev, trav=None):
609 # type: (bool, Optional[TraversalState]) -> hnode_t
610 trav = trav or TraversalState()
611 heap_id = id(self)
612 if heap_id in trav.seen:
613 return hnode.AlreadySeen(heap_id)
614 trav.seen[heap_id] = True
615
616 out_node = NewRecord('wait_status.Proc')
617 L = out_node.fields
618
619 x0 = hnode.Leaf(job_state_str(self.state), color_e.TypeName)
620 L.append(Field('state', x0))
621
622 x1 = hnode.Leaf(str(self.code), color_e.OtherConst)
623 L.append(Field('code', x1))
624
625 return out_node
626
627 class Pipeline(wait_status_t):
628 _type_tag = 2
629 __slots__ = ('state', 'codes')
630
631 def __init__(self, state, codes):
632 # type: (job_state_t, List[int]) -> None
633 self.state = state
634 self.codes = codes
635
636 @staticmethod
637 def CreateNull(alloc_lists=False):
638 # type: () -> wait_status.Pipeline
639 return wait_status.Pipeline(job_state_e.Running, [] if alloc_lists else cast('List[int]', None))
640
641 def PrettyTree(self, do_abbrev, trav=None):
642 # type: (bool, Optional[TraversalState]) -> hnode_t
643 trav = trav or TraversalState()
644 heap_id = id(self)
645 if heap_id in trav.seen:
646 return hnode.AlreadySeen(heap_id)
647 trav.seen[heap_id] = True
648
649 out_node = NewRecord('wait_status.Pipeline')
650 L = out_node.fields
651
652 x0 = hnode.Leaf(job_state_str(self.state), color_e.TypeName)
653 L.append(Field('state', x0))
654
655 if self.codes is not None: # List
656 x1 = hnode.Array([])
657 for i1 in self.codes:
658 x1.children.append(hnode.Leaf(str(i1), color_e.OtherConst))
659 L.append(Field('codes', x1))
660
661 return out_node
662
663 class Cancelled(wait_status_t):
664 _type_tag = 3
665 __slots__ = ('sig_num',)
666
667 def __init__(self, sig_num):
668 # type: (int) -> None
669 self.sig_num = sig_num
670
671 @staticmethod
672 def CreateNull(alloc_lists=False):
673 # type: () -> wait_status.Cancelled
674 return wait_status.Cancelled(-1)
675
676 def PrettyTree(self, do_abbrev, trav=None):
677 # type: (bool, Optional[TraversalState]) -> hnode_t
678 trav = trav or TraversalState()
679 heap_id = id(self)
680 if heap_id in trav.seen:
681 return hnode.AlreadySeen(heap_id)
682 trav.seen[heap_id] = True
683
684 out_node = NewRecord('wait_status.Cancelled')
685 L = out_node.fields
686
687 x0 = hnode.Leaf(str(self.sig_num), color_e.OtherConst)
688 L.append(Field('sig_num', x0))
689
690 return out_node
691
692 pass
693
694class flow_t(pybase.SimpleObj):
695 pass
696
697class flow_e(object):
698 Nothing = flow_t(1)
699 Break = flow_t(2)
700 Raise = flow_t(3)
701
702_flow_str = {
703 1: 'Nothing',
704 2: 'Break',
705 3: 'Raise',
706}
707
708def flow_str(val, dot=True):
709 # type: (flow_t, bool) -> str
710 v = _flow_str[val]
711 if dot:
712 return "flow.%s" % v
713 else:
714 return v
715
716class span_t(pybase.SimpleObj):
717 pass
718
719class span_e(object):
720 Black = span_t(1)
721 Delim = span_t(2)
722 Backslash = span_t(3)
723
724_span_str = {
725 1: 'Black',
726 2: 'Delim',
727 3: 'Backslash',
728}
729
730def span_str(val, dot=True):
731 # type: (span_t, bool) -> str
732 v = _span_str[val]
733 if dot:
734 return "span.%s" % v
735 else:
736 return v
737
738emit_t = int # type alias for integer
739
740class emit_i(object):
741 Part = 1
742 Delim = 2
743 Empty = 3
744 Escape = 4
745 Nothing = 5
746 ARRAY_SIZE = 6
747
748_emit_str = {
749 1: 'Part',
750 2: 'Delim',
751 3: 'Empty',
752 4: 'Escape',
753 5: 'Nothing',
754}
755
756def emit_str(val, dot=True):
757 # type: (emit_t, bool) -> str
758 v = _emit_str[val]
759 if dot:
760 return "emit.%s" % v
761 else:
762 return v
763
764state_t = int # type alias for integer
765
766class state_i(object):
767 Invalid = 1
768 Start = 2
769 DE_White1 = 3
770 DE_Gray = 4
771 DE_White2 = 5
772 Black = 6
773 Backslash = 7
774 Done = 8
775 ARRAY_SIZE = 9
776
777_state_str = {
778 1: 'Invalid',
779 2: 'Start',
780 3: 'DE_White1',
781 4: 'DE_Gray',
782 5: 'DE_White2',
783 6: 'Black',
784 7: 'Backslash',
785 8: 'Done',
786}
787
788def state_str(val, dot=True):
789 # type: (state_t, bool) -> str
790 v = _state_str[val]
791 if dot:
792 return "state.%s" % v
793 else:
794 return v
795
796char_kind_t = int # type alias for integer
797
798class char_kind_i(object):
799 DE_White = 1
800 DE_Gray = 2
801 Black = 3
802 Backslash = 4
803 Sentinel = 5
804 ARRAY_SIZE = 6
805
806_char_kind_str = {
807 1: 'DE_White',
808 2: 'DE_Gray',
809 3: 'Black',
810 4: 'Backslash',
811 5: 'Sentinel',
812}
813
814def char_kind_str(val, dot=True):
815 # type: (char_kind_t, bool) -> str
816 v = _char_kind_str[val]
817 if dot:
818 return "char_kind.%s" % v
819 else:
820 return v
821
822class error_code_t(pybase.SimpleObj):
823 pass
824
825class error_code_e(object):
826 OK = error_code_t(1)
827 IndexOutOfRange = error_code_t(2)
828
829_error_code_str = {
830 1: 'OK',
831 2: 'IndexOutOfRange',
832}
833
834def error_code_str(val, dot=True):
835 # type: (error_code_t, bool) -> str
836 v = _error_code_str[val]
837 if dot:
838 return "error_code.%s" % v
839 else:
840 return v
841
842class flag_type_t(pybase.SimpleObj):
843 pass
844
845class flag_type_e(object):
846 Bool = flag_type_t(1)
847 Int = flag_type_t(2)
848 Float = flag_type_t(3)
849 Str = flag_type_t(4)
850
851_flag_type_str = {
852 1: 'Bool',
853 2: 'Int',
854 3: 'Float',
855 4: 'Str',
856}
857
858def flag_type_str(val, dot=True):
859 # type: (flag_type_t, bool) -> str
860 v = _flag_type_str[val]
861 if dot:
862 return "flag_type.%s" % v
863 else:
864 return v
865
866class trace_e(object):
867 External = 1
868 CommandSub = 2
869 ForkWait = 3
870 Fork = 4
871 PipelinePart = 5
872 ProcessSub = 6
873 HereDoc = 7
874
875_trace_str = {
876 1: 'External',
877 2: 'CommandSub',
878 3: 'ForkWait',
879 4: 'Fork',
880 5: 'PipelinePart',
881 6: 'ProcessSub',
882 7: 'HereDoc',
883}
884
885def trace_str(tag, dot=True):
886 # type: (int, bool) -> str
887 v = _trace_str[tag]
888 if dot:
889 return "trace.%s" % v
890 else:
891 return v
892
893class trace_t(pybase.CompoundObj):
894 def tag(self):
895 # type: () -> int
896 return self._type_tag
897
898class trace__CommandSub(trace_t):
899 _type_tag = 2
900 __slots__ = ()
901
902 def __init__(self, ):
903 # type: () -> None
904 pass
905
906 def PrettyTree(self, do_abbrev, trav=None):
907 # type: (bool, Optional[TraversalState]) -> hnode_t
908 trav = trav or TraversalState()
909 heap_id = id(self)
910 if heap_id in trav.seen:
911 return hnode.AlreadySeen(heap_id)
912 trav.seen[heap_id] = True
913
914 out_node = NewRecord('trace.CommandSub')
915 L = out_node.fields
916
917 return out_node
918
919class trace__ForkWait(trace_t):
920 _type_tag = 3
921 __slots__ = ()
922
923 def __init__(self, ):
924 # type: () -> None
925 pass
926
927 def PrettyTree(self, do_abbrev, trav=None):
928 # type: (bool, Optional[TraversalState]) -> hnode_t
929 trav = trav or TraversalState()
930 heap_id = id(self)
931 if heap_id in trav.seen:
932 return hnode.AlreadySeen(heap_id)
933 trav.seen[heap_id] = True
934
935 out_node = NewRecord('trace.ForkWait')
936 L = out_node.fields
937
938 return out_node
939
940class trace__Fork(trace_t):
941 _type_tag = 4
942 __slots__ = ()
943
944 def __init__(self, ):
945 # type: () -> None
946 pass
947
948 def PrettyTree(self, do_abbrev, trav=None):
949 # type: (bool, Optional[TraversalState]) -> hnode_t
950 trav = trav or TraversalState()
951 heap_id = id(self)
952 if heap_id in trav.seen:
953 return hnode.AlreadySeen(heap_id)
954 trav.seen[heap_id] = True
955
956 out_node = NewRecord('trace.Fork')
957 L = out_node.fields
958
959 return out_node
960
961class trace__PipelinePart(trace_t):
962 _type_tag = 5
963 __slots__ = ()
964
965 def __init__(self, ):
966 # type: () -> None
967 pass
968
969 def PrettyTree(self, do_abbrev, trav=None):
970 # type: (bool, Optional[TraversalState]) -> hnode_t
971 trav = trav or TraversalState()
972 heap_id = id(self)
973 if heap_id in trav.seen:
974 return hnode.AlreadySeen(heap_id)
975 trav.seen[heap_id] = True
976
977 out_node = NewRecord('trace.PipelinePart')
978 L = out_node.fields
979
980 return out_node
981
982class trace__ProcessSub(trace_t):
983 _type_tag = 6
984 __slots__ = ()
985
986 def __init__(self, ):
987 # type: () -> None
988 pass
989
990 def PrettyTree(self, do_abbrev, trav=None):
991 # type: (bool, Optional[TraversalState]) -> hnode_t
992 trav = trav or TraversalState()
993 heap_id = id(self)
994 if heap_id in trav.seen:
995 return hnode.AlreadySeen(heap_id)
996 trav.seen[heap_id] = True
997
998 out_node = NewRecord('trace.ProcessSub')
999 L = out_node.fields
1000
1001 return out_node
1002
1003class trace__HereDoc(trace_t):
1004 _type_tag = 7
1005 __slots__ = ()
1006
1007 def __init__(self, ):
1008 # type: () -> None
1009 pass
1010
1011 def PrettyTree(self, do_abbrev, trav=None):
1012 # type: (bool, Optional[TraversalState]) -> hnode_t
1013 trav = trav or TraversalState()
1014 heap_id = id(self)
1015 if heap_id in trav.seen:
1016 return hnode.AlreadySeen(heap_id)
1017 trav.seen[heap_id] = True
1018
1019 out_node = NewRecord('trace.HereDoc')
1020 L = out_node.fields
1021
1022 return out_node
1023
1024class trace(object):
1025 class External(trace_t):
1026 _type_tag = 1
1027 __slots__ = ('argv',)
1028
1029 def __init__(self, argv):
1030 # type: (List[str]) -> None
1031 self.argv = argv
1032
1033 @staticmethod
1034 def CreateNull(alloc_lists=False):
1035 # type: () -> trace.External
1036 return trace.External([] if alloc_lists else cast('List[str]', None))
1037
1038 def PrettyTree(self, do_abbrev, trav=None):
1039 # type: (bool, Optional[TraversalState]) -> hnode_t
1040 trav = trav or TraversalState()
1041 heap_id = id(self)
1042 if heap_id in trav.seen:
1043 return hnode.AlreadySeen(heap_id)
1044 trav.seen[heap_id] = True
1045
1046 out_node = NewRecord('trace.External')
1047 L = out_node.fields
1048
1049 if self.argv is not None: # List
1050 x0 = hnode.Array([])
1051 for i0 in self.argv:
1052 x0.children.append(NewLeaf(i0, color_e.StringConst))
1053 L.append(Field('argv', x0))
1054
1055 return out_node
1056
1057 CommandSub = trace__CommandSub()
1058
1059 ForkWait = trace__ForkWait()
1060
1061 Fork = trace__Fork()
1062
1063 PipelinePart = trace__PipelinePart()
1064
1065 ProcessSub = trace__ProcessSub()
1066
1067 HereDoc = trace__HereDoc()
1068
1069 pass
1070
1071class word_style_t(pybase.SimpleObj):
1072 pass
1073
1074class word_style_e(object):
1075 Expr = word_style_t(1)
1076 Unquoted = word_style_t(2)
1077 DQ = word_style_t(3)
1078 SQ = word_style_t(4)
1079
1080_word_style_str = {
1081 1: 'Expr',
1082 2: 'Unquoted',
1083 3: 'DQ',
1084 4: 'SQ',
1085}
1086
1087def word_style_str(val, dot=True):
1088 # type: (word_style_t, bool) -> str
1089 v = _word_style_str[val]
1090 if dot:
1091 return "word_style.%s" % v
1092 else:
1093 return v
1094
1095class comp_action_t(pybase.SimpleObj):
1096 pass
1097
1098class comp_action_e(object):
1099 Other = comp_action_t(1)
1100 FileSystem = comp_action_t(2)
1101 BashFunc = comp_action_t(3)
1102
1103_comp_action_str = {
1104 1: 'Other',
1105 2: 'FileSystem',
1106 3: 'BashFunc',
1107}
1108
1109def comp_action_str(val, dot=True):
1110 # type: (comp_action_t, bool) -> str
1111 v = _comp_action_str[val]
1112 if dot:
1113 return "comp_action.%s" % v
1114 else:
1115 return v
1116
1117class AssignArg(pybase.CompoundObj):
1118 _type_tag = 64
1119 __slots__ = ('var_name', 'rval', 'plus_eq', 'blame_word')
1120
1121 def __init__(self, var_name, rval, plus_eq, blame_word):
1122 # type: (str, Optional[value_t], bool, CompoundWord) -> None
1123 self.var_name = var_name
1124 self.rval = rval
1125 self.plus_eq = plus_eq
1126 self.blame_word = blame_word
1127
1128 @staticmethod
1129 def CreateNull(alloc_lists=False):
1130 # type: () -> AssignArg
1131 return AssignArg('', cast('Optional[value_t]', None), False, cast('CompoundWord', None))
1132
1133 def PrettyTree(self, do_abbrev, trav=None):
1134 # type: (bool, Optional[TraversalState]) -> hnode_t
1135 trav = trav or TraversalState()
1136 heap_id = id(self)
1137 if heap_id in trav.seen:
1138 return hnode.AlreadySeen(heap_id)
1139 trav.seen[heap_id] = True
1140
1141 out_node = NewRecord('AssignArg')
1142 L = out_node.fields
1143
1144 x0 = NewLeaf(self.var_name, color_e.StringConst)
1145 L.append(Field('var_name', x0))
1146
1147 if self.rval is not None: # Optional
1148 x1 = self.rval.PrettyTree(do_abbrev, trav=trav)
1149 L.append(Field('rval', x1))
1150
1151 x2 = hnode.Leaf('T' if self.plus_eq else 'F', color_e.OtherConst)
1152 L.append(Field('plus_eq', x2))
1153
1154 assert self.blame_word is not None
1155 x3 = self.blame_word.PrettyTree(do_abbrev, trav=trav)
1156 L.append(Field('blame_word', x3))
1157
1158 return out_node
1159
1160class ProcArgs(pybase.CompoundObj):
1161 _type_tag = 65
1162 __slots__ = ('typed_args', 'pos_args', 'named_args', 'block_arg')
1163
1164 def __init__(self, typed_args, pos_args, named_args, block_arg):
1165 # type: (ArgList, Optional[List[value_t]], Optional[Dict[str, value_t]], Optional[value_t]) -> None
1166 self.typed_args = typed_args
1167 self.pos_args = pos_args
1168 self.named_args = named_args
1169 self.block_arg = block_arg
1170
1171 @staticmethod
1172 def CreateNull(alloc_lists=False):
1173 # type: () -> ProcArgs
1174 return ProcArgs(cast('ArgList', None), cast('Optional[List[value_t]]', None), cast('Optional[Dict[str, value_t]]', None), cast('Optional[value_t]', None))
1175
1176 def PrettyTree(self, do_abbrev, trav=None):
1177 # type: (bool, Optional[TraversalState]) -> hnode_t
1178 trav = trav or TraversalState()
1179 heap_id = id(self)
1180 if heap_id in trav.seen:
1181 return hnode.AlreadySeen(heap_id)
1182 trav.seen[heap_id] = True
1183
1184 out_node = NewRecord('ProcArgs')
1185 L = out_node.fields
1186
1187 assert self.typed_args is not None
1188 x0 = self.typed_args.PrettyTree(do_abbrev, trav=trav)
1189 L.append(Field('typed_args', x0))
1190
1191 if self.pos_args is not None: # List
1192 x1 = hnode.Array([])
1193 for i1 in self.pos_args:
1194 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1195 i1.PrettyTree(do_abbrev, trav=trav))
1196 x1.children.append(h)
1197 L.append(Field('pos_args', x1))
1198
1199 if self.named_args is not None: # Dict
1200 unnamed2 = [] # type: List[hnode_t]
1201 x2 = hnode.Record("", "{", "}", [], unnamed2)
1202 for k2, v2 in self.named_args.iteritems():
1203 unnamed2.append(NewLeaf(k2, color_e.StringConst))
1204 unnamed2.append(v2.PrettyTree(do_abbrev, trav=trav))
1205 L.append(Field('named_args', x2))
1206
1207 if self.block_arg is not None: # Optional
1208 x3 = self.block_arg.PrettyTree(do_abbrev, trav=trav)
1209 L.append(Field('block_arg', x3))
1210
1211 return out_node
1212
1213class Piece(part_value_t):
1214 _type_tag = 66
1215 __slots__ = ('s', 'quoted', 'do_split')
1216
1217 def __init__(self, s, quoted, do_split):
1218 # type: (str, bool, bool) -> None
1219 self.s = s
1220 self.quoted = quoted
1221 self.do_split = do_split
1222
1223 @staticmethod
1224 def CreateNull(alloc_lists=False):
1225 # type: () -> Piece
1226 return Piece('', False, False)
1227
1228 def PrettyTree(self, do_abbrev, trav=None):
1229 # type: (bool, Optional[TraversalState]) -> hnode_t
1230 trav = trav or TraversalState()
1231 heap_id = id(self)
1232 if heap_id in trav.seen:
1233 return hnode.AlreadySeen(heap_id)
1234 trav.seen[heap_id] = True
1235
1236 out_node = NewRecord('Piece')
1237 L = out_node.fields
1238
1239 x0 = NewLeaf(self.s, color_e.StringConst)
1240 L.append(Field('s', x0))
1241
1242 x1 = hnode.Leaf('T' if self.quoted else 'F', color_e.OtherConst)
1243 L.append(Field('quoted', x1))
1244
1245 x2 = hnode.Leaf('T' if self.do_split else 'F', color_e.OtherConst)
1246 L.append(Field('do_split', x2))
1247
1248 return out_node
1249
1250class VarSubState(pybase.CompoundObj):
1251 _type_tag = 67
1252 __slots__ = ('join_array', 'h_value', 'array_ref')
1253
1254 def __init__(self, join_array, h_value, array_ref):
1255 # type: (bool, value_t, Token) -> None
1256 self.join_array = join_array
1257 self.h_value = h_value
1258 self.array_ref = array_ref
1259
1260 @staticmethod
1261 def CreateNull(alloc_lists=False):
1262 # type: () -> VarSubState
1263 return VarSubState(False, cast('value_t', None), cast('Token', None))
1264
1265 def PrettyTree(self, do_abbrev, trav=None):
1266 # type: (bool, Optional[TraversalState]) -> hnode_t
1267 trav = trav or TraversalState()
1268 heap_id = id(self)
1269 if heap_id in trav.seen:
1270 return hnode.AlreadySeen(heap_id)
1271 trav.seen[heap_id] = True
1272
1273 out_node = NewRecord('VarSubState')
1274 L = out_node.fields
1275
1276 x0 = hnode.Leaf('T' if self.join_array else 'F', color_e.OtherConst)
1277 L.append(Field('join_array', x0))
1278
1279 assert self.h_value is not None
1280 x1 = self.h_value.PrettyTree(do_abbrev, trav=trav)
1281 L.append(Field('h_value', x1))
1282
1283 assert self.array_ref is not None
1284 x2 = self.array_ref.PrettyTree(do_abbrev, trav=trav)
1285 L.append(Field('array_ref', x2))
1286
1287 return out_node
1288
1289class Cell(pybase.CompoundObj):
1290 _type_tag = 68
1291 __slots__ = ('exported', 'readonly', 'nameref', 'val')
1292
1293 def __init__(self, exported, readonly, nameref, val):
1294 # type: (bool, bool, bool, value_t) -> None
1295 self.exported = exported
1296 self.readonly = readonly
1297 self.nameref = nameref
1298 self.val = val
1299
1300 @staticmethod
1301 def CreateNull(alloc_lists=False):
1302 # type: () -> Cell
1303 return Cell(False, False, False, cast('value_t', None))
1304
1305 def PrettyTree(self, do_abbrev, trav=None):
1306 # type: (bool, Optional[TraversalState]) -> hnode_t
1307 trav = trav or TraversalState()
1308 heap_id = id(self)
1309 if heap_id in trav.seen:
1310 return hnode.AlreadySeen(heap_id)
1311 trav.seen[heap_id] = True
1312
1313 out_node = NewRecord('Cell')
1314 L = out_node.fields
1315
1316 x0 = hnode.Leaf('T' if self.exported else 'F', color_e.OtherConst)
1317 L.append(Field('exported', x0))
1318
1319 x1 = hnode.Leaf('T' if self.readonly else 'F', color_e.OtherConst)
1320 L.append(Field('readonly', x1))
1321
1322 x2 = hnode.Leaf('T' if self.nameref else 'F', color_e.OtherConst)
1323 L.append(Field('nameref', x2))
1324
1325 assert self.val is not None
1326 x3 = self.val.PrettyTree(do_abbrev, trav=trav)
1327 L.append(Field('val', x3))
1328
1329 return out_node
1330
1331class VTestPlace(pybase.CompoundObj):
1332 _type_tag = 69
1333 __slots__ = ('name', 'index')
1334
1335 def __init__(self, name, index):
1336 # type: (Optional[str], Optional[a_index_t]) -> None
1337 self.name = name
1338 self.index = index
1339
1340 @staticmethod
1341 def CreateNull(alloc_lists=False):
1342 # type: () -> VTestPlace
1343 return VTestPlace(cast('Optional[str]', None), cast('Optional[a_index_t]', None))
1344
1345 def PrettyTree(self, do_abbrev, trav=None):
1346 # type: (bool, Optional[TraversalState]) -> hnode_t
1347 trav = trav or TraversalState()
1348 heap_id = id(self)
1349 if heap_id in trav.seen:
1350 return hnode.AlreadySeen(heap_id)
1351 trav.seen[heap_id] = True
1352
1353 out_node = NewRecord('VTestPlace')
1354 L = out_node.fields
1355
1356 if self.name is not None: # Optional
1357 x0 = NewLeaf(self.name, color_e.StringConst)
1358 L.append(Field('name', x0))
1359
1360 if self.index is not None: # Optional
1361 x1 = self.index.PrettyTree(do_abbrev, trav=trav)
1362 L.append(Field('index', x1))
1363
1364 return out_node
1365
1366class RedirValue(pybase.CompoundObj):
1367 _type_tag = 70
1368 __slots__ = ('op_id', 'op_loc', 'loc', 'arg')
1369
1370 def __init__(self, op_id, op_loc, loc, arg):
1371 # type: (Id_t, loc_t, redir_loc_t, redirect_arg_t) -> None
1372 self.op_id = op_id
1373 self.op_loc = op_loc
1374 self.loc = loc
1375 self.arg = arg
1376
1377 @staticmethod
1378 def CreateNull(alloc_lists=False):
1379 # type: () -> RedirValue
1380 return RedirValue(-1, cast('loc_t', None), cast('redir_loc_t', None), cast('redirect_arg_t', None))
1381
1382 def PrettyTree(self, do_abbrev, trav=None):
1383 # type: (bool, Optional[TraversalState]) -> hnode_t
1384 trav = trav or TraversalState()
1385 heap_id = id(self)
1386 if heap_id in trav.seen:
1387 return hnode.AlreadySeen(heap_id)
1388 trav.seen[heap_id] = True
1389
1390 out_node = NewRecord('RedirValue')
1391 L = out_node.fields
1392
1393 x0 = hnode.Leaf(Id_str(self.op_id, dot=False), color_e.UserType)
1394 L.append(Field('op_id', x0))
1395
1396 assert self.op_loc is not None
1397 x1 = self.op_loc.PrettyTree(do_abbrev, trav=trav)
1398 L.append(Field('op_loc', x1))
1399
1400 assert self.loc is not None
1401 x2 = self.loc.PrettyTree(do_abbrev, trav=trav)
1402 L.append(Field('loc', x2))
1403
1404 assert self.arg is not None
1405 x3 = self.arg.PrettyTree(do_abbrev, trav=trav)
1406 L.append(Field('arg', x3))
1407
1408 return out_node
1409
1410class StatusArray(pybase.CompoundObj):
1411 _type_tag = 71
1412 __slots__ = ('codes', 'locs')
1413
1414 def __init__(self, codes, locs):
1415 # type: (Optional[List[int]], Optional[List[loc_t]]) -> None
1416 self.codes = codes
1417 self.locs = locs
1418
1419 @staticmethod
1420 def CreateNull(alloc_lists=False):
1421 # type: () -> StatusArray
1422 return StatusArray(cast('Optional[List[int]]', None), cast('Optional[List[loc_t]]', None))
1423
1424 def PrettyTree(self, do_abbrev, trav=None):
1425 # type: (bool, Optional[TraversalState]) -> hnode_t
1426 trav = trav or TraversalState()
1427 heap_id = id(self)
1428 if heap_id in trav.seen:
1429 return hnode.AlreadySeen(heap_id)
1430 trav.seen[heap_id] = True
1431
1432 out_node = NewRecord('StatusArray')
1433 L = out_node.fields
1434
1435 if self.codes is not None: # List
1436 x0 = hnode.Array([])
1437 for i0 in self.codes:
1438 x0.children.append(hnode.Leaf(str(i0), color_e.OtherConst))
1439 L.append(Field('codes', x0))
1440
1441 if self.locs is not None: # List
1442 x1 = hnode.Array([])
1443 for i1 in self.locs:
1444 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1445 i1.PrettyTree(do_abbrev, trav=trav))
1446 x1.children.append(h)
1447 L.append(Field('locs', x1))
1448
1449 return out_node
1450
1451class CommandStatus(pybase.CompoundObj):
1452 _type_tag = 72
1453 __slots__ = ('check_errexit', 'show_code', 'pipe_negated', 'pipe_status',
1454 'pipe_locs')
1455
1456 def __init__(self, check_errexit, show_code, pipe_negated, pipe_status,
1457 pipe_locs):
1458 # type: (bool, bool, bool, Optional[List[int]], Optional[List[loc_t]]) -> None
1459 self.check_errexit = check_errexit
1460 self.show_code = show_code
1461 self.pipe_negated = pipe_negated
1462 self.pipe_status = pipe_status
1463 self.pipe_locs = pipe_locs
1464
1465 @staticmethod
1466 def CreateNull(alloc_lists=False):
1467 # type: () -> CommandStatus
1468 return CommandStatus(False, False, False, cast('Optional[List[int]]', None), cast('Optional[List[loc_t]]', None))
1469
1470 def PrettyTree(self, do_abbrev, trav=None):
1471 # type: (bool, Optional[TraversalState]) -> hnode_t
1472 trav = trav or TraversalState()
1473 heap_id = id(self)
1474 if heap_id in trav.seen:
1475 return hnode.AlreadySeen(heap_id)
1476 trav.seen[heap_id] = True
1477
1478 out_node = NewRecord('CommandStatus')
1479 L = out_node.fields
1480
1481 x0 = hnode.Leaf('T' if self.check_errexit else 'F', color_e.OtherConst)
1482 L.append(Field('check_errexit', x0))
1483
1484 x1 = hnode.Leaf('T' if self.show_code else 'F', color_e.OtherConst)
1485 L.append(Field('show_code', x1))
1486
1487 x2 = hnode.Leaf('T' if self.pipe_negated else 'F', color_e.OtherConst)
1488 L.append(Field('pipe_negated', x2))
1489
1490 if self.pipe_status is not None: # List
1491 x3 = hnode.Array([])
1492 for i3 in self.pipe_status:
1493 x3.children.append(hnode.Leaf(str(i3), color_e.OtherConst))
1494 L.append(Field('pipe_status', x3))
1495
1496 if self.pipe_locs is not None: # List
1497 x4 = hnode.Array([])
1498 for i4 in self.pipe_locs:
1499 h = (hnode.Leaf("_", color_e.OtherConst) if i4 is None else
1500 i4.PrettyTree(do_abbrev, trav=trav))
1501 x4.children.append(h)
1502 L.append(Field('pipe_locs', x4))
1503
1504 return out_node
1505
1506class HayNode(pybase.CompoundObj):
1507 _type_tag = 73
1508 __slots__ = ('children',)
1509
1510 def __init__(self, children):
1511 # type: (Dict[str, HayNode]) -> None
1512 self.children = children
1513
1514 @staticmethod
1515 def CreateNull(alloc_lists=False):
1516 # type: () -> HayNode
1517 return HayNode(cast('Dict[str, HayNode]', None))
1518
1519 def PrettyTree(self, do_abbrev, trav=None):
1520 # type: (bool, Optional[TraversalState]) -> hnode_t
1521 trav = trav or TraversalState()
1522 heap_id = id(self)
1523 if heap_id in trav.seen:
1524 return hnode.AlreadySeen(heap_id)
1525 trav.seen[heap_id] = True
1526
1527 out_node = NewRecord('HayNode')
1528 L = out_node.fields
1529
1530 if self.children is not None: # Dict
1531 unnamed0 = [] # type: List[hnode_t]
1532 x0 = hnode.Record("", "{", "}", [], unnamed0)
1533 for k0, v0 in self.children.iteritems():
1534 unnamed0.append(NewLeaf(k0, color_e.StringConst))
1535 unnamed0.append(v0.PrettyTree(do_abbrev, trav=trav))
1536 L.append(Field('children', x0))
1537
1538 return out_node
1539