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

1617 lines, 1159 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 trap_action_e(object):
1118 Ignored = 1
1119 Command = 2
1120
1121_trap_action_str = {
1122 1: 'Ignored',
1123 2: 'Command',
1124}
1125
1126def trap_action_str(tag, dot=True):
1127 # type: (int, bool) -> str
1128 v = _trap_action_str[tag]
1129 if dot:
1130 return "trap_action.%s" % v
1131 else:
1132 return v
1133
1134class trap_action_t(pybase.CompoundObj):
1135 def tag(self):
1136 # type: () -> int
1137 return self._type_tag
1138
1139class trap_action__Ignored(trap_action_t):
1140 _type_tag = 1
1141 __slots__ = ()
1142
1143 def __init__(self, ):
1144 # type: () -> None
1145 pass
1146
1147 def PrettyTree(self, do_abbrev, trav=None):
1148 # type: (bool, Optional[TraversalState]) -> hnode_t
1149 trav = trav or TraversalState()
1150 heap_id = id(self)
1151 if heap_id in trav.seen:
1152 return hnode.AlreadySeen(heap_id)
1153 trav.seen[heap_id] = True
1154
1155 out_node = NewRecord('trap_action.Ignored')
1156 L = out_node.fields
1157
1158 return out_node
1159
1160class trap_action(object):
1161 Ignored = trap_action__Ignored()
1162
1163 class Command(trap_action_t):
1164 _type_tag = 2
1165 __slots__ = ('c',)
1166
1167 def __init__(self, c):
1168 # type: (command_t) -> None
1169 self.c = c
1170
1171 @staticmethod
1172 def CreateNull(alloc_lists=False):
1173 # type: () -> trap_action.Command
1174 return trap_action.Command(cast('command_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('trap_action.Command')
1185 L = out_node.fields
1186
1187 assert self.c is not None
1188 x0 = self.c.PrettyTree(do_abbrev, trav=trav)
1189 L.append(Field('c', x0))
1190
1191 return out_node
1192
1193 pass
1194
1195class AssignArg(pybase.CompoundObj):
1196 _type_tag = 64
1197 __slots__ = ('var_name', 'rval', 'plus_eq', 'blame_word')
1198
1199 def __init__(self, var_name, rval, plus_eq, blame_word):
1200 # type: (str, Optional[value_t], bool, CompoundWord) -> None
1201 self.var_name = var_name
1202 self.rval = rval
1203 self.plus_eq = plus_eq
1204 self.blame_word = blame_word
1205
1206 @staticmethod
1207 def CreateNull(alloc_lists=False):
1208 # type: () -> AssignArg
1209 return AssignArg('', cast('Optional[value_t]', None), False, cast('CompoundWord', None))
1210
1211 def PrettyTree(self, do_abbrev, trav=None):
1212 # type: (bool, Optional[TraversalState]) -> hnode_t
1213 trav = trav or TraversalState()
1214 heap_id = id(self)
1215 if heap_id in trav.seen:
1216 return hnode.AlreadySeen(heap_id)
1217 trav.seen[heap_id] = True
1218
1219 out_node = NewRecord('AssignArg')
1220 L = out_node.fields
1221
1222 x0 = NewLeaf(self.var_name, color_e.StringConst)
1223 L.append(Field('var_name', x0))
1224
1225 if self.rval is not None: # Optional
1226 x1 = self.rval.PrettyTree(do_abbrev, trav=trav)
1227 L.append(Field('rval', x1))
1228
1229 x2 = hnode.Leaf('T' if self.plus_eq else 'F', color_e.OtherConst)
1230 L.append(Field('plus_eq', x2))
1231
1232 assert self.blame_word is not None
1233 x3 = self.blame_word.PrettyTree(do_abbrev, trav=trav)
1234 L.append(Field('blame_word', x3))
1235
1236 return out_node
1237
1238class ProcArgs(pybase.CompoundObj):
1239 _type_tag = 65
1240 __slots__ = ('typed_args', 'pos_args', 'named_args', 'block_arg')
1241
1242 def __init__(self, typed_args, pos_args, named_args, block_arg):
1243 # type: (ArgList, Optional[List[value_t]], Optional[Dict[str, value_t]], Optional[value_t]) -> None
1244 self.typed_args = typed_args
1245 self.pos_args = pos_args
1246 self.named_args = named_args
1247 self.block_arg = block_arg
1248
1249 @staticmethod
1250 def CreateNull(alloc_lists=False):
1251 # type: () -> ProcArgs
1252 return ProcArgs(cast('ArgList', None), cast('Optional[List[value_t]]', None), cast('Optional[Dict[str, value_t]]', None), cast('Optional[value_t]', None))
1253
1254 def PrettyTree(self, do_abbrev, trav=None):
1255 # type: (bool, Optional[TraversalState]) -> hnode_t
1256 trav = trav or TraversalState()
1257 heap_id = id(self)
1258 if heap_id in trav.seen:
1259 return hnode.AlreadySeen(heap_id)
1260 trav.seen[heap_id] = True
1261
1262 out_node = NewRecord('ProcArgs')
1263 L = out_node.fields
1264
1265 assert self.typed_args is not None
1266 x0 = self.typed_args.PrettyTree(do_abbrev, trav=trav)
1267 L.append(Field('typed_args', x0))
1268
1269 if self.pos_args is not None: # List
1270 x1 = hnode.Array([])
1271 for i1 in self.pos_args:
1272 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1273 i1.PrettyTree(do_abbrev, trav=trav))
1274 x1.children.append(h)
1275 L.append(Field('pos_args', x1))
1276
1277 if self.named_args is not None: # Dict
1278 unnamed2 = [] # type: List[hnode_t]
1279 x2 = hnode.Record("", "{", "}", [], unnamed2)
1280 for k2, v2 in self.named_args.iteritems():
1281 unnamed2.append(NewLeaf(k2, color_e.StringConst))
1282 unnamed2.append(v2.PrettyTree(do_abbrev, trav=trav))
1283 L.append(Field('named_args', x2))
1284
1285 if self.block_arg is not None: # Optional
1286 x3 = self.block_arg.PrettyTree(do_abbrev, trav=trav)
1287 L.append(Field('block_arg', x3))
1288
1289 return out_node
1290
1291class Piece(part_value_t):
1292 _type_tag = 66
1293 __slots__ = ('s', 'quoted', 'do_split')
1294
1295 def __init__(self, s, quoted, do_split):
1296 # type: (str, bool, bool) -> None
1297 self.s = s
1298 self.quoted = quoted
1299 self.do_split = do_split
1300
1301 @staticmethod
1302 def CreateNull(alloc_lists=False):
1303 # type: () -> Piece
1304 return Piece('', False, False)
1305
1306 def PrettyTree(self, do_abbrev, trav=None):
1307 # type: (bool, Optional[TraversalState]) -> hnode_t
1308 trav = trav or TraversalState()
1309 heap_id = id(self)
1310 if heap_id in trav.seen:
1311 return hnode.AlreadySeen(heap_id)
1312 trav.seen[heap_id] = True
1313
1314 out_node = NewRecord('Piece')
1315 L = out_node.fields
1316
1317 x0 = NewLeaf(self.s, color_e.StringConst)
1318 L.append(Field('s', x0))
1319
1320 x1 = hnode.Leaf('T' if self.quoted else 'F', color_e.OtherConst)
1321 L.append(Field('quoted', x1))
1322
1323 x2 = hnode.Leaf('T' if self.do_split else 'F', color_e.OtherConst)
1324 L.append(Field('do_split', x2))
1325
1326 return out_node
1327
1328class VarSubState(pybase.CompoundObj):
1329 _type_tag = 67
1330 __slots__ = ('join_array', 'h_value', 'array_ref')
1331
1332 def __init__(self, join_array, h_value, array_ref):
1333 # type: (bool, value_t, Token) -> None
1334 self.join_array = join_array
1335 self.h_value = h_value
1336 self.array_ref = array_ref
1337
1338 @staticmethod
1339 def CreateNull(alloc_lists=False):
1340 # type: () -> VarSubState
1341 return VarSubState(False, cast('value_t', None), cast('Token', None))
1342
1343 def PrettyTree(self, do_abbrev, trav=None):
1344 # type: (bool, Optional[TraversalState]) -> hnode_t
1345 trav = trav or TraversalState()
1346 heap_id = id(self)
1347 if heap_id in trav.seen:
1348 return hnode.AlreadySeen(heap_id)
1349 trav.seen[heap_id] = True
1350
1351 out_node = NewRecord('VarSubState')
1352 L = out_node.fields
1353
1354 x0 = hnode.Leaf('T' if self.join_array else 'F', color_e.OtherConst)
1355 L.append(Field('join_array', x0))
1356
1357 assert self.h_value is not None
1358 x1 = self.h_value.PrettyTree(do_abbrev, trav=trav)
1359 L.append(Field('h_value', x1))
1360
1361 assert self.array_ref is not None
1362 x2 = self.array_ref.PrettyTree(do_abbrev, trav=trav)
1363 L.append(Field('array_ref', x2))
1364
1365 return out_node
1366
1367class Cell(pybase.CompoundObj):
1368 _type_tag = 68
1369 __slots__ = ('exported', 'readonly', 'nameref', 'val')
1370
1371 def __init__(self, exported, readonly, nameref, val):
1372 # type: (bool, bool, bool, value_t) -> None
1373 self.exported = exported
1374 self.readonly = readonly
1375 self.nameref = nameref
1376 self.val = val
1377
1378 @staticmethod
1379 def CreateNull(alloc_lists=False):
1380 # type: () -> Cell
1381 return Cell(False, False, False, cast('value_t', None))
1382
1383 def PrettyTree(self, do_abbrev, trav=None):
1384 # type: (bool, Optional[TraversalState]) -> hnode_t
1385 trav = trav or TraversalState()
1386 heap_id = id(self)
1387 if heap_id in trav.seen:
1388 return hnode.AlreadySeen(heap_id)
1389 trav.seen[heap_id] = True
1390
1391 out_node = NewRecord('Cell')
1392 L = out_node.fields
1393
1394 x0 = hnode.Leaf('T' if self.exported else 'F', color_e.OtherConst)
1395 L.append(Field('exported', x0))
1396
1397 x1 = hnode.Leaf('T' if self.readonly else 'F', color_e.OtherConst)
1398 L.append(Field('readonly', x1))
1399
1400 x2 = hnode.Leaf('T' if self.nameref else 'F', color_e.OtherConst)
1401 L.append(Field('nameref', x2))
1402
1403 assert self.val is not None
1404 x3 = self.val.PrettyTree(do_abbrev, trav=trav)
1405 L.append(Field('val', x3))
1406
1407 return out_node
1408
1409class VTestPlace(pybase.CompoundObj):
1410 _type_tag = 69
1411 __slots__ = ('name', 'index')
1412
1413 def __init__(self, name, index):
1414 # type: (Optional[str], Optional[a_index_t]) -> None
1415 self.name = name
1416 self.index = index
1417
1418 @staticmethod
1419 def CreateNull(alloc_lists=False):
1420 # type: () -> VTestPlace
1421 return VTestPlace(cast('Optional[str]', None), cast('Optional[a_index_t]', None))
1422
1423 def PrettyTree(self, do_abbrev, trav=None):
1424 # type: (bool, Optional[TraversalState]) -> hnode_t
1425 trav = trav or TraversalState()
1426 heap_id = id(self)
1427 if heap_id in trav.seen:
1428 return hnode.AlreadySeen(heap_id)
1429 trav.seen[heap_id] = True
1430
1431 out_node = NewRecord('VTestPlace')
1432 L = out_node.fields
1433
1434 if self.name is not None: # Optional
1435 x0 = NewLeaf(self.name, color_e.StringConst)
1436 L.append(Field('name', x0))
1437
1438 if self.index is not None: # Optional
1439 x1 = self.index.PrettyTree(do_abbrev, trav=trav)
1440 L.append(Field('index', x1))
1441
1442 return out_node
1443
1444class RedirValue(pybase.CompoundObj):
1445 _type_tag = 70
1446 __slots__ = ('op_id', 'op_loc', 'loc', 'arg')
1447
1448 def __init__(self, op_id, op_loc, loc, arg):
1449 # type: (Id_t, loc_t, redir_loc_t, redirect_arg_t) -> None
1450 self.op_id = op_id
1451 self.op_loc = op_loc
1452 self.loc = loc
1453 self.arg = arg
1454
1455 @staticmethod
1456 def CreateNull(alloc_lists=False):
1457 # type: () -> RedirValue
1458 return RedirValue(-1, cast('loc_t', None), cast('redir_loc_t', None), cast('redirect_arg_t', None))
1459
1460 def PrettyTree(self, do_abbrev, trav=None):
1461 # type: (bool, Optional[TraversalState]) -> hnode_t
1462 trav = trav or TraversalState()
1463 heap_id = id(self)
1464 if heap_id in trav.seen:
1465 return hnode.AlreadySeen(heap_id)
1466 trav.seen[heap_id] = True
1467
1468 out_node = NewRecord('RedirValue')
1469 L = out_node.fields
1470
1471 x0 = hnode.Leaf(Id_str(self.op_id, dot=False), color_e.UserType)
1472 L.append(Field('op_id', x0))
1473
1474 assert self.op_loc is not None
1475 x1 = self.op_loc.PrettyTree(do_abbrev, trav=trav)
1476 L.append(Field('op_loc', x1))
1477
1478 assert self.loc is not None
1479 x2 = self.loc.PrettyTree(do_abbrev, trav=trav)
1480 L.append(Field('loc', x2))
1481
1482 assert self.arg is not None
1483 x3 = self.arg.PrettyTree(do_abbrev, trav=trav)
1484 L.append(Field('arg', x3))
1485
1486 return out_node
1487
1488class StatusArray(pybase.CompoundObj):
1489 _type_tag = 71
1490 __slots__ = ('codes', 'locs')
1491
1492 def __init__(self, codes, locs):
1493 # type: (Optional[List[int]], Optional[List[loc_t]]) -> None
1494 self.codes = codes
1495 self.locs = locs
1496
1497 @staticmethod
1498 def CreateNull(alloc_lists=False):
1499 # type: () -> StatusArray
1500 return StatusArray(cast('Optional[List[int]]', None), cast('Optional[List[loc_t]]', None))
1501
1502 def PrettyTree(self, do_abbrev, trav=None):
1503 # type: (bool, Optional[TraversalState]) -> hnode_t
1504 trav = trav or TraversalState()
1505 heap_id = id(self)
1506 if heap_id in trav.seen:
1507 return hnode.AlreadySeen(heap_id)
1508 trav.seen[heap_id] = True
1509
1510 out_node = NewRecord('StatusArray')
1511 L = out_node.fields
1512
1513 if self.codes is not None: # List
1514 x0 = hnode.Array([])
1515 for i0 in self.codes:
1516 x0.children.append(hnode.Leaf(str(i0), color_e.OtherConst))
1517 L.append(Field('codes', x0))
1518
1519 if self.locs is not None: # List
1520 x1 = hnode.Array([])
1521 for i1 in self.locs:
1522 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1523 i1.PrettyTree(do_abbrev, trav=trav))
1524 x1.children.append(h)
1525 L.append(Field('locs', x1))
1526
1527 return out_node
1528
1529class CommandStatus(pybase.CompoundObj):
1530 _type_tag = 72
1531 __slots__ = ('check_errexit', 'show_code', 'pipe_negated', 'pipe_status',
1532 'pipe_locs')
1533
1534 def __init__(self, check_errexit, show_code, pipe_negated, pipe_status,
1535 pipe_locs):
1536 # type: (bool, bool, bool, Optional[List[int]], Optional[List[loc_t]]) -> None
1537 self.check_errexit = check_errexit
1538 self.show_code = show_code
1539 self.pipe_negated = pipe_negated
1540 self.pipe_status = pipe_status
1541 self.pipe_locs = pipe_locs
1542
1543 @staticmethod
1544 def CreateNull(alloc_lists=False):
1545 # type: () -> CommandStatus
1546 return CommandStatus(False, False, False, cast('Optional[List[int]]', None), cast('Optional[List[loc_t]]', None))
1547
1548 def PrettyTree(self, do_abbrev, trav=None):
1549 # type: (bool, Optional[TraversalState]) -> hnode_t
1550 trav = trav or TraversalState()
1551 heap_id = id(self)
1552 if heap_id in trav.seen:
1553 return hnode.AlreadySeen(heap_id)
1554 trav.seen[heap_id] = True
1555
1556 out_node = NewRecord('CommandStatus')
1557 L = out_node.fields
1558
1559 x0 = hnode.Leaf('T' if self.check_errexit else 'F', color_e.OtherConst)
1560 L.append(Field('check_errexit', x0))
1561
1562 x1 = hnode.Leaf('T' if self.show_code else 'F', color_e.OtherConst)
1563 L.append(Field('show_code', x1))
1564
1565 x2 = hnode.Leaf('T' if self.pipe_negated else 'F', color_e.OtherConst)
1566 L.append(Field('pipe_negated', x2))
1567
1568 if self.pipe_status is not None: # List
1569 x3 = hnode.Array([])
1570 for i3 in self.pipe_status:
1571 x3.children.append(hnode.Leaf(str(i3), color_e.OtherConst))
1572 L.append(Field('pipe_status', x3))
1573
1574 if self.pipe_locs is not None: # List
1575 x4 = hnode.Array([])
1576 for i4 in self.pipe_locs:
1577 h = (hnode.Leaf("_", color_e.OtherConst) if i4 is None else
1578 i4.PrettyTree(do_abbrev, trav=trav))
1579 x4.children.append(h)
1580 L.append(Field('pipe_locs', x4))
1581
1582 return out_node
1583
1584class HayNode(pybase.CompoundObj):
1585 _type_tag = 73
1586 __slots__ = ('children',)
1587
1588 def __init__(self, children):
1589 # type: (Dict[str, HayNode]) -> None
1590 self.children = children
1591
1592 @staticmethod
1593 def CreateNull(alloc_lists=False):
1594 # type: () -> HayNode
1595 return HayNode(cast('Dict[str, HayNode]', None))
1596
1597 def PrettyTree(self, do_abbrev, trav=None):
1598 # type: (bool, Optional[TraversalState]) -> hnode_t
1599 trav = trav or TraversalState()
1600 heap_id = id(self)
1601 if heap_id in trav.seen:
1602 return hnode.AlreadySeen(heap_id)
1603 trav.seen[heap_id] = True
1604
1605 out_node = NewRecord('HayNode')
1606 L = out_node.fields
1607
1608 if self.children is not None: # Dict
1609 unnamed0 = [] # type: List[hnode_t]
1610 x0 = hnode.Record("", "{", "}", [], unnamed0)
1611 for k0, v0 in self.children.iteritems():
1612 unnamed0.append(NewLeaf(k0, color_e.StringConst))
1613 unnamed0.append(v0.PrettyTree(do_abbrev, trav=trav))
1614 L.append(Field('children', x0))
1615
1616 return out_node
1617