OILS / _devbuild / gen / runtime_asdl.py View on Github | oilshell.org

2067 lines, 1514 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, LiteralBlock, Func
7 from _devbuild.gen.value_asdl import value_t
8
9from _devbuild.gen.id_kind_asdl import Id_t
10from _devbuild.gen.id_kind_asdl import Id_str
11
12
13from asdl import runtime # For runtime.NO_SPID
14from asdl.runtime import NewRecord, NewLeaf, TraversalState
15from _devbuild.gen.hnode_asdl import color_e, hnode, hnode_e, hnode_t, Field
16
17class cmd_value_e(object):
18 Argv = 1
19 Assign = 2
20
21_cmd_value_str = {
22 1: 'Argv',
23 2: 'Assign',
24}
25
26def cmd_value_str(tag, dot=True):
27 # type: (int, bool) -> str
28 v = _cmd_value_str[tag]
29 if dot:
30 return "cmd_value.%s" % v
31 else:
32 return v
33
34class cmd_value_t(pybase.CompoundObj):
35 def tag(self):
36 # type: () -> int
37 return self._type_tag
38 pass
39
40class cmd_value(object):
41 class Argv(cmd_value_t):
42 _type_tag = 1
43 __slots__ = ('argv', 'arg_locs', 'typed_args', 'pos_args', 'named_args')
44
45 def __init__(self, argv, arg_locs, typed_args, pos_args, named_args):
46 # type: (List[str], List[CompoundWord], Optional[ArgList], Optional[List[value_t]], Optional[Dict[str, value_t]]) -> None
47 self.argv = argv
48 self.arg_locs = arg_locs
49 self.typed_args = typed_args
50 self.pos_args = pos_args
51 self.named_args = named_args
52
53 @staticmethod
54 def CreateNull(alloc_lists=False):
55 # type: () -> cmd_value.Argv
56 return cmd_value.Argv([] if alloc_lists else cast('List[str]', None), [] if alloc_lists else cast('List[CompoundWord]', None), cast('Optional[ArgList]', None), cast('Optional[List[value_t]]', None), cast('Optional[Dict[str, value_t]]', None))
57
58 def PrettyTree(self, trav=None):
59 # type: (Optional[TraversalState]) -> hnode_t
60 trav = trav or TraversalState()
61 heap_id = id(self)
62 if heap_id in trav.seen:
63 return hnode.AlreadySeen(heap_id)
64 trav.seen[heap_id] = True
65 out_node = NewRecord('cmd_value.Argv')
66 L = out_node.fields
67
68 if self.argv is not None: # List
69 x0 = hnode.Array([])
70 for i0 in self.argv:
71 x0.children.append(NewLeaf(i0, color_e.StringConst))
72 L.append(Field('argv', x0))
73
74 if self.arg_locs is not None: # List
75 x1 = hnode.Array([])
76 for i1 in self.arg_locs:
77 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
78 i1.PrettyTree(trav=trav))
79 x1.children.append(h)
80 L.append(Field('arg_locs', x1))
81
82 if self.typed_args is not None: # Optional
83 x2 = self.typed_args.PrettyTree(trav=trav)
84 L.append(Field('typed_args', x2))
85
86 if self.pos_args is not None: # List
87 x3 = hnode.Array([])
88 for i3 in self.pos_args:
89 h = (hnode.Leaf("_", color_e.OtherConst) if i3 is None else
90 i3.PrettyTree(trav=trav))
91 x3.children.append(h)
92 L.append(Field('pos_args', x3))
93
94 if self.named_args is not None: # Dict
95 m = hnode.Leaf("Dict", color_e.OtherConst)
96 x4 = hnode.Array([m])
97 for k4, v4 in self.named_args.iteritems():
98 x4.children.append(NewLeaf(k4, color_e.StringConst))
99 x4.children.append(v4.PrettyTree(trav=trav))
100 L.append(Field('named_args', x4))
101
102 return out_node
103
104 def _AbbreviatedTree(self, trav=None):
105 # type: (Optional[TraversalState]) -> hnode_t
106 trav = trav or TraversalState()
107 heap_id = id(self)
108 if heap_id in trav.seen:
109 return hnode.AlreadySeen(heap_id)
110 trav.seen[heap_id] = True
111 out_node = NewRecord('cmd_value.Argv')
112 L = out_node.fields
113 if self.argv is not None: # List
114 x0 = hnode.Array([])
115 for i0 in self.argv:
116 x0.children.append(NewLeaf(i0, color_e.StringConst))
117 L.append(Field('argv', x0))
118
119 if self.arg_locs is not None: # List
120 x1 = hnode.Array([])
121 for i1 in self.arg_locs:
122 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
123 i1.AbbreviatedTree(trav=trav))
124 x1.children.append(h)
125 L.append(Field('arg_locs', x1))
126
127 if self.typed_args is not None: # Optional
128 x2 = self.typed_args.AbbreviatedTree(trav=trav)
129 L.append(Field('typed_args', x2))
130
131 if self.pos_args is not None: # List
132 x3 = hnode.Array([])
133 for i3 in self.pos_args:
134 h = (hnode.Leaf("_", color_e.OtherConst) if i3 is None else
135 i3.AbbreviatedTree(trav=trav))
136 x3.children.append(h)
137 L.append(Field('pos_args', x3))
138
139 if self.named_args is not None: # Dict
140 m = hnode.Leaf("Dict", color_e.OtherConst)
141 x4 = hnode.Array([m])
142 for k4, v4 in self.named_args.iteritems():
143 x4.children.append(NewLeaf(k4, color_e.StringConst))
144 x4.children.append(v4.AbbreviatedTree(trav=trav))
145 L.append(Field('named_args', x4))
146
147 return out_node
148
149 def AbbreviatedTree(self, trav=None):
150 # type: (Optional[TraversalState]) -> hnode_t
151 return self._AbbreviatedTree(trav=trav)
152
153 class Assign(cmd_value_t):
154 _type_tag = 2
155 __slots__ = ('builtin_id', 'argv', 'arg_locs', 'pairs')
156
157 def __init__(self, builtin_id, argv, arg_locs, pairs):
158 # type: (int, List[str], List[CompoundWord], List[AssignArg]) -> None
159 self.builtin_id = builtin_id
160 self.argv = argv
161 self.arg_locs = arg_locs
162 self.pairs = pairs
163
164 @staticmethod
165 def CreateNull(alloc_lists=False):
166 # type: () -> cmd_value.Assign
167 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))
168
169 def PrettyTree(self, trav=None):
170 # type: (Optional[TraversalState]) -> hnode_t
171 trav = trav or TraversalState()
172 heap_id = id(self)
173 if heap_id in trav.seen:
174 return hnode.AlreadySeen(heap_id)
175 trav.seen[heap_id] = True
176 out_node = NewRecord('cmd_value.Assign')
177 L = out_node.fields
178
179 x0 = hnode.Leaf(str(self.builtin_id), color_e.OtherConst)
180 L.append(Field('builtin_id', x0))
181
182 if self.argv is not None: # List
183 x1 = hnode.Array([])
184 for i1 in self.argv:
185 x1.children.append(NewLeaf(i1, color_e.StringConst))
186 L.append(Field('argv', x1))
187
188 if self.arg_locs is not None: # List
189 x2 = hnode.Array([])
190 for i2 in self.arg_locs:
191 h = (hnode.Leaf("_", color_e.OtherConst) if i2 is None else
192 i2.PrettyTree(trav=trav))
193 x2.children.append(h)
194 L.append(Field('arg_locs', x2))
195
196 if self.pairs is not None: # List
197 x3 = hnode.Array([])
198 for i3 in self.pairs:
199 h = (hnode.Leaf("_", color_e.OtherConst) if i3 is None else
200 i3.PrettyTree(trav=trav))
201 x3.children.append(h)
202 L.append(Field('pairs', x3))
203
204 return out_node
205
206 def _AbbreviatedTree(self, trav=None):
207 # type: (Optional[TraversalState]) -> hnode_t
208 trav = trav or TraversalState()
209 heap_id = id(self)
210 if heap_id in trav.seen:
211 return hnode.AlreadySeen(heap_id)
212 trav.seen[heap_id] = True
213 out_node = NewRecord('cmd_value.Assign')
214 L = out_node.fields
215 x0 = hnode.Leaf(str(self.builtin_id), color_e.OtherConst)
216 L.append(Field('builtin_id', x0))
217
218 if self.argv is not None: # List
219 x1 = hnode.Array([])
220 for i1 in self.argv:
221 x1.children.append(NewLeaf(i1, color_e.StringConst))
222 L.append(Field('argv', x1))
223
224 if self.arg_locs is not None: # List
225 x2 = hnode.Array([])
226 for i2 in self.arg_locs:
227 h = (hnode.Leaf("_", color_e.OtherConst) if i2 is None else
228 i2.AbbreviatedTree(trav=trav))
229 x2.children.append(h)
230 L.append(Field('arg_locs', x2))
231
232 if self.pairs is not None: # List
233 x3 = hnode.Array([])
234 for i3 in self.pairs:
235 h = (hnode.Leaf("_", color_e.OtherConst) if i3 is None else
236 i3.AbbreviatedTree(trav=trav))
237 x3.children.append(h)
238 L.append(Field('pairs', x3))
239
240 return out_node
241
242 def AbbreviatedTree(self, trav=None):
243 # type: (Optional[TraversalState]) -> hnode_t
244 return self._AbbreviatedTree(trav=trav)
245
246 pass
247
248class part_value_e(object):
249 String = 65
250 Array = 2
251 ExtGlob = 3
252
253_part_value_str = {
254 2: 'Array',
255 3: 'ExtGlob',
256 65: 'String',
257}
258
259def part_value_str(tag, dot=True):
260 # type: (int, bool) -> str
261 v = _part_value_str[tag]
262 if dot:
263 return "part_value.%s" % v
264 else:
265 return v
266
267class part_value_t(pybase.CompoundObj):
268 def tag(self):
269 # type: () -> int
270 return self._type_tag
271 pass
272
273class part_value(object):
274 class Array(part_value_t):
275 _type_tag = 2
276 __slots__ = ('strs',)
277
278 def __init__(self, strs):
279 # type: (List[str]) -> None
280 self.strs = strs
281
282 @staticmethod
283 def CreateNull(alloc_lists=False):
284 # type: () -> part_value.Array
285 return part_value.Array([] if alloc_lists else cast('List[str]', None))
286
287 def PrettyTree(self, trav=None):
288 # type: (Optional[TraversalState]) -> hnode_t
289 trav = trav or TraversalState()
290 heap_id = id(self)
291 if heap_id in trav.seen:
292 return hnode.AlreadySeen(heap_id)
293 trav.seen[heap_id] = True
294 out_node = NewRecord('part_value.Array')
295 L = out_node.fields
296
297 if self.strs is not None: # List
298 x0 = hnode.Array([])
299 for i0 in self.strs:
300 x0.children.append(NewLeaf(i0, color_e.StringConst))
301 L.append(Field('strs', x0))
302
303 return out_node
304
305 def _AbbreviatedTree(self, trav=None):
306 # type: (Optional[TraversalState]) -> hnode_t
307 trav = trav or TraversalState()
308 heap_id = id(self)
309 if heap_id in trav.seen:
310 return hnode.AlreadySeen(heap_id)
311 trav.seen[heap_id] = True
312 out_node = NewRecord('part_value.Array')
313 L = out_node.fields
314 if self.strs is not None: # List
315 x0 = hnode.Array([])
316 for i0 in self.strs:
317 x0.children.append(NewLeaf(i0, color_e.StringConst))
318 L.append(Field('strs', x0))
319
320 return out_node
321
322 def AbbreviatedTree(self, trav=None):
323 # type: (Optional[TraversalState]) -> hnode_t
324 return self._AbbreviatedTree(trav=trav)
325
326 class ExtGlob(part_value_t):
327 _type_tag = 3
328 __slots__ = ('part_vals',)
329
330 def __init__(self, part_vals):
331 # type: (List[part_value_t]) -> None
332 self.part_vals = part_vals
333
334 @staticmethod
335 def CreateNull(alloc_lists=False):
336 # type: () -> part_value.ExtGlob
337 return part_value.ExtGlob([] if alloc_lists else cast('List[part_value_t]', None))
338
339 def PrettyTree(self, trav=None):
340 # type: (Optional[TraversalState]) -> hnode_t
341 trav = trav or TraversalState()
342 heap_id = id(self)
343 if heap_id in trav.seen:
344 return hnode.AlreadySeen(heap_id)
345 trav.seen[heap_id] = True
346 out_node = NewRecord('part_value.ExtGlob')
347 L = out_node.fields
348
349 if self.part_vals is not None: # List
350 x0 = hnode.Array([])
351 for i0 in self.part_vals:
352 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
353 i0.PrettyTree(trav=trav))
354 x0.children.append(h)
355 L.append(Field('part_vals', x0))
356
357 return out_node
358
359 def _AbbreviatedTree(self, trav=None):
360 # type: (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 out_node = NewRecord('part_value.ExtGlob')
367 L = out_node.fields
368 if self.part_vals is not None: # List
369 x0 = hnode.Array([])
370 for i0 in self.part_vals:
371 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
372 i0.AbbreviatedTree(trav=trav))
373 x0.children.append(h)
374 L.append(Field('part_vals', x0))
375
376 return out_node
377
378 def AbbreviatedTree(self, trav=None):
379 # type: (Optional[TraversalState]) -> hnode_t
380 return self._AbbreviatedTree(trav=trav)
381
382 pass
383
384class coerced_t(pybase.SimpleObj):
385 pass
386
387class coerced_e(object):
388 Int = coerced_t(1)
389 Float = coerced_t(2)
390 Neither = coerced_t(3)
391
392_coerced_str = {
393 1: 'coerced.Int',
394 2: 'coerced.Float',
395 3: 'coerced.Neither',
396}
397
398def coerced_str(val):
399 # type: (coerced_t) -> str
400 return _coerced_str[val]
401
402class scope_t(pybase.SimpleObj):
403 pass
404
405class scope_e(object):
406 Shopt = scope_t(1)
407 Dynamic = scope_t(2)
408 LocalOrGlobal = scope_t(3)
409 LocalOnly = scope_t(4)
410 GlobalOnly = scope_t(5)
411
412_scope_str = {
413 1: 'scope.Shopt',
414 2: 'scope.Dynamic',
415 3: 'scope.LocalOrGlobal',
416 4: 'scope.LocalOnly',
417 5: 'scope.GlobalOnly',
418}
419
420def scope_str(val):
421 # type: (scope_t) -> str
422 return _scope_str[val]
423
424class a_index_e(object):
425 Str = 1
426 Int = 2
427
428_a_index_str = {
429 1: 'Str',
430 2: 'Int',
431}
432
433def a_index_str(tag, dot=True):
434 # type: (int, bool) -> str
435 v = _a_index_str[tag]
436 if dot:
437 return "a_index.%s" % v
438 else:
439 return v
440
441class a_index_t(pybase.CompoundObj):
442 def tag(self):
443 # type: () -> int
444 return self._type_tag
445 pass
446
447class a_index(object):
448 class Str(a_index_t):
449 _type_tag = 1
450 __slots__ = ('s',)
451
452 def __init__(self, s):
453 # type: (str) -> None
454 self.s = s
455
456 @staticmethod
457 def CreateNull(alloc_lists=False):
458 # type: () -> a_index.Str
459 return a_index.Str('')
460
461 def PrettyTree(self, trav=None):
462 # type: (Optional[TraversalState]) -> hnode_t
463 trav = trav or TraversalState()
464 heap_id = id(self)
465 if heap_id in trav.seen:
466 return hnode.AlreadySeen(heap_id)
467 trav.seen[heap_id] = True
468 out_node = NewRecord('a_index.Str')
469 L = out_node.fields
470
471 x0 = NewLeaf(self.s, color_e.StringConst)
472 L.append(Field('s', x0))
473
474 return out_node
475
476 def _AbbreviatedTree(self, trav=None):
477 # type: (Optional[TraversalState]) -> hnode_t
478 trav = trav or TraversalState()
479 heap_id = id(self)
480 if heap_id in trav.seen:
481 return hnode.AlreadySeen(heap_id)
482 trav.seen[heap_id] = True
483 out_node = NewRecord('a_index.Str')
484 L = out_node.fields
485 x0 = NewLeaf(self.s, color_e.StringConst)
486 L.append(Field('s', x0))
487
488 return out_node
489
490 def AbbreviatedTree(self, trav=None):
491 # type: (Optional[TraversalState]) -> hnode_t
492 return self._AbbreviatedTree(trav=trav)
493
494 class Int(a_index_t):
495 _type_tag = 2
496 __slots__ = ('i',)
497
498 def __init__(self, i):
499 # type: (int) -> None
500 self.i = i
501
502 @staticmethod
503 def CreateNull(alloc_lists=False):
504 # type: () -> a_index.Int
505 return a_index.Int(-1)
506
507 def PrettyTree(self, trav=None):
508 # type: (Optional[TraversalState]) -> hnode_t
509 trav = trav or TraversalState()
510 heap_id = id(self)
511 if heap_id in trav.seen:
512 return hnode.AlreadySeen(heap_id)
513 trav.seen[heap_id] = True
514 out_node = NewRecord('a_index.Int')
515 L = out_node.fields
516
517 x0 = hnode.Leaf(str(self.i), color_e.OtherConst)
518 L.append(Field('i', x0))
519
520 return out_node
521
522 def _AbbreviatedTree(self, trav=None):
523 # type: (Optional[TraversalState]) -> hnode_t
524 trav = trav or TraversalState()
525 heap_id = id(self)
526 if heap_id in trav.seen:
527 return hnode.AlreadySeen(heap_id)
528 trav.seen[heap_id] = True
529 out_node = NewRecord('a_index.Int')
530 L = out_node.fields
531 x0 = hnode.Leaf(str(self.i), color_e.OtherConst)
532 L.append(Field('i', x0))
533
534 return out_node
535
536 def AbbreviatedTree(self, trav=None):
537 # type: (Optional[TraversalState]) -> hnode_t
538 return self._AbbreviatedTree(trav=trav)
539
540 pass
541
542class redirect_arg_e(object):
543 Path = 1
544 CopyFd = 2
545 MoveFd = 3
546 CloseFd = 4
547 HereDoc = 5
548
549_redirect_arg_str = {
550 1: 'Path',
551 2: 'CopyFd',
552 3: 'MoveFd',
553 4: 'CloseFd',
554 5: 'HereDoc',
555}
556
557def redirect_arg_str(tag, dot=True):
558 # type: (int, bool) -> str
559 v = _redirect_arg_str[tag]
560 if dot:
561 return "redirect_arg.%s" % v
562 else:
563 return v
564
565class redirect_arg_t(pybase.CompoundObj):
566 def tag(self):
567 # type: () -> int
568 return self._type_tag
569 pass
570
571class redirect_arg__CloseFd(redirect_arg_t):
572 _type_tag = 4
573 __slots__ = ()
574
575 def __init__(self, ):
576 # type: () -> None
577 pass
578
579 def PrettyTree(self, trav=None):
580 # type: (Optional[TraversalState]) -> hnode_t
581 trav = trav or TraversalState()
582 heap_id = id(self)
583 if heap_id in trav.seen:
584 return hnode.AlreadySeen(heap_id)
585 trav.seen[heap_id] = True
586 out_node = NewRecord('redirect_arg__CloseFd')
587 L = out_node.fields
588
589 return out_node
590
591 def _AbbreviatedTree(self, trav=None):
592 # type: (Optional[TraversalState]) -> hnode_t
593 trav = trav or TraversalState()
594 heap_id = id(self)
595 if heap_id in trav.seen:
596 return hnode.AlreadySeen(heap_id)
597 trav.seen[heap_id] = True
598 out_node = NewRecord('redirect_arg__CloseFd')
599 L = out_node.fields
600 return out_node
601
602 def AbbreviatedTree(self, trav=None):
603 # type: (Optional[TraversalState]) -> hnode_t
604 return self._AbbreviatedTree(trav=trav)
605
606class redirect_arg(object):
607 class Path(redirect_arg_t):
608 _type_tag = 1
609 __slots__ = ('filename',)
610
611 def __init__(self, filename):
612 # type: (str) -> None
613 self.filename = filename
614
615 @staticmethod
616 def CreateNull(alloc_lists=False):
617 # type: () -> redirect_arg.Path
618 return redirect_arg.Path('')
619
620 def PrettyTree(self, trav=None):
621 # type: (Optional[TraversalState]) -> hnode_t
622 trav = trav or TraversalState()
623 heap_id = id(self)
624 if heap_id in trav.seen:
625 return hnode.AlreadySeen(heap_id)
626 trav.seen[heap_id] = True
627 out_node = NewRecord('redirect_arg.Path')
628 L = out_node.fields
629
630 x0 = NewLeaf(self.filename, color_e.StringConst)
631 L.append(Field('filename', x0))
632
633 return out_node
634
635 def _AbbreviatedTree(self, trav=None):
636 # type: (Optional[TraversalState]) -> hnode_t
637 trav = trav or TraversalState()
638 heap_id = id(self)
639 if heap_id in trav.seen:
640 return hnode.AlreadySeen(heap_id)
641 trav.seen[heap_id] = True
642 out_node = NewRecord('redirect_arg.Path')
643 L = out_node.fields
644 x0 = NewLeaf(self.filename, color_e.StringConst)
645 L.append(Field('filename', x0))
646
647 return out_node
648
649 def AbbreviatedTree(self, trav=None):
650 # type: (Optional[TraversalState]) -> hnode_t
651 return self._AbbreviatedTree(trav=trav)
652
653 class CopyFd(redirect_arg_t):
654 _type_tag = 2
655 __slots__ = ('target_fd',)
656
657 def __init__(self, target_fd):
658 # type: (int) -> None
659 self.target_fd = target_fd
660
661 @staticmethod
662 def CreateNull(alloc_lists=False):
663 # type: () -> redirect_arg.CopyFd
664 return redirect_arg.CopyFd(-1)
665
666 def PrettyTree(self, trav=None):
667 # type: (Optional[TraversalState]) -> hnode_t
668 trav = trav or TraversalState()
669 heap_id = id(self)
670 if heap_id in trav.seen:
671 return hnode.AlreadySeen(heap_id)
672 trav.seen[heap_id] = True
673 out_node = NewRecord('redirect_arg.CopyFd')
674 L = out_node.fields
675
676 x0 = hnode.Leaf(str(self.target_fd), color_e.OtherConst)
677 L.append(Field('target_fd', x0))
678
679 return out_node
680
681 def _AbbreviatedTree(self, trav=None):
682 # type: (Optional[TraversalState]) -> hnode_t
683 trav = trav or TraversalState()
684 heap_id = id(self)
685 if heap_id in trav.seen:
686 return hnode.AlreadySeen(heap_id)
687 trav.seen[heap_id] = True
688 out_node = NewRecord('redirect_arg.CopyFd')
689 L = out_node.fields
690 x0 = hnode.Leaf(str(self.target_fd), color_e.OtherConst)
691 L.append(Field('target_fd', x0))
692
693 return out_node
694
695 def AbbreviatedTree(self, trav=None):
696 # type: (Optional[TraversalState]) -> hnode_t
697 return self._AbbreviatedTree(trav=trav)
698
699 class MoveFd(redirect_arg_t):
700 _type_tag = 3
701 __slots__ = ('target_fd',)
702
703 def __init__(self, target_fd):
704 # type: (int) -> None
705 self.target_fd = target_fd
706
707 @staticmethod
708 def CreateNull(alloc_lists=False):
709 # type: () -> redirect_arg.MoveFd
710 return redirect_arg.MoveFd(-1)
711
712 def PrettyTree(self, trav=None):
713 # type: (Optional[TraversalState]) -> hnode_t
714 trav = trav or TraversalState()
715 heap_id = id(self)
716 if heap_id in trav.seen:
717 return hnode.AlreadySeen(heap_id)
718 trav.seen[heap_id] = True
719 out_node = NewRecord('redirect_arg.MoveFd')
720 L = out_node.fields
721
722 x0 = hnode.Leaf(str(self.target_fd), color_e.OtherConst)
723 L.append(Field('target_fd', x0))
724
725 return out_node
726
727 def _AbbreviatedTree(self, trav=None):
728 # type: (Optional[TraversalState]) -> hnode_t
729 trav = trav or TraversalState()
730 heap_id = id(self)
731 if heap_id in trav.seen:
732 return hnode.AlreadySeen(heap_id)
733 trav.seen[heap_id] = True
734 out_node = NewRecord('redirect_arg.MoveFd')
735 L = out_node.fields
736 x0 = hnode.Leaf(str(self.target_fd), color_e.OtherConst)
737 L.append(Field('target_fd', x0))
738
739 return out_node
740
741 def AbbreviatedTree(self, trav=None):
742 # type: (Optional[TraversalState]) -> hnode_t
743 return self._AbbreviatedTree(trav=trav)
744
745 CloseFd = redirect_arg__CloseFd()
746
747 class HereDoc(redirect_arg_t):
748 _type_tag = 5
749 __slots__ = ('body',)
750
751 def __init__(self, body):
752 # type: (str) -> None
753 self.body = body
754
755 @staticmethod
756 def CreateNull(alloc_lists=False):
757 # type: () -> redirect_arg.HereDoc
758 return redirect_arg.HereDoc('')
759
760 def PrettyTree(self, trav=None):
761 # type: (Optional[TraversalState]) -> hnode_t
762 trav = trav or TraversalState()
763 heap_id = id(self)
764 if heap_id in trav.seen:
765 return hnode.AlreadySeen(heap_id)
766 trav.seen[heap_id] = True
767 out_node = NewRecord('redirect_arg.HereDoc')
768 L = out_node.fields
769
770 x0 = NewLeaf(self.body, color_e.StringConst)
771 L.append(Field('body', x0))
772
773 return out_node
774
775 def _AbbreviatedTree(self, trav=None):
776 # type: (Optional[TraversalState]) -> hnode_t
777 trav = trav or TraversalState()
778 heap_id = id(self)
779 if heap_id in trav.seen:
780 return hnode.AlreadySeen(heap_id)
781 trav.seen[heap_id] = True
782 out_node = NewRecord('redirect_arg.HereDoc')
783 L = out_node.fields
784 x0 = NewLeaf(self.body, color_e.StringConst)
785 L.append(Field('body', x0))
786
787 return out_node
788
789 def AbbreviatedTree(self, trav=None):
790 # type: (Optional[TraversalState]) -> hnode_t
791 return self._AbbreviatedTree(trav=trav)
792
793 pass
794
795class wait_status_e(object):
796 Proc = 1
797 Pipeline = 2
798 Cancelled = 3
799
800_wait_status_str = {
801 1: 'Proc',
802 2: 'Pipeline',
803 3: 'Cancelled',
804}
805
806def wait_status_str(tag, dot=True):
807 # type: (int, bool) -> str
808 v = _wait_status_str[tag]
809 if dot:
810 return "wait_status.%s" % v
811 else:
812 return v
813
814class wait_status_t(pybase.CompoundObj):
815 def tag(self):
816 # type: () -> int
817 return self._type_tag
818 pass
819
820class wait_status(object):
821 class Proc(wait_status_t):
822 _type_tag = 1
823 __slots__ = ('code',)
824
825 def __init__(self, code):
826 # type: (int) -> None
827 self.code = code
828
829 @staticmethod
830 def CreateNull(alloc_lists=False):
831 # type: () -> wait_status.Proc
832 return wait_status.Proc(-1)
833
834 def PrettyTree(self, trav=None):
835 # type: (Optional[TraversalState]) -> hnode_t
836 trav = trav or TraversalState()
837 heap_id = id(self)
838 if heap_id in trav.seen:
839 return hnode.AlreadySeen(heap_id)
840 trav.seen[heap_id] = True
841 out_node = NewRecord('wait_status.Proc')
842 L = out_node.fields
843
844 x0 = hnode.Leaf(str(self.code), color_e.OtherConst)
845 L.append(Field('code', x0))
846
847 return out_node
848
849 def _AbbreviatedTree(self, trav=None):
850 # type: (Optional[TraversalState]) -> hnode_t
851 trav = trav or TraversalState()
852 heap_id = id(self)
853 if heap_id in trav.seen:
854 return hnode.AlreadySeen(heap_id)
855 trav.seen[heap_id] = True
856 out_node = NewRecord('wait_status.Proc')
857 L = out_node.fields
858 x0 = hnode.Leaf(str(self.code), color_e.OtherConst)
859 L.append(Field('code', x0))
860
861 return out_node
862
863 def AbbreviatedTree(self, trav=None):
864 # type: (Optional[TraversalState]) -> hnode_t
865 return self._AbbreviatedTree(trav=trav)
866
867 class Pipeline(wait_status_t):
868 _type_tag = 2
869 __slots__ = ('codes',)
870
871 def __init__(self, codes):
872 # type: (List[int]) -> None
873 self.codes = codes
874
875 @staticmethod
876 def CreateNull(alloc_lists=False):
877 # type: () -> wait_status.Pipeline
878 return wait_status.Pipeline([] if alloc_lists else cast('List[int]', None))
879
880 def PrettyTree(self, trav=None):
881 # type: (Optional[TraversalState]) -> hnode_t
882 trav = trav or TraversalState()
883 heap_id = id(self)
884 if heap_id in trav.seen:
885 return hnode.AlreadySeen(heap_id)
886 trav.seen[heap_id] = True
887 out_node = NewRecord('wait_status.Pipeline')
888 L = out_node.fields
889
890 if self.codes is not None: # List
891 x0 = hnode.Array([])
892 for i0 in self.codes:
893 x0.children.append(hnode.Leaf(str(i0), color_e.OtherConst))
894 L.append(Field('codes', x0))
895
896 return out_node
897
898 def _AbbreviatedTree(self, trav=None):
899 # type: (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 out_node = NewRecord('wait_status.Pipeline')
906 L = out_node.fields
907 if self.codes is not None: # List
908 x0 = hnode.Array([])
909 for i0 in self.codes:
910 x0.children.append(hnode.Leaf(str(i0), color_e.OtherConst))
911 L.append(Field('codes', x0))
912
913 return out_node
914
915 def AbbreviatedTree(self, trav=None):
916 # type: (Optional[TraversalState]) -> hnode_t
917 return self._AbbreviatedTree(trav=trav)
918
919 class Cancelled(wait_status_t):
920 _type_tag = 3
921 __slots__ = ('sig_num',)
922
923 def __init__(self, sig_num):
924 # type: (int) -> None
925 self.sig_num = sig_num
926
927 @staticmethod
928 def CreateNull(alloc_lists=False):
929 # type: () -> wait_status.Cancelled
930 return wait_status.Cancelled(-1)
931
932 def PrettyTree(self, trav=None):
933 # type: (Optional[TraversalState]) -> hnode_t
934 trav = trav or TraversalState()
935 heap_id = id(self)
936 if heap_id in trav.seen:
937 return hnode.AlreadySeen(heap_id)
938 trav.seen[heap_id] = True
939 out_node = NewRecord('wait_status.Cancelled')
940 L = out_node.fields
941
942 x0 = hnode.Leaf(str(self.sig_num), color_e.OtherConst)
943 L.append(Field('sig_num', x0))
944
945 return out_node
946
947 def _AbbreviatedTree(self, trav=None):
948 # type: (Optional[TraversalState]) -> hnode_t
949 trav = trav or TraversalState()
950 heap_id = id(self)
951 if heap_id in trav.seen:
952 return hnode.AlreadySeen(heap_id)
953 trav.seen[heap_id] = True
954 out_node = NewRecord('wait_status.Cancelled')
955 L = out_node.fields
956 x0 = hnode.Leaf(str(self.sig_num), color_e.OtherConst)
957 L.append(Field('sig_num', x0))
958
959 return out_node
960
961 def AbbreviatedTree(self, trav=None):
962 # type: (Optional[TraversalState]) -> hnode_t
963 return self._AbbreviatedTree(trav=trav)
964
965 pass
966
967class flow_t(pybase.SimpleObj):
968 pass
969
970class flow_e(object):
971 Nothing = flow_t(1)
972 Break = flow_t(2)
973 Raise = flow_t(3)
974
975_flow_str = {
976 1: 'flow.Nothing',
977 2: 'flow.Break',
978 3: 'flow.Raise',
979}
980
981def flow_str(val):
982 # type: (flow_t) -> str
983 return _flow_str[val]
984
985class span_t(pybase.SimpleObj):
986 pass
987
988class span_e(object):
989 Black = span_t(1)
990 Delim = span_t(2)
991 Backslash = span_t(3)
992
993_span_str = {
994 1: 'span.Black',
995 2: 'span.Delim',
996 3: 'span.Backslash',
997}
998
999def span_str(val):
1000 # type: (span_t) -> str
1001 return _span_str[val]
1002
1003emit_t = int # type alias for integer
1004
1005class emit_i(object):
1006 Part = 1
1007 Delim = 2
1008 Empty = 3
1009 Escape = 4
1010 Nothing = 5
1011 ARRAY_SIZE = 6
1012
1013_emit_str = {
1014 1: 'emit.Part',
1015 2: 'emit.Delim',
1016 3: 'emit.Empty',
1017 4: 'emit.Escape',
1018 5: 'emit.Nothing',
1019}
1020
1021def emit_str(val):
1022 # type: (emit_t) -> str
1023 return _emit_str[val]
1024
1025state_t = int # type alias for integer
1026
1027class state_i(object):
1028 Invalid = 1
1029 Start = 2
1030 DE_White1 = 3
1031 DE_Gray = 4
1032 DE_White2 = 5
1033 Black = 6
1034 Backslash = 7
1035 Done = 8
1036 ARRAY_SIZE = 9
1037
1038_state_str = {
1039 1: 'state.Invalid',
1040 2: 'state.Start',
1041 3: 'state.DE_White1',
1042 4: 'state.DE_Gray',
1043 5: 'state.DE_White2',
1044 6: 'state.Black',
1045 7: 'state.Backslash',
1046 8: 'state.Done',
1047}
1048
1049def state_str(val):
1050 # type: (state_t) -> str
1051 return _state_str[val]
1052
1053char_kind_t = int # type alias for integer
1054
1055class char_kind_i(object):
1056 DE_White = 1
1057 DE_Gray = 2
1058 Black = 3
1059 Backslash = 4
1060 Sentinel = 5
1061 ARRAY_SIZE = 6
1062
1063_char_kind_str = {
1064 1: 'char_kind.DE_White',
1065 2: 'char_kind.DE_Gray',
1066 3: 'char_kind.Black',
1067 4: 'char_kind.Backslash',
1068 5: 'char_kind.Sentinel',
1069}
1070
1071def char_kind_str(val):
1072 # type: (char_kind_t) -> str
1073 return _char_kind_str[val]
1074
1075class job_state_t(pybase.SimpleObj):
1076 pass
1077
1078class job_state_e(object):
1079 Running = job_state_t(1)
1080 Done = job_state_t(2)
1081 Stopped = job_state_t(3)
1082
1083_job_state_str = {
1084 1: 'job_state.Running',
1085 2: 'job_state.Done',
1086 3: 'job_state.Stopped',
1087}
1088
1089def job_state_str(val):
1090 # type: (job_state_t) -> str
1091 return _job_state_str[val]
1092
1093class flag_type_t(pybase.SimpleObj):
1094 pass
1095
1096class flag_type_e(object):
1097 Bool = flag_type_t(1)
1098 Int = flag_type_t(2)
1099 Float = flag_type_t(3)
1100 Str = flag_type_t(4)
1101
1102_flag_type_str = {
1103 1: 'flag_type.Bool',
1104 2: 'flag_type.Int',
1105 3: 'flag_type.Float',
1106 4: 'flag_type.Str',
1107}
1108
1109def flag_type_str(val):
1110 # type: (flag_type_t) -> str
1111 return _flag_type_str[val]
1112
1113class trace_e(object):
1114 External = 1
1115 CommandSub = 2
1116 ForkWait = 3
1117 Fork = 4
1118 PipelinePart = 5
1119 ProcessSub = 6
1120 HereDoc = 7
1121
1122_trace_str = {
1123 1: 'External',
1124 2: 'CommandSub',
1125 3: 'ForkWait',
1126 4: 'Fork',
1127 5: 'PipelinePart',
1128 6: 'ProcessSub',
1129 7: 'HereDoc',
1130}
1131
1132def trace_str(tag, dot=True):
1133 # type: (int, bool) -> str
1134 v = _trace_str[tag]
1135 if dot:
1136 return "trace.%s" % v
1137 else:
1138 return v
1139
1140class trace_t(pybase.CompoundObj):
1141 def tag(self):
1142 # type: () -> int
1143 return self._type_tag
1144 pass
1145
1146class trace__CommandSub(trace_t):
1147 _type_tag = 2
1148 __slots__ = ()
1149
1150 def __init__(self, ):
1151 # type: () -> None
1152 pass
1153
1154 def PrettyTree(self, trav=None):
1155 # type: (Optional[TraversalState]) -> hnode_t
1156 trav = trav or TraversalState()
1157 heap_id = id(self)
1158 if heap_id in trav.seen:
1159 return hnode.AlreadySeen(heap_id)
1160 trav.seen[heap_id] = True
1161 out_node = NewRecord('trace__CommandSub')
1162 L = out_node.fields
1163
1164 return out_node
1165
1166 def _AbbreviatedTree(self, trav=None):
1167 # type: (Optional[TraversalState]) -> hnode_t
1168 trav = trav or TraversalState()
1169 heap_id = id(self)
1170 if heap_id in trav.seen:
1171 return hnode.AlreadySeen(heap_id)
1172 trav.seen[heap_id] = True
1173 out_node = NewRecord('trace__CommandSub')
1174 L = out_node.fields
1175 return out_node
1176
1177 def AbbreviatedTree(self, trav=None):
1178 # type: (Optional[TraversalState]) -> hnode_t
1179 return self._AbbreviatedTree(trav=trav)
1180
1181class trace__ForkWait(trace_t):
1182 _type_tag = 3
1183 __slots__ = ()
1184
1185 def __init__(self, ):
1186 # type: () -> None
1187 pass
1188
1189 def PrettyTree(self, trav=None):
1190 # type: (Optional[TraversalState]) -> hnode_t
1191 trav = trav or TraversalState()
1192 heap_id = id(self)
1193 if heap_id in trav.seen:
1194 return hnode.AlreadySeen(heap_id)
1195 trav.seen[heap_id] = True
1196 out_node = NewRecord('trace__ForkWait')
1197 L = out_node.fields
1198
1199 return out_node
1200
1201 def _AbbreviatedTree(self, trav=None):
1202 # type: (Optional[TraversalState]) -> hnode_t
1203 trav = trav or TraversalState()
1204 heap_id = id(self)
1205 if heap_id in trav.seen:
1206 return hnode.AlreadySeen(heap_id)
1207 trav.seen[heap_id] = True
1208 out_node = NewRecord('trace__ForkWait')
1209 L = out_node.fields
1210 return out_node
1211
1212 def AbbreviatedTree(self, trav=None):
1213 # type: (Optional[TraversalState]) -> hnode_t
1214 return self._AbbreviatedTree(trav=trav)
1215
1216class trace__Fork(trace_t):
1217 _type_tag = 4
1218 __slots__ = ()
1219
1220 def __init__(self, ):
1221 # type: () -> None
1222 pass
1223
1224 def PrettyTree(self, trav=None):
1225 # type: (Optional[TraversalState]) -> hnode_t
1226 trav = trav or TraversalState()
1227 heap_id = id(self)
1228 if heap_id in trav.seen:
1229 return hnode.AlreadySeen(heap_id)
1230 trav.seen[heap_id] = True
1231 out_node = NewRecord('trace__Fork')
1232 L = out_node.fields
1233
1234 return out_node
1235
1236 def _AbbreviatedTree(self, trav=None):
1237 # type: (Optional[TraversalState]) -> hnode_t
1238 trav = trav or TraversalState()
1239 heap_id = id(self)
1240 if heap_id in trav.seen:
1241 return hnode.AlreadySeen(heap_id)
1242 trav.seen[heap_id] = True
1243 out_node = NewRecord('trace__Fork')
1244 L = out_node.fields
1245 return out_node
1246
1247 def AbbreviatedTree(self, trav=None):
1248 # type: (Optional[TraversalState]) -> hnode_t
1249 return self._AbbreviatedTree(trav=trav)
1250
1251class trace__PipelinePart(trace_t):
1252 _type_tag = 5
1253 __slots__ = ()
1254
1255 def __init__(self, ):
1256 # type: () -> None
1257 pass
1258
1259 def PrettyTree(self, trav=None):
1260 # type: (Optional[TraversalState]) -> hnode_t
1261 trav = trav or TraversalState()
1262 heap_id = id(self)
1263 if heap_id in trav.seen:
1264 return hnode.AlreadySeen(heap_id)
1265 trav.seen[heap_id] = True
1266 out_node = NewRecord('trace__PipelinePart')
1267 L = out_node.fields
1268
1269 return out_node
1270
1271 def _AbbreviatedTree(self, trav=None):
1272 # type: (Optional[TraversalState]) -> hnode_t
1273 trav = trav or TraversalState()
1274 heap_id = id(self)
1275 if heap_id in trav.seen:
1276 return hnode.AlreadySeen(heap_id)
1277 trav.seen[heap_id] = True
1278 out_node = NewRecord('trace__PipelinePart')
1279 L = out_node.fields
1280 return out_node
1281
1282 def AbbreviatedTree(self, trav=None):
1283 # type: (Optional[TraversalState]) -> hnode_t
1284 return self._AbbreviatedTree(trav=trav)
1285
1286class trace__ProcessSub(trace_t):
1287 _type_tag = 6
1288 __slots__ = ()
1289
1290 def __init__(self, ):
1291 # type: () -> None
1292 pass
1293
1294 def PrettyTree(self, trav=None):
1295 # type: (Optional[TraversalState]) -> hnode_t
1296 trav = trav or TraversalState()
1297 heap_id = id(self)
1298 if heap_id in trav.seen:
1299 return hnode.AlreadySeen(heap_id)
1300 trav.seen[heap_id] = True
1301 out_node = NewRecord('trace__ProcessSub')
1302 L = out_node.fields
1303
1304 return out_node
1305
1306 def _AbbreviatedTree(self, trav=None):
1307 # type: (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 out_node = NewRecord('trace__ProcessSub')
1314 L = out_node.fields
1315 return out_node
1316
1317 def AbbreviatedTree(self, trav=None):
1318 # type: (Optional[TraversalState]) -> hnode_t
1319 return self._AbbreviatedTree(trav=trav)
1320
1321class trace__HereDoc(trace_t):
1322 _type_tag = 7
1323 __slots__ = ()
1324
1325 def __init__(self, ):
1326 # type: () -> None
1327 pass
1328
1329 def PrettyTree(self, trav=None):
1330 # type: (Optional[TraversalState]) -> hnode_t
1331 trav = trav or TraversalState()
1332 heap_id = id(self)
1333 if heap_id in trav.seen:
1334 return hnode.AlreadySeen(heap_id)
1335 trav.seen[heap_id] = True
1336 out_node = NewRecord('trace__HereDoc')
1337 L = out_node.fields
1338
1339 return out_node
1340
1341 def _AbbreviatedTree(self, trav=None):
1342 # type: (Optional[TraversalState]) -> hnode_t
1343 trav = trav or TraversalState()
1344 heap_id = id(self)
1345 if heap_id in trav.seen:
1346 return hnode.AlreadySeen(heap_id)
1347 trav.seen[heap_id] = True
1348 out_node = NewRecord('trace__HereDoc')
1349 L = out_node.fields
1350 return out_node
1351
1352 def AbbreviatedTree(self, trav=None):
1353 # type: (Optional[TraversalState]) -> hnode_t
1354 return self._AbbreviatedTree(trav=trav)
1355
1356class trace(object):
1357 class External(trace_t):
1358 _type_tag = 1
1359 __slots__ = ('argv',)
1360
1361 def __init__(self, argv):
1362 # type: (List[str]) -> None
1363 self.argv = argv
1364
1365 @staticmethod
1366 def CreateNull(alloc_lists=False):
1367 # type: () -> trace.External
1368 return trace.External([] if alloc_lists else cast('List[str]', None))
1369
1370 def PrettyTree(self, trav=None):
1371 # type: (Optional[TraversalState]) -> hnode_t
1372 trav = trav or TraversalState()
1373 heap_id = id(self)
1374 if heap_id in trav.seen:
1375 return hnode.AlreadySeen(heap_id)
1376 trav.seen[heap_id] = True
1377 out_node = NewRecord('trace.External')
1378 L = out_node.fields
1379
1380 if self.argv is not None: # List
1381 x0 = hnode.Array([])
1382 for i0 in self.argv:
1383 x0.children.append(NewLeaf(i0, color_e.StringConst))
1384 L.append(Field('argv', x0))
1385
1386 return out_node
1387
1388 def _AbbreviatedTree(self, trav=None):
1389 # type: (Optional[TraversalState]) -> hnode_t
1390 trav = trav or TraversalState()
1391 heap_id = id(self)
1392 if heap_id in trav.seen:
1393 return hnode.AlreadySeen(heap_id)
1394 trav.seen[heap_id] = True
1395 out_node = NewRecord('trace.External')
1396 L = out_node.fields
1397 if self.argv is not None: # List
1398 x0 = hnode.Array([])
1399 for i0 in self.argv:
1400 x0.children.append(NewLeaf(i0, color_e.StringConst))
1401 L.append(Field('argv', x0))
1402
1403 return out_node
1404
1405 def AbbreviatedTree(self, trav=None):
1406 # type: (Optional[TraversalState]) -> hnode_t
1407 return self._AbbreviatedTree(trav=trav)
1408
1409 CommandSub = trace__CommandSub()
1410
1411 ForkWait = trace__ForkWait()
1412
1413 Fork = trace__Fork()
1414
1415 PipelinePart = trace__PipelinePart()
1416
1417 ProcessSub = trace__ProcessSub()
1418
1419 HereDoc = trace__HereDoc()
1420
1421 pass
1422
1423class word_style_t(pybase.SimpleObj):
1424 pass
1425
1426class word_style_e(object):
1427 Expr = word_style_t(1)
1428 Unquoted = word_style_t(2)
1429 DQ = word_style_t(3)
1430 SQ = word_style_t(4)
1431
1432_word_style_str = {
1433 1: 'word_style.Expr',
1434 2: 'word_style.Unquoted',
1435 3: 'word_style.DQ',
1436 4: 'word_style.SQ',
1437}
1438
1439def word_style_str(val):
1440 # type: (word_style_t) -> str
1441 return _word_style_str[val]
1442
1443class comp_action_t(pybase.SimpleObj):
1444 pass
1445
1446class comp_action_e(object):
1447 Other = comp_action_t(1)
1448 FileSystem = comp_action_t(2)
1449 BashFunc = comp_action_t(3)
1450
1451_comp_action_str = {
1452 1: 'comp_action.Other',
1453 2: 'comp_action.FileSystem',
1454 3: 'comp_action.BashFunc',
1455}
1456
1457def comp_action_str(val):
1458 # type: (comp_action_t) -> str
1459 return _comp_action_str[val]
1460
1461class AssignArg(pybase.CompoundObj):
1462 _type_tag = 64
1463 __slots__ = ('var_name', 'rval', 'plus_eq', 'blame_word')
1464
1465 def __init__(self, var_name, rval, plus_eq, blame_word):
1466 # type: (str, Optional[value_t], bool, CompoundWord) -> None
1467 self.var_name = var_name
1468 self.rval = rval
1469 self.plus_eq = plus_eq
1470 self.blame_word = blame_word
1471
1472 @staticmethod
1473 def CreateNull(alloc_lists=False):
1474 # type: () -> AssignArg
1475 return AssignArg('', cast('Optional[value_t]', None), False, cast(CompoundWord, None))
1476
1477 def PrettyTree(self, trav=None):
1478 # type: (Optional[TraversalState]) -> hnode_t
1479 trav = trav or TraversalState()
1480 heap_id = id(self)
1481 if heap_id in trav.seen:
1482 return hnode.AlreadySeen(heap_id)
1483 trav.seen[heap_id] = True
1484 out_node = NewRecord('AssignArg')
1485 L = out_node.fields
1486
1487 x0 = NewLeaf(self.var_name, color_e.StringConst)
1488 L.append(Field('var_name', x0))
1489
1490 if self.rval is not None: # Optional
1491 x1 = self.rval.PrettyTree(trav=trav)
1492 L.append(Field('rval', x1))
1493
1494 x2 = hnode.Leaf('T' if self.plus_eq else 'F', color_e.OtherConst)
1495 L.append(Field('plus_eq', x2))
1496
1497 assert self.blame_word is not None
1498 x3 = self.blame_word.PrettyTree(trav=trav)
1499 L.append(Field('blame_word', x3))
1500
1501 return out_node
1502
1503 def _AbbreviatedTree(self, trav=None):
1504 # type: (Optional[TraversalState]) -> hnode_t
1505 trav = trav or TraversalState()
1506 heap_id = id(self)
1507 if heap_id in trav.seen:
1508 return hnode.AlreadySeen(heap_id)
1509 trav.seen[heap_id] = True
1510 out_node = NewRecord('AssignArg')
1511 L = out_node.fields
1512 x0 = NewLeaf(self.var_name, color_e.StringConst)
1513 L.append(Field('var_name', x0))
1514
1515 if self.rval is not None: # Optional
1516 x1 = self.rval.AbbreviatedTree(trav=trav)
1517 L.append(Field('rval', x1))
1518
1519 x2 = hnode.Leaf('T' if self.plus_eq else 'F', color_e.OtherConst)
1520 L.append(Field('plus_eq', x2))
1521
1522 assert self.blame_word is not None
1523 x3 = self.blame_word.AbbreviatedTree(trav=trav)
1524 L.append(Field('blame_word', x3))
1525
1526 return out_node
1527
1528 def AbbreviatedTree(self, trav=None):
1529 # type: (Optional[TraversalState]) -> hnode_t
1530 return self._AbbreviatedTree(trav=trav)
1531
1532class Piece(part_value_t):
1533 _type_tag = 65
1534 __slots__ = ('s', 'quoted', 'do_split')
1535
1536 def __init__(self, s, quoted, do_split):
1537 # type: (str, bool, bool) -> None
1538 self.s = s
1539 self.quoted = quoted
1540 self.do_split = do_split
1541
1542 @staticmethod
1543 def CreateNull(alloc_lists=False):
1544 # type: () -> Piece
1545 return Piece('', False, False)
1546
1547 def PrettyTree(self, trav=None):
1548 # type: (Optional[TraversalState]) -> hnode_t
1549 trav = trav or TraversalState()
1550 heap_id = id(self)
1551 if heap_id in trav.seen:
1552 return hnode.AlreadySeen(heap_id)
1553 trav.seen[heap_id] = True
1554 out_node = NewRecord('Piece')
1555 L = out_node.fields
1556
1557 x0 = NewLeaf(self.s, color_e.StringConst)
1558 L.append(Field('s', x0))
1559
1560 x1 = hnode.Leaf('T' if self.quoted else 'F', color_e.OtherConst)
1561 L.append(Field('quoted', x1))
1562
1563 x2 = hnode.Leaf('T' if self.do_split else 'F', color_e.OtherConst)
1564 L.append(Field('do_split', x2))
1565
1566 return out_node
1567
1568 def _AbbreviatedTree(self, trav=None):
1569 # type: (Optional[TraversalState]) -> hnode_t
1570 trav = trav or TraversalState()
1571 heap_id = id(self)
1572 if heap_id in trav.seen:
1573 return hnode.AlreadySeen(heap_id)
1574 trav.seen[heap_id] = True
1575 out_node = NewRecord('Piece')
1576 L = out_node.fields
1577 x0 = NewLeaf(self.s, color_e.StringConst)
1578 L.append(Field('s', x0))
1579
1580 x1 = hnode.Leaf('T' if self.quoted else 'F', color_e.OtherConst)
1581 L.append(Field('quoted', x1))
1582
1583 x2 = hnode.Leaf('T' if self.do_split else 'F', color_e.OtherConst)
1584 L.append(Field('do_split', x2))
1585
1586 return out_node
1587
1588 def AbbreviatedTree(self, trav=None):
1589 # type: (Optional[TraversalState]) -> hnode_t
1590 return self._AbbreviatedTree(trav=trav)
1591
1592class VarSubState(pybase.CompoundObj):
1593 _type_tag = 66
1594 __slots__ = ('join_array', 'is_type_query', 'has_test_op')
1595
1596 def __init__(self, join_array, is_type_query, has_test_op):
1597 # type: (bool, bool, bool) -> None
1598 self.join_array = join_array
1599 self.is_type_query = is_type_query
1600 self.has_test_op = has_test_op
1601
1602 @staticmethod
1603 def CreateNull(alloc_lists=False):
1604 # type: () -> VarSubState
1605 return VarSubState(False, False, False)
1606
1607 def PrettyTree(self, trav=None):
1608 # type: (Optional[TraversalState]) -> hnode_t
1609 trav = trav or TraversalState()
1610 heap_id = id(self)
1611 if heap_id in trav.seen:
1612 return hnode.AlreadySeen(heap_id)
1613 trav.seen[heap_id] = True
1614 out_node = NewRecord('VarSubState')
1615 L = out_node.fields
1616
1617 x0 = hnode.Leaf('T' if self.join_array else 'F', color_e.OtherConst)
1618 L.append(Field('join_array', x0))
1619
1620 x1 = hnode.Leaf('T' if self.is_type_query else 'F', color_e.OtherConst)
1621 L.append(Field('is_type_query', x1))
1622
1623 x2 = hnode.Leaf('T' if self.has_test_op else 'F', color_e.OtherConst)
1624 L.append(Field('has_test_op', x2))
1625
1626 return out_node
1627
1628 def _AbbreviatedTree(self, trav=None):
1629 # type: (Optional[TraversalState]) -> hnode_t
1630 trav = trav or TraversalState()
1631 heap_id = id(self)
1632 if heap_id in trav.seen:
1633 return hnode.AlreadySeen(heap_id)
1634 trav.seen[heap_id] = True
1635 out_node = NewRecord('VarSubState')
1636 L = out_node.fields
1637 x0 = hnode.Leaf('T' if self.join_array else 'F', color_e.OtherConst)
1638 L.append(Field('join_array', x0))
1639
1640 x1 = hnode.Leaf('T' if self.is_type_query else 'F', color_e.OtherConst)
1641 L.append(Field('is_type_query', x1))
1642
1643 x2 = hnode.Leaf('T' if self.has_test_op else 'F', color_e.OtherConst)
1644 L.append(Field('has_test_op', x2))
1645
1646 return out_node
1647
1648 def AbbreviatedTree(self, trav=None):
1649 # type: (Optional[TraversalState]) -> hnode_t
1650 return self._AbbreviatedTree(trav=trav)
1651
1652class Cell(pybase.CompoundObj):
1653 _type_tag = 67
1654 __slots__ = ('exported', 'readonly', 'nameref', 'val')
1655
1656 def __init__(self, exported, readonly, nameref, val):
1657 # type: (bool, bool, bool, value_t) -> None
1658 self.exported = exported
1659 self.readonly = readonly
1660 self.nameref = nameref
1661 self.val = val
1662
1663 @staticmethod
1664 def CreateNull(alloc_lists=False):
1665 # type: () -> Cell
1666 return Cell(False, False, False, cast(value_t, None))
1667
1668 def PrettyTree(self, trav=None):
1669 # type: (Optional[TraversalState]) -> hnode_t
1670 trav = trav or TraversalState()
1671 heap_id = id(self)
1672 if heap_id in trav.seen:
1673 return hnode.AlreadySeen(heap_id)
1674 trav.seen[heap_id] = True
1675 out_node = NewRecord('Cell')
1676 L = out_node.fields
1677
1678 x0 = hnode.Leaf('T' if self.exported else 'F', color_e.OtherConst)
1679 L.append(Field('exported', x0))
1680
1681 x1 = hnode.Leaf('T' if self.readonly else 'F', color_e.OtherConst)
1682 L.append(Field('readonly', x1))
1683
1684 x2 = hnode.Leaf('T' if self.nameref else 'F', color_e.OtherConst)
1685 L.append(Field('nameref', x2))
1686
1687 assert self.val is not None
1688 x3 = self.val.PrettyTree(trav=trav)
1689 L.append(Field('val', x3))
1690
1691 return out_node
1692
1693 def _AbbreviatedTree(self, trav=None):
1694 # type: (Optional[TraversalState]) -> hnode_t
1695 trav = trav or TraversalState()
1696 heap_id = id(self)
1697 if heap_id in trav.seen:
1698 return hnode.AlreadySeen(heap_id)
1699 trav.seen[heap_id] = True
1700 out_node = NewRecord('Cell')
1701 L = out_node.fields
1702 x0 = hnode.Leaf('T' if self.exported else 'F', color_e.OtherConst)
1703 L.append(Field('exported', x0))
1704
1705 x1 = hnode.Leaf('T' if self.readonly else 'F', color_e.OtherConst)
1706 L.append(Field('readonly', x1))
1707
1708 x2 = hnode.Leaf('T' if self.nameref else 'F', color_e.OtherConst)
1709 L.append(Field('nameref', x2))
1710
1711 assert self.val is not None
1712 x3 = self.val.AbbreviatedTree(trav=trav)
1713 L.append(Field('val', x3))
1714
1715 return out_node
1716
1717 def AbbreviatedTree(self, trav=None):
1718 # type: (Optional[TraversalState]) -> hnode_t
1719 return self._AbbreviatedTree(trav=trav)
1720
1721class VTestPlace(pybase.CompoundObj):
1722 _type_tag = 68
1723 __slots__ = ('name', 'index')
1724
1725 def __init__(self, name, index):
1726 # type: (Optional[str], Optional[a_index_t]) -> None
1727 self.name = name
1728 self.index = index
1729
1730 @staticmethod
1731 def CreateNull(alloc_lists=False):
1732 # type: () -> VTestPlace
1733 return VTestPlace(cast('Optional[str]', None), cast('Optional[a_index_t]', None))
1734
1735 def PrettyTree(self, trav=None):
1736 # type: (Optional[TraversalState]) -> hnode_t
1737 trav = trav or TraversalState()
1738 heap_id = id(self)
1739 if heap_id in trav.seen:
1740 return hnode.AlreadySeen(heap_id)
1741 trav.seen[heap_id] = True
1742 out_node = NewRecord('VTestPlace')
1743 L = out_node.fields
1744
1745 if self.name is not None: # Optional
1746 x0 = NewLeaf(self.name, color_e.StringConst)
1747 L.append(Field('name', x0))
1748
1749 if self.index is not None: # Optional
1750 x1 = self.index.PrettyTree(trav=trav)
1751 L.append(Field('index', x1))
1752
1753 return out_node
1754
1755 def _AbbreviatedTree(self, trav=None):
1756 # type: (Optional[TraversalState]) -> hnode_t
1757 trav = trav or TraversalState()
1758 heap_id = id(self)
1759 if heap_id in trav.seen:
1760 return hnode.AlreadySeen(heap_id)
1761 trav.seen[heap_id] = True
1762 out_node = NewRecord('VTestPlace')
1763 L = out_node.fields
1764 if self.name is not None: # Optional
1765 x0 = NewLeaf(self.name, color_e.StringConst)
1766 L.append(Field('name', x0))
1767
1768 if self.index is not None: # Optional
1769 x1 = self.index.AbbreviatedTree(trav=trav)
1770 L.append(Field('index', x1))
1771
1772 return out_node
1773
1774 def AbbreviatedTree(self, trav=None):
1775 # type: (Optional[TraversalState]) -> hnode_t
1776 return self._AbbreviatedTree(trav=trav)
1777
1778class RedirValue(pybase.CompoundObj):
1779 _type_tag = 69
1780 __slots__ = ('op_id', 'op_loc', 'loc', 'arg')
1781
1782 def __init__(self, op_id, op_loc, loc, arg):
1783 # type: (Id_t, loc_t, redir_loc_t, redirect_arg_t) -> None
1784 self.op_id = op_id
1785 self.op_loc = op_loc
1786 self.loc = loc
1787 self.arg = arg
1788
1789 @staticmethod
1790 def CreateNull(alloc_lists=False):
1791 # type: () -> RedirValue
1792 return RedirValue(-1, cast(loc_t, None), cast(redir_loc_t, None), cast(redirect_arg_t, None))
1793
1794 def PrettyTree(self, trav=None):
1795 # type: (Optional[TraversalState]) -> hnode_t
1796 trav = trav or TraversalState()
1797 heap_id = id(self)
1798 if heap_id in trav.seen:
1799 return hnode.AlreadySeen(heap_id)
1800 trav.seen[heap_id] = True
1801 out_node = NewRecord('RedirValue')
1802 L = out_node.fields
1803
1804 x0 = hnode.Leaf(Id_str(self.op_id), color_e.UserType)
1805 L.append(Field('op_id', x0))
1806
1807 assert self.op_loc is not None
1808 x1 = self.op_loc.PrettyTree(trav=trav)
1809 L.append(Field('op_loc', x1))
1810
1811 assert self.loc is not None
1812 x2 = self.loc.PrettyTree(trav=trav)
1813 L.append(Field('loc', x2))
1814
1815 assert self.arg is not None
1816 x3 = self.arg.PrettyTree(trav=trav)
1817 L.append(Field('arg', x3))
1818
1819 return out_node
1820
1821 def _AbbreviatedTree(self, trav=None):
1822 # type: (Optional[TraversalState]) -> hnode_t
1823 trav = trav or TraversalState()
1824 heap_id = id(self)
1825 if heap_id in trav.seen:
1826 return hnode.AlreadySeen(heap_id)
1827 trav.seen[heap_id] = True
1828 out_node = NewRecord('RedirValue')
1829 L = out_node.fields
1830 x0 = hnode.Leaf(Id_str(self.op_id), color_e.UserType)
1831 L.append(Field('op_id', x0))
1832
1833 assert self.op_loc is not None
1834 x1 = self.op_loc.AbbreviatedTree(trav=trav)
1835 L.append(Field('op_loc', x1))
1836
1837 assert self.loc is not None
1838 x2 = self.loc.AbbreviatedTree(trav=trav)
1839 L.append(Field('loc', x2))
1840
1841 assert self.arg is not None
1842 x3 = self.arg.AbbreviatedTree(trav=trav)
1843 L.append(Field('arg', x3))
1844
1845 return out_node
1846
1847 def AbbreviatedTree(self, trav=None):
1848 # type: (Optional[TraversalState]) -> hnode_t
1849 return self._AbbreviatedTree(trav=trav)
1850
1851class StatusArray(pybase.CompoundObj):
1852 _type_tag = 70
1853 __slots__ = ('codes', 'locs')
1854
1855 def __init__(self, codes, locs):
1856 # type: (Optional[List[int]], Optional[List[loc_t]]) -> None
1857 self.codes = codes
1858 self.locs = locs
1859
1860 @staticmethod
1861 def CreateNull(alloc_lists=False):
1862 # type: () -> StatusArray
1863 return StatusArray(cast('Optional[List[int]]', None), cast('Optional[List[loc_t]]', None))
1864
1865 def PrettyTree(self, trav=None):
1866 # type: (Optional[TraversalState]) -> hnode_t
1867 trav = trav or TraversalState()
1868 heap_id = id(self)
1869 if heap_id in trav.seen:
1870 return hnode.AlreadySeen(heap_id)
1871 trav.seen[heap_id] = True
1872 out_node = NewRecord('StatusArray')
1873 L = out_node.fields
1874
1875 if self.codes is not None: # List
1876 x0 = hnode.Array([])
1877 for i0 in self.codes:
1878 x0.children.append(hnode.Leaf(str(i0), color_e.OtherConst))
1879 L.append(Field('codes', x0))
1880
1881 if self.locs is not None: # List
1882 x1 = hnode.Array([])
1883 for i1 in self.locs:
1884 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1885 i1.PrettyTree(trav=trav))
1886 x1.children.append(h)
1887 L.append(Field('locs', x1))
1888
1889 return out_node
1890
1891 def _AbbreviatedTree(self, trav=None):
1892 # type: (Optional[TraversalState]) -> hnode_t
1893 trav = trav or TraversalState()
1894 heap_id = id(self)
1895 if heap_id in trav.seen:
1896 return hnode.AlreadySeen(heap_id)
1897 trav.seen[heap_id] = True
1898 out_node = NewRecord('StatusArray')
1899 L = out_node.fields
1900 if self.codes is not None: # List
1901 x0 = hnode.Array([])
1902 for i0 in self.codes:
1903 x0.children.append(hnode.Leaf(str(i0), color_e.OtherConst))
1904 L.append(Field('codes', x0))
1905
1906 if self.locs is not None: # List
1907 x1 = hnode.Array([])
1908 for i1 in self.locs:
1909 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1910 i1.AbbreviatedTree(trav=trav))
1911 x1.children.append(h)
1912 L.append(Field('locs', x1))
1913
1914 return out_node
1915
1916 def AbbreviatedTree(self, trav=None):
1917 # type: (Optional[TraversalState]) -> hnode_t
1918 return self._AbbreviatedTree(trav=trav)
1919
1920class CommandStatus(pybase.CompoundObj):
1921 _type_tag = 71
1922 __slots__ = ('check_errexit', 'show_code', 'pipe_negated', 'pipe_status',
1923 'pipe_locs')
1924
1925 def __init__(self, check_errexit, show_code, pipe_negated, pipe_status,
1926 pipe_locs):
1927 # type: (bool, bool, bool, Optional[List[int]], Optional[List[loc_t]]) -> None
1928 self.check_errexit = check_errexit
1929 self.show_code = show_code
1930 self.pipe_negated = pipe_negated
1931 self.pipe_status = pipe_status
1932 self.pipe_locs = pipe_locs
1933
1934 @staticmethod
1935 def CreateNull(alloc_lists=False):
1936 # type: () -> CommandStatus
1937 return CommandStatus(False, False, False, cast('Optional[List[int]]', None), cast('Optional[List[loc_t]]', None))
1938
1939 def PrettyTree(self, trav=None):
1940 # type: (Optional[TraversalState]) -> hnode_t
1941 trav = trav or TraversalState()
1942 heap_id = id(self)
1943 if heap_id in trav.seen:
1944 return hnode.AlreadySeen(heap_id)
1945 trav.seen[heap_id] = True
1946 out_node = NewRecord('CommandStatus')
1947 L = out_node.fields
1948
1949 x0 = hnode.Leaf('T' if self.check_errexit else 'F', color_e.OtherConst)
1950 L.append(Field('check_errexit', x0))
1951
1952 x1 = hnode.Leaf('T' if self.show_code else 'F', color_e.OtherConst)
1953 L.append(Field('show_code', x1))
1954
1955 x2 = hnode.Leaf('T' if self.pipe_negated else 'F', color_e.OtherConst)
1956 L.append(Field('pipe_negated', x2))
1957
1958 if self.pipe_status is not None: # List
1959 x3 = hnode.Array([])
1960 for i3 in self.pipe_status:
1961 x3.children.append(hnode.Leaf(str(i3), color_e.OtherConst))
1962 L.append(Field('pipe_status', x3))
1963
1964 if self.pipe_locs is not None: # List
1965 x4 = hnode.Array([])
1966 for i4 in self.pipe_locs:
1967 h = (hnode.Leaf("_", color_e.OtherConst) if i4 is None else
1968 i4.PrettyTree(trav=trav))
1969 x4.children.append(h)
1970 L.append(Field('pipe_locs', x4))
1971
1972 return out_node
1973
1974 def _AbbreviatedTree(self, trav=None):
1975 # type: (Optional[TraversalState]) -> hnode_t
1976 trav = trav or TraversalState()
1977 heap_id = id(self)
1978 if heap_id in trav.seen:
1979 return hnode.AlreadySeen(heap_id)
1980 trav.seen[heap_id] = True
1981 out_node = NewRecord('CommandStatus')
1982 L = out_node.fields
1983 x0 = hnode.Leaf('T' if self.check_errexit else 'F', color_e.OtherConst)
1984 L.append(Field('check_errexit', x0))
1985
1986 x1 = hnode.Leaf('T' if self.show_code else 'F', color_e.OtherConst)
1987 L.append(Field('show_code', x1))
1988
1989 x2 = hnode.Leaf('T' if self.pipe_negated else 'F', color_e.OtherConst)
1990 L.append(Field('pipe_negated', x2))
1991
1992 if self.pipe_status is not None: # List
1993 x3 = hnode.Array([])
1994 for i3 in self.pipe_status:
1995 x3.children.append(hnode.Leaf(str(i3), color_e.OtherConst))
1996 L.append(Field('pipe_status', x3))
1997
1998 if self.pipe_locs is not None: # List
1999 x4 = hnode.Array([])
2000 for i4 in self.pipe_locs:
2001 h = (hnode.Leaf("_", color_e.OtherConst) if i4 is None else
2002 i4.AbbreviatedTree(trav=trav))
2003 x4.children.append(h)
2004 L.append(Field('pipe_locs', x4))
2005
2006 return out_node
2007
2008 def AbbreviatedTree(self, trav=None):
2009 # type: (Optional[TraversalState]) -> hnode_t
2010 return self._AbbreviatedTree(trav=trav)
2011
2012class HayNode(pybase.CompoundObj):
2013 _type_tag = 72
2014 __slots__ = ('children',)
2015
2016 def __init__(self, children):
2017 # type: (Dict[str, HayNode]) -> None
2018 self.children = children
2019
2020 @staticmethod
2021 def CreateNull(alloc_lists=False):
2022 # type: () -> HayNode
2023 return HayNode(cast('Dict[str, HayNode]', None))
2024
2025 def PrettyTree(self, trav=None):
2026 # type: (Optional[TraversalState]) -> hnode_t
2027 trav = trav or TraversalState()
2028 heap_id = id(self)
2029 if heap_id in trav.seen:
2030 return hnode.AlreadySeen(heap_id)
2031 trav.seen[heap_id] = True
2032 out_node = NewRecord('HayNode')
2033 L = out_node.fields
2034
2035 if self.children is not None: # Dict
2036 m = hnode.Leaf("Dict", color_e.OtherConst)
2037 x0 = hnode.Array([m])
2038 for k0, v0 in self.children.iteritems():
2039 x0.children.append(NewLeaf(k0, color_e.StringConst))
2040 x0.children.append(v0.PrettyTree(trav=trav))
2041 L.append(Field('children', x0))
2042
2043 return out_node
2044
2045 def _AbbreviatedTree(self, trav=None):
2046 # type: (Optional[TraversalState]) -> hnode_t
2047 trav = trav or TraversalState()
2048 heap_id = id(self)
2049 if heap_id in trav.seen:
2050 return hnode.AlreadySeen(heap_id)
2051 trav.seen[heap_id] = True
2052 out_node = NewRecord('HayNode')
2053 L = out_node.fields
2054 if self.children is not None: # Dict
2055 m = hnode.Leaf("Dict", color_e.OtherConst)
2056 x0 = hnode.Array([m])
2057 for k0, v0 in self.children.iteritems():
2058 x0.children.append(NewLeaf(k0, color_e.StringConst))
2059 x0.children.append(v0.AbbreviatedTree(trav=trav))
2060 L.append(Field('children', x0))
2061
2062 return out_node
2063
2064 def AbbreviatedTree(self, trav=None):
2065 # type: (Optional[TraversalState]) -> hnode_t
2066 return self._AbbreviatedTree(trav=trav)
2067