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

1660 lines, 1191 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, command_t, DoubleQuoted, re_t, proc_sig_t, Func, NameType, EggexFlag, BraceGroup, SourceLine, debug_frame_t, ShFunction, cmd_frag_t
7 from _devbuild.gen.runtime_asdl import Cell
8
9from asdl import runtime # For runtime.NO_SPID
10from asdl.runtime import NewRecord, NewLeaf, TraversalState
11from _devbuild.gen.hnode_asdl import color_e, hnode, hnode_e, hnode_t, Field
12
13class y_lvalue_e(object):
14 Local = 67
15 Container = 2
16
17_y_lvalue_str = {
18 2: 'Container',
19 67: 'Local',
20}
21
22def y_lvalue_str(tag, dot=True):
23 # type: (int, bool) -> str
24 v = _y_lvalue_str[tag]
25 if dot:
26 return "y_lvalue.%s" % v
27 else:
28 return v
29
30class y_lvalue_t(pybase.CompoundObj):
31 def tag(self):
32 # type: () -> int
33 return self._type_tag
34
35class y_lvalue(object):
36 class Container(y_lvalue_t):
37 _type_tag = 2
38 __slots__ = ('obj', 'index')
39
40 def __init__(self, obj, index):
41 # type: (value_t, value_t) -> None
42 self.obj = obj
43 self.index = index
44
45 @staticmethod
46 def CreateNull(alloc_lists=False):
47 # type: () -> y_lvalue.Container
48 return y_lvalue.Container(cast('value_t', None), cast('value_t', None))
49
50 def PrettyTree(self, do_abbrev, trav=None):
51 # type: (bool, Optional[TraversalState]) -> hnode_t
52 trav = trav or TraversalState()
53 heap_id = id(self)
54 if heap_id in trav.seen:
55 return hnode.AlreadySeen(heap_id)
56 trav.seen[heap_id] = True
57
58 out_node = NewRecord('y_lvalue.Container')
59 L = out_node.fields
60
61 assert self.obj is not None
62 x0 = self.obj.PrettyTree(do_abbrev, trav=trav)
63 L.append(Field('obj', x0))
64
65 assert self.index is not None
66 x1 = self.index.PrettyTree(do_abbrev, trav=trav)
67 L.append(Field('index', x1))
68
69 return out_node
70
71 pass
72
73class sh_lvalue_e(object):
74 Var = 67
75 Indexed = 2
76 Keyed = 3
77
78_sh_lvalue_str = {
79 2: 'Indexed',
80 3: 'Keyed',
81 67: 'Var',
82}
83
84def sh_lvalue_str(tag, dot=True):
85 # type: (int, bool) -> str
86 v = _sh_lvalue_str[tag]
87 if dot:
88 return "sh_lvalue.%s" % v
89 else:
90 return v
91
92class sh_lvalue_t(pybase.CompoundObj):
93 def tag(self):
94 # type: () -> int
95 return self._type_tag
96
97class sh_lvalue(object):
98 class Indexed(sh_lvalue_t):
99 _type_tag = 2
100 __slots__ = ('name', 'index', 'blame_loc')
101
102 def __init__(self, name, index, blame_loc):
103 # type: (str, int, loc_t) -> None
104 self.name = name
105 self.index = index
106 self.blame_loc = blame_loc
107
108 @staticmethod
109 def CreateNull(alloc_lists=False):
110 # type: () -> sh_lvalue.Indexed
111 return sh_lvalue.Indexed('', -1, cast('loc_t', None))
112
113 def PrettyTree(self, do_abbrev, trav=None):
114 # type: (bool, Optional[TraversalState]) -> hnode_t
115 trav = trav or TraversalState()
116 heap_id = id(self)
117 if heap_id in trav.seen:
118 return hnode.AlreadySeen(heap_id)
119 trav.seen[heap_id] = True
120
121 out_node = NewRecord('sh_lvalue.Indexed')
122 L = out_node.fields
123
124 x0 = NewLeaf(self.name, color_e.StringConst)
125 L.append(Field('name', x0))
126
127 x1 = hnode.Leaf(str(self.index), color_e.OtherConst)
128 L.append(Field('index', x1))
129
130 assert self.blame_loc is not None
131 x2 = self.blame_loc.PrettyTree(do_abbrev, trav=trav)
132 L.append(Field('blame_loc', x2))
133
134 return out_node
135
136 class Keyed(sh_lvalue_t):
137 _type_tag = 3
138 __slots__ = ('name', 'key', 'blame_loc')
139
140 def __init__(self, name, key, blame_loc):
141 # type: (str, str, loc_t) -> None
142 self.name = name
143 self.key = key
144 self.blame_loc = blame_loc
145
146 @staticmethod
147 def CreateNull(alloc_lists=False):
148 # type: () -> sh_lvalue.Keyed
149 return sh_lvalue.Keyed('', '', cast('loc_t', None))
150
151 def PrettyTree(self, do_abbrev, trav=None):
152 # type: (bool, Optional[TraversalState]) -> hnode_t
153 trav = trav or TraversalState()
154 heap_id = id(self)
155 if heap_id in trav.seen:
156 return hnode.AlreadySeen(heap_id)
157 trav.seen[heap_id] = True
158
159 out_node = NewRecord('sh_lvalue.Keyed')
160 L = out_node.fields
161
162 x0 = NewLeaf(self.name, color_e.StringConst)
163 L.append(Field('name', x0))
164
165 x1 = NewLeaf(self.key, color_e.StringConst)
166 L.append(Field('key', x1))
167
168 assert self.blame_loc is not None
169 x2 = self.blame_loc.PrettyTree(do_abbrev, trav=trav)
170 L.append(Field('blame_loc', x2))
171
172 return out_node
173
174 pass
175
176class eggex_ops_e(object):
177 No = 1
178 Yes = 2
179
180_eggex_ops_str = {
181 1: 'No',
182 2: 'Yes',
183}
184
185def eggex_ops_str(tag, dot=True):
186 # type: (int, bool) -> str
187 v = _eggex_ops_str[tag]
188 if dot:
189 return "eggex_ops.%s" % v
190 else:
191 return v
192
193class eggex_ops_t(pybase.CompoundObj):
194 def tag(self):
195 # type: () -> int
196 return self._type_tag
197
198class eggex_ops__No(eggex_ops_t):
199 _type_tag = 1
200 __slots__ = ()
201
202 def __init__(self, ):
203 # type: () -> None
204 pass
205
206 def PrettyTree(self, do_abbrev, trav=None):
207 # type: (bool, 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
214 out_node = NewRecord('eggex_ops.No')
215 L = out_node.fields
216
217 return out_node
218
219class eggex_ops(object):
220 No = eggex_ops__No()
221
222 class Yes(eggex_ops_t):
223 _type_tag = 2
224 __slots__ = ('convert_funcs', 'convert_toks', 'capture_names')
225
226 def __init__(self, convert_funcs, convert_toks, capture_names):
227 # type: (List[Optional[value_t]], List[Optional[Token]], List[Optional[str]]) -> None
228 self.convert_funcs = convert_funcs
229 self.convert_toks = convert_toks
230 self.capture_names = capture_names
231
232 @staticmethod
233 def CreateNull(alloc_lists=False):
234 # type: () -> eggex_ops.Yes
235 return eggex_ops.Yes([] if alloc_lists else cast('List[Optional[value_t]]', None), [] if alloc_lists else cast('List[Optional[Token]]', None), [] if alloc_lists else cast('List[Optional[str]]', None))
236
237 def PrettyTree(self, do_abbrev, trav=None):
238 # type: (bool, Optional[TraversalState]) -> hnode_t
239 trav = trav or TraversalState()
240 heap_id = id(self)
241 if heap_id in trav.seen:
242 return hnode.AlreadySeen(heap_id)
243 trav.seen[heap_id] = True
244
245 out_node = NewRecord('eggex_ops.Yes')
246 L = out_node.fields
247
248 if self.convert_funcs is not None: # List
249 x0 = hnode.Array([])
250 for i0 in self.convert_funcs:
251 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
252 i0.PrettyTree(do_abbrev, trav=trav))
253 x0.children.append(h)
254 L.append(Field('convert_funcs', x0))
255
256 if self.convert_toks is not None: # List
257 x1 = hnode.Array([])
258 for i1 in self.convert_toks:
259 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
260 i1.PrettyTree(do_abbrev, trav=trav))
261 x1.children.append(h)
262 L.append(Field('convert_toks', x1))
263
264 if self.capture_names is not None: # List
265 x2 = hnode.Array([])
266 for i2 in self.capture_names:
267 x2.children.append(NewLeaf(i2, color_e.StringConst))
268 L.append(Field('capture_names', x2))
269
270 return out_node
271
272 pass
273
274class regex_match_e(object):
275 No = 1
276 Yes = 68
277
278_regex_match_str = {
279 1: 'No',
280 68: 'Yes',
281}
282
283def regex_match_str(tag, dot=True):
284 # type: (int, bool) -> str
285 v = _regex_match_str[tag]
286 if dot:
287 return "regex_match.%s" % v
288 else:
289 return v
290
291class regex_match_t(pybase.CompoundObj):
292 def tag(self):
293 # type: () -> int
294 return self._type_tag
295
296class regex_match__No(regex_match_t):
297 _type_tag = 1
298 __slots__ = ()
299
300 def __init__(self, ):
301 # type: () -> None
302 pass
303
304 def PrettyTree(self, do_abbrev, trav=None):
305 # type: (bool, Optional[TraversalState]) -> hnode_t
306 trav = trav or TraversalState()
307 heap_id = id(self)
308 if heap_id in trav.seen:
309 return hnode.AlreadySeen(heap_id)
310 trav.seen[heap_id] = True
311
312 out_node = NewRecord('regex_match.No')
313 L = out_node.fields
314
315 return out_node
316
317class regex_match(object):
318 No = regex_match__No()
319
320 pass
321
322class value_e(object):
323 Interrupted = 1
324 Stdin = 2
325 Slice = 3
326 Undef = 4
327 Str = 5
328 InitializerList = 6
329 InternalStringArray = 7
330 BashArray = 8
331 BashAssoc = 9
332 Null = 10
333 Bool = 11
334 Int = 12
335 Float = 13
336 List = 14
337 Dict = 15
338 Obj = 69
339 Range = 17
340 Eggex = 18
341 Match = 68
342 Place = 20
343 Frame = 21
344 DebugFrame = 22
345 BoundFunc = 23
346 BuiltinFunc = 24
347 Func = 25
348 BuiltinProc = 26
349 Proc = 27
350 Expr = 28
351 CommandFrag = 29
352 Command = 30
353
354_value_str = {
355 1: 'Interrupted',
356 2: 'Stdin',
357 3: 'Slice',
358 4: 'Undef',
359 5: 'Str',
360 6: 'InitializerList',
361 7: 'InternalStringArray',
362 8: 'BashArray',
363 9: 'BashAssoc',
364 10: 'Null',
365 11: 'Bool',
366 12: 'Int',
367 13: 'Float',
368 14: 'List',
369 15: 'Dict',
370 17: 'Range',
371 18: 'Eggex',
372 20: 'Place',
373 21: 'Frame',
374 22: 'DebugFrame',
375 23: 'BoundFunc',
376 24: 'BuiltinFunc',
377 25: 'Func',
378 26: 'BuiltinProc',
379 27: 'Proc',
380 28: 'Expr',
381 29: 'CommandFrag',
382 30: 'Command',
383 68: 'Match',
384 69: 'Obj',
385}
386
387def value_str(tag, dot=True):
388 # type: (int, bool) -> str
389 v = _value_str[tag]
390 if dot:
391 return "value.%s" % v
392 else:
393 return v
394
395class value_t(pybase.CompoundObj):
396 def tag(self):
397 # type: () -> int
398 return self._type_tag
399
400class value__Interrupted(value_t):
401 _type_tag = 1
402 __slots__ = ()
403
404 def __init__(self, ):
405 # type: () -> None
406 pass
407
408 def PrettyTree(self, do_abbrev, trav=None):
409 # type: (bool, Optional[TraversalState]) -> hnode_t
410 trav = trav or TraversalState()
411 heap_id = id(self)
412 if heap_id in trav.seen:
413 return hnode.AlreadySeen(heap_id)
414 trav.seen[heap_id] = True
415
416 out_node = NewRecord('value.Interrupted')
417 L = out_node.fields
418
419 return out_node
420
421class value__Stdin(value_t):
422 _type_tag = 2
423 __slots__ = ()
424
425 def __init__(self, ):
426 # type: () -> None
427 pass
428
429 def PrettyTree(self, do_abbrev, trav=None):
430 # type: (bool, Optional[TraversalState]) -> hnode_t
431 trav = trav or TraversalState()
432 heap_id = id(self)
433 if heap_id in trav.seen:
434 return hnode.AlreadySeen(heap_id)
435 trav.seen[heap_id] = True
436
437 out_node = NewRecord('value.Stdin')
438 L = out_node.fields
439
440 return out_node
441
442class value__Undef(value_t):
443 _type_tag = 4
444 __slots__ = ()
445
446 def __init__(self, ):
447 # type: () -> None
448 pass
449
450 def PrettyTree(self, do_abbrev, trav=None):
451 # type: (bool, Optional[TraversalState]) -> hnode_t
452 trav = trav or TraversalState()
453 heap_id = id(self)
454 if heap_id in trav.seen:
455 return hnode.AlreadySeen(heap_id)
456 trav.seen[heap_id] = True
457
458 out_node = NewRecord('value.Undef')
459 L = out_node.fields
460
461 return out_node
462
463class value__Null(value_t):
464 _type_tag = 10
465 __slots__ = ()
466
467 def __init__(self, ):
468 # type: () -> None
469 pass
470
471 def PrettyTree(self, do_abbrev, trav=None):
472 # type: (bool, Optional[TraversalState]) -> hnode_t
473 trav = trav or TraversalState()
474 heap_id = id(self)
475 if heap_id in trav.seen:
476 return hnode.AlreadySeen(heap_id)
477 trav.seen[heap_id] = True
478
479 out_node = NewRecord('value.Null')
480 L = out_node.fields
481
482 return out_node
483
484class value(object):
485 Interrupted = value__Interrupted()
486
487 Stdin = value__Stdin()
488
489 class Slice(value_t):
490 _type_tag = 3
491 __slots__ = ('lower', 'upper')
492
493 def __init__(self, lower, upper):
494 # type: (Optional[IntBox], Optional[IntBox]) -> None
495 self.lower = lower
496 self.upper = upper
497
498 @staticmethod
499 def CreateNull(alloc_lists=False):
500 # type: () -> value.Slice
501 return value.Slice(cast('Optional[IntBox]', None), cast('Optional[IntBox]', None))
502
503 def PrettyTree(self, do_abbrev, trav=None):
504 # type: (bool, Optional[TraversalState]) -> hnode_t
505 trav = trav or TraversalState()
506 heap_id = id(self)
507 if heap_id in trav.seen:
508 return hnode.AlreadySeen(heap_id)
509 trav.seen[heap_id] = True
510
511 out_node = NewRecord('value.Slice')
512 L = out_node.fields
513
514 if self.lower is not None: # Optional
515 x0 = self.lower.PrettyTree(do_abbrev, trav=trav)
516 L.append(Field('lower', x0))
517
518 if self.upper is not None: # Optional
519 x1 = self.upper.PrettyTree(do_abbrev, trav=trav)
520 L.append(Field('upper', x1))
521
522 return out_node
523
524 Undef = value__Undef()
525
526 class Str(value_t):
527 _type_tag = 5
528 __slots__ = ('s',)
529
530 def __init__(self, s):
531 # type: (str) -> None
532 self.s = s
533
534 @staticmethod
535 def CreateNull(alloc_lists=False):
536 # type: () -> value.Str
537 return value.Str('')
538
539 def PrettyTree(self, do_abbrev, trav=None):
540 # type: (bool, Optional[TraversalState]) -> hnode_t
541 trav = trav or TraversalState()
542 heap_id = id(self)
543 if heap_id in trav.seen:
544 return hnode.AlreadySeen(heap_id)
545 trav.seen[heap_id] = True
546
547 out_node = NewRecord('value.Str')
548 L = out_node.fields
549
550 x0 = NewLeaf(self.s, color_e.StringConst)
551 L.append(Field('s', x0))
552
553 return out_node
554
555 class InitializerList(value_t):
556 _type_tag = 6
557 __slots__ = ('assigns',)
558
559 def __init__(self, assigns):
560 # type: (List[InitializerValue]) -> None
561 self.assigns = assigns
562
563 @staticmethod
564 def CreateNull(alloc_lists=False):
565 # type: () -> value.InitializerList
566 return value.InitializerList([] if alloc_lists else cast('List[InitializerValue]', None))
567
568 def PrettyTree(self, do_abbrev, trav=None):
569 # type: (bool, Optional[TraversalState]) -> hnode_t
570 trav = trav or TraversalState()
571 heap_id = id(self)
572 if heap_id in trav.seen:
573 return hnode.AlreadySeen(heap_id)
574 trav.seen[heap_id] = True
575
576 out_node = NewRecord('value.InitializerList')
577 L = out_node.fields
578
579 if self.assigns is not None: # List
580 x0 = hnode.Array([])
581 for i0 in self.assigns:
582 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
583 i0.PrettyTree(do_abbrev, trav=trav))
584 x0.children.append(h)
585 L.append(Field('assigns', x0))
586
587 return out_node
588
589 class InternalStringArray(value_t):
590 _type_tag = 7
591 __slots__ = ('strs',)
592
593 def __init__(self, strs):
594 # type: (List[str]) -> None
595 self.strs = strs
596
597 @staticmethod
598 def CreateNull(alloc_lists=False):
599 # type: () -> value.InternalStringArray
600 return value.InternalStringArray([] if alloc_lists else cast('List[str]', None))
601
602 def PrettyTree(self, do_abbrev, trav=None):
603 # type: (bool, Optional[TraversalState]) -> hnode_t
604 trav = trav or TraversalState()
605 heap_id = id(self)
606 if heap_id in trav.seen:
607 return hnode.AlreadySeen(heap_id)
608 trav.seen[heap_id] = True
609
610 out_node = NewRecord('value.InternalStringArray')
611 L = out_node.fields
612
613 if self.strs is not None: # List
614 x0 = hnode.Array([])
615 for i0 in self.strs:
616 x0.children.append(NewLeaf(i0, color_e.StringConst))
617 L.append(Field('strs', x0))
618
619 return out_node
620
621 class BashArray(value_t):
622 _type_tag = 8
623 __slots__ = ('d', 'max_index')
624
625 def __init__(self, d, max_index):
626 # type: (Dict[mops.BigInt, str], mops.BigInt) -> None
627 self.d = d
628 self.max_index = max_index
629
630 @staticmethod
631 def CreateNull(alloc_lists=False):
632 # type: () -> value.BashArray
633 return value.BashArray(cast('Dict[mops.BigInt, str]', None), mops.BigInt(-1))
634
635 def PrettyTree(self, do_abbrev, trav=None):
636 # type: (bool, 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
643 out_node = NewRecord('value.BashArray')
644 L = out_node.fields
645
646 if self.d is not None: # Dict
647 unnamed0 = [] # type: List[hnode_t]
648 x0 = hnode.Record("", "{", "}", [], unnamed0)
649 for k0, v0 in self.d.iteritems():
650 unnamed0.append(hnode.Leaf(mops.ToStr(k0), color_e.OtherConst))
651 unnamed0.append(NewLeaf(v0, color_e.StringConst))
652 L.append(Field('d', x0))
653
654 x1 = hnode.Leaf(mops.ToStr(self.max_index), color_e.OtherConst)
655 L.append(Field('max_index', x1))
656
657 return out_node
658
659 class BashAssoc(value_t):
660 _type_tag = 9
661 __slots__ = ('d',)
662
663 def __init__(self, d):
664 # type: (Dict[str, str]) -> None
665 self.d = d
666
667 @staticmethod
668 def CreateNull(alloc_lists=False):
669 # type: () -> value.BashAssoc
670 return value.BashAssoc(cast('Dict[str, str]', None))
671
672 def PrettyTree(self, do_abbrev, trav=None):
673 # type: (bool, Optional[TraversalState]) -> hnode_t
674 trav = trav or TraversalState()
675 heap_id = id(self)
676 if heap_id in trav.seen:
677 return hnode.AlreadySeen(heap_id)
678 trav.seen[heap_id] = True
679
680 out_node = NewRecord('value.BashAssoc')
681 L = out_node.fields
682
683 if self.d is not None: # Dict
684 unnamed0 = [] # type: List[hnode_t]
685 x0 = hnode.Record("", "{", "}", [], unnamed0)
686 for k0, v0 in self.d.iteritems():
687 unnamed0.append(NewLeaf(k0, color_e.StringConst))
688 unnamed0.append(NewLeaf(v0, color_e.StringConst))
689 L.append(Field('d', x0))
690
691 return out_node
692
693 Null = value__Null()
694
695 class Bool(value_t):
696 _type_tag = 11
697 __slots__ = ('b',)
698
699 def __init__(self, b):
700 # type: (bool) -> None
701 self.b = b
702
703 @staticmethod
704 def CreateNull(alloc_lists=False):
705 # type: () -> value.Bool
706 return value.Bool(False)
707
708 def PrettyTree(self, do_abbrev, trav=None):
709 # type: (bool, Optional[TraversalState]) -> hnode_t
710 trav = trav or TraversalState()
711 heap_id = id(self)
712 if heap_id in trav.seen:
713 return hnode.AlreadySeen(heap_id)
714 trav.seen[heap_id] = True
715
716 out_node = NewRecord('value.Bool')
717 L = out_node.fields
718
719 x0 = hnode.Leaf('T' if self.b else 'F', color_e.OtherConst)
720 L.append(Field('b', x0))
721
722 return out_node
723
724 class Int(value_t):
725 _type_tag = 12
726 __slots__ = ('i',)
727
728 def __init__(self, i):
729 # type: (mops.BigInt) -> None
730 self.i = i
731
732 @staticmethod
733 def CreateNull(alloc_lists=False):
734 # type: () -> value.Int
735 return value.Int(mops.BigInt(-1))
736
737 def PrettyTree(self, do_abbrev, trav=None):
738 # type: (bool, Optional[TraversalState]) -> hnode_t
739 trav = trav or TraversalState()
740 heap_id = id(self)
741 if heap_id in trav.seen:
742 return hnode.AlreadySeen(heap_id)
743 trav.seen[heap_id] = True
744
745 out_node = NewRecord('value.Int')
746 L = out_node.fields
747
748 x0 = hnode.Leaf(mops.ToStr(self.i), color_e.OtherConst)
749 L.append(Field('i', x0))
750
751 return out_node
752
753 class Float(value_t):
754 _type_tag = 13
755 __slots__ = ('f',)
756
757 def __init__(self, f):
758 # type: (float) -> None
759 self.f = f
760
761 @staticmethod
762 def CreateNull(alloc_lists=False):
763 # type: () -> value.Float
764 return value.Float(0.0)
765
766 def PrettyTree(self, do_abbrev, trav=None):
767 # type: (bool, Optional[TraversalState]) -> hnode_t
768 trav = trav or TraversalState()
769 heap_id = id(self)
770 if heap_id in trav.seen:
771 return hnode.AlreadySeen(heap_id)
772 trav.seen[heap_id] = True
773
774 out_node = NewRecord('value.Float')
775 L = out_node.fields
776
777 x0 = hnode.Leaf(str(self.f), color_e.OtherConst)
778 L.append(Field('f', x0))
779
780 return out_node
781
782 class List(value_t):
783 _type_tag = 14
784 __slots__ = ('items',)
785
786 def __init__(self, items):
787 # type: (List[value_t]) -> None
788 self.items = items
789
790 @staticmethod
791 def CreateNull(alloc_lists=False):
792 # type: () -> value.List
793 return value.List([] if alloc_lists else cast('List[value_t]', None))
794
795 def PrettyTree(self, do_abbrev, trav=None):
796 # type: (bool, Optional[TraversalState]) -> hnode_t
797 trav = trav or TraversalState()
798 heap_id = id(self)
799 if heap_id in trav.seen:
800 return hnode.AlreadySeen(heap_id)
801 trav.seen[heap_id] = True
802
803 out_node = NewRecord('value.List')
804 L = out_node.fields
805
806 if self.items is not None: # List
807 x0 = hnode.Array([])
808 for i0 in self.items:
809 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
810 i0.PrettyTree(do_abbrev, trav=trav))
811 x0.children.append(h)
812 L.append(Field('items', x0))
813
814 return out_node
815
816 class Dict(value_t):
817 _type_tag = 15
818 __slots__ = ('d',)
819
820 def __init__(self, d):
821 # type: (Dict[str, value_t]) -> None
822 self.d = d
823
824 @staticmethod
825 def CreateNull(alloc_lists=False):
826 # type: () -> value.Dict
827 return value.Dict(cast('Dict[str, value_t]', None))
828
829 def PrettyTree(self, do_abbrev, trav=None):
830 # type: (bool, Optional[TraversalState]) -> hnode_t
831 trav = trav or TraversalState()
832 heap_id = id(self)
833 if heap_id in trav.seen:
834 return hnode.AlreadySeen(heap_id)
835 trav.seen[heap_id] = True
836
837 out_node = NewRecord('value.Dict')
838 L = out_node.fields
839
840 if self.d is not None: # Dict
841 unnamed0 = [] # type: List[hnode_t]
842 x0 = hnode.Record("", "{", "}", [], unnamed0)
843 for k0, v0 in self.d.iteritems():
844 unnamed0.append(NewLeaf(k0, color_e.StringConst))
845 unnamed0.append(v0.PrettyTree(do_abbrev, trav=trav))
846 L.append(Field('d', x0))
847
848 return out_node
849
850 class Range(value_t):
851 _type_tag = 17
852 __slots__ = ('lower', 'upper')
853
854 def __init__(self, lower, upper):
855 # type: (int, int) -> None
856 self.lower = lower
857 self.upper = upper
858
859 @staticmethod
860 def CreateNull(alloc_lists=False):
861 # type: () -> value.Range
862 return value.Range(-1, -1)
863
864 def PrettyTree(self, do_abbrev, trav=None):
865 # type: (bool, Optional[TraversalState]) -> hnode_t
866 trav = trav or TraversalState()
867 heap_id = id(self)
868 if heap_id in trav.seen:
869 return hnode.AlreadySeen(heap_id)
870 trav.seen[heap_id] = True
871
872 out_node = NewRecord('value.Range')
873 L = out_node.fields
874
875 x0 = hnode.Leaf(str(self.lower), color_e.OtherConst)
876 L.append(Field('lower', x0))
877
878 x1 = hnode.Leaf(str(self.upper), color_e.OtherConst)
879 L.append(Field('upper', x1))
880
881 return out_node
882
883 class Eggex(value_t):
884 _type_tag = 18
885 __slots__ = ('spliced', 'canonical_flags', 'convert_funcs', 'convert_toks',
886 'as_ere', 'capture_names')
887
888 def __init__(self, spliced, canonical_flags, convert_funcs, convert_toks,
889 as_ere, capture_names):
890 # type: (re_t, str, List[Optional[value_t]], List[Optional[Token]], Optional[str], List[Optional[str]]) -> None
891 self.spliced = spliced
892 self.canonical_flags = canonical_flags
893 self.convert_funcs = convert_funcs
894 self.convert_toks = convert_toks
895 self.as_ere = as_ere
896 self.capture_names = capture_names
897
898 @staticmethod
899 def CreateNull(alloc_lists=False):
900 # type: () -> value.Eggex
901 return value.Eggex(cast('re_t', None), '', [] if alloc_lists else cast('List[Optional[value_t]]', None), [] if alloc_lists else cast('List[Optional[Token]]', None), cast('Optional[str]', None), [] if alloc_lists else cast('List[Optional[str]]', None))
902
903 def PrettyTree(self, do_abbrev, trav=None):
904 # type: (bool, Optional[TraversalState]) -> hnode_t
905 trav = trav or TraversalState()
906 heap_id = id(self)
907 if heap_id in trav.seen:
908 return hnode.AlreadySeen(heap_id)
909 trav.seen[heap_id] = True
910
911 out_node = NewRecord('value.Eggex')
912 L = out_node.fields
913
914 assert self.spliced is not None
915 x0 = self.spliced.PrettyTree(do_abbrev, trav=trav)
916 L.append(Field('spliced', x0))
917
918 x1 = NewLeaf(self.canonical_flags, color_e.StringConst)
919 L.append(Field('canonical_flags', x1))
920
921 if self.convert_funcs is not None: # List
922 x2 = hnode.Array([])
923 for i2 in self.convert_funcs:
924 h = (hnode.Leaf("_", color_e.OtherConst) if i2 is None else
925 i2.PrettyTree(do_abbrev, trav=trav))
926 x2.children.append(h)
927 L.append(Field('convert_funcs', x2))
928
929 if self.convert_toks is not None: # List
930 x3 = hnode.Array([])
931 for i3 in self.convert_toks:
932 h = (hnode.Leaf("_", color_e.OtherConst) if i3 is None else
933 i3.PrettyTree(do_abbrev, trav=trav))
934 x3.children.append(h)
935 L.append(Field('convert_toks', x3))
936
937 if self.as_ere is not None: # Optional
938 x4 = NewLeaf(self.as_ere, color_e.StringConst)
939 L.append(Field('as_ere', x4))
940
941 if self.capture_names is not None: # List
942 x5 = hnode.Array([])
943 for i5 in self.capture_names:
944 x5.children.append(NewLeaf(i5, color_e.StringConst))
945 L.append(Field('capture_names', x5))
946
947 return out_node
948
949 class Place(value_t):
950 _type_tag = 20
951 __slots__ = ('lval', 'frame')
952
953 def __init__(self, lval, frame):
954 # type: (y_lvalue_t, Dict[str, Cell]) -> None
955 self.lval = lval
956 self.frame = frame
957
958 @staticmethod
959 def CreateNull(alloc_lists=False):
960 # type: () -> value.Place
961 return value.Place(cast('y_lvalue_t', None), cast('Dict[str, Cell]', None))
962
963 def PrettyTree(self, do_abbrev, trav=None):
964 # type: (bool, Optional[TraversalState]) -> hnode_t
965 trav = trav or TraversalState()
966 heap_id = id(self)
967 if heap_id in trav.seen:
968 return hnode.AlreadySeen(heap_id)
969 trav.seen[heap_id] = True
970
971 out_node = NewRecord('value.Place')
972 L = out_node.fields
973
974 assert self.lval is not None
975 x0 = self.lval.PrettyTree(do_abbrev, trav=trav)
976 L.append(Field('lval', x0))
977
978 if self.frame is not None: # Dict
979 unnamed1 = [] # type: List[hnode_t]
980 x1 = hnode.Record("", "{", "}", [], unnamed1)
981 for k1, v1 in self.frame.iteritems():
982 unnamed1.append(NewLeaf(k1, color_e.StringConst))
983 unnamed1.append(v1.PrettyTree(do_abbrev, trav=trav))
984 L.append(Field('frame', x1))
985
986 return out_node
987
988 class Frame(value_t):
989 _type_tag = 21
990 __slots__ = ('frame',)
991
992 def __init__(self, frame):
993 # type: (Dict[str, Cell]) -> None
994 self.frame = frame
995
996 @staticmethod
997 def CreateNull(alloc_lists=False):
998 # type: () -> value.Frame
999 return value.Frame(cast('Dict[str, Cell]', None))
1000
1001 def PrettyTree(self, do_abbrev, trav=None):
1002 # type: (bool, Optional[TraversalState]) -> hnode_t
1003 trav = trav or TraversalState()
1004 heap_id = id(self)
1005 if heap_id in trav.seen:
1006 return hnode.AlreadySeen(heap_id)
1007 trav.seen[heap_id] = True
1008
1009 out_node = NewRecord('value.Frame')
1010 L = out_node.fields
1011
1012 if self.frame is not None: # Dict
1013 unnamed0 = [] # type: List[hnode_t]
1014 x0 = hnode.Record("", "{", "}", [], unnamed0)
1015 for k0, v0 in self.frame.iteritems():
1016 unnamed0.append(NewLeaf(k0, color_e.StringConst))
1017 unnamed0.append(v0.PrettyTree(do_abbrev, trav=trav))
1018 L.append(Field('frame', x0))
1019
1020 return out_node
1021
1022 class DebugFrame(value_t):
1023 _type_tag = 22
1024 __slots__ = ('frame',)
1025
1026 def __init__(self, frame):
1027 # type: (debug_frame_t) -> None
1028 self.frame = frame
1029
1030 @staticmethod
1031 def CreateNull(alloc_lists=False):
1032 # type: () -> value.DebugFrame
1033 return value.DebugFrame(cast('debug_frame_t', None))
1034
1035 def PrettyTree(self, do_abbrev, trav=None):
1036 # type: (bool, Optional[TraversalState]) -> hnode_t
1037 trav = trav or TraversalState()
1038 heap_id = id(self)
1039 if heap_id in trav.seen:
1040 return hnode.AlreadySeen(heap_id)
1041 trav.seen[heap_id] = True
1042
1043 out_node = NewRecord('value.DebugFrame')
1044 L = out_node.fields
1045
1046 assert self.frame is not None
1047 x0 = self.frame.PrettyTree(do_abbrev, trav=trav)
1048 L.append(Field('frame', x0))
1049
1050 return out_node
1051
1052 class BoundFunc(value_t):
1053 _type_tag = 23
1054 __slots__ = ('me', 'func')
1055
1056 def __init__(self, me, func):
1057 # type: (value_t, value_t) -> None
1058 self.me = me
1059 self.func = func
1060
1061 @staticmethod
1062 def CreateNull(alloc_lists=False):
1063 # type: () -> value.BoundFunc
1064 return value.BoundFunc(cast('value_t', None), cast('value_t', None))
1065
1066 def PrettyTree(self, do_abbrev, trav=None):
1067 # type: (bool, Optional[TraversalState]) -> hnode_t
1068 trav = trav or TraversalState()
1069 heap_id = id(self)
1070 if heap_id in trav.seen:
1071 return hnode.AlreadySeen(heap_id)
1072 trav.seen[heap_id] = True
1073
1074 out_node = NewRecord('value.BoundFunc')
1075 L = out_node.fields
1076
1077 assert self.me is not None
1078 x0 = self.me.PrettyTree(do_abbrev, trav=trav)
1079 L.append(Field('me', x0))
1080
1081 assert self.func is not None
1082 x1 = self.func.PrettyTree(do_abbrev, trav=trav)
1083 L.append(Field('func', x1))
1084
1085 return out_node
1086
1087 class BuiltinFunc(value_t):
1088 _type_tag = 24
1089 __slots__ = ('callable',)
1090
1091 def __init__(self, callable):
1092 # type: (Any) -> None
1093 self.callable = callable
1094
1095 @staticmethod
1096 def CreateNull(alloc_lists=False):
1097 # type: () -> value.BuiltinFunc
1098 return value.BuiltinFunc(cast('Any', None))
1099
1100 def PrettyTree(self, do_abbrev, trav=None):
1101 # type: (bool, Optional[TraversalState]) -> hnode_t
1102 trav = trav or TraversalState()
1103 heap_id = id(self)
1104 if heap_id in trav.seen:
1105 return hnode.AlreadySeen(heap_id)
1106 trav.seen[heap_id] = True
1107
1108 out_node = NewRecord('value.BuiltinFunc')
1109 L = out_node.fields
1110
1111 x0 = NewLeaf(str(self.callable), color_e.External)
1112 L.append(Field('callable', x0))
1113
1114 return out_node
1115
1116 class Func(value_t):
1117 _type_tag = 25
1118 __slots__ = ('name', 'parsed', 'pos_defaults', 'named_defaults',
1119 'captured_frame', 'module_frame')
1120
1121 def __init__(self, name, parsed, pos_defaults, named_defaults,
1122 captured_frame, module_frame):
1123 # type: (str, Func, List[value_t], Dict[str, value_t], Dict[str, Cell], Dict[str, Cell]) -> None
1124 self.name = name
1125 self.parsed = parsed
1126 self.pos_defaults = pos_defaults
1127 self.named_defaults = named_defaults
1128 self.captured_frame = captured_frame
1129 self.module_frame = module_frame
1130
1131 @staticmethod
1132 def CreateNull(alloc_lists=False):
1133 # type: () -> value.Func
1134 return value.Func('', cast('Func', None), [] if alloc_lists else cast('List[value_t]', None), cast('Dict[str, value_t]', None), cast('Dict[str, Cell]', None), cast('Dict[str, Cell]', None))
1135
1136 def PrettyTree(self, do_abbrev, trav=None):
1137 # type: (bool, Optional[TraversalState]) -> hnode_t
1138 trav = trav or TraversalState()
1139 heap_id = id(self)
1140 if heap_id in trav.seen:
1141 return hnode.AlreadySeen(heap_id)
1142 trav.seen[heap_id] = True
1143
1144 out_node = NewRecord('value.Func')
1145 L = out_node.fields
1146
1147 x0 = NewLeaf(self.name, color_e.StringConst)
1148 L.append(Field('name', x0))
1149
1150 assert self.parsed is not None
1151 x1 = self.parsed.PrettyTree(do_abbrev, trav=trav)
1152 L.append(Field('parsed', x1))
1153
1154 if self.pos_defaults is not None: # List
1155 x2 = hnode.Array([])
1156 for i2 in self.pos_defaults:
1157 h = (hnode.Leaf("_", color_e.OtherConst) if i2 is None else
1158 i2.PrettyTree(do_abbrev, trav=trav))
1159 x2.children.append(h)
1160 L.append(Field('pos_defaults', x2))
1161
1162 if self.named_defaults is not None: # Dict
1163 unnamed3 = [] # type: List[hnode_t]
1164 x3 = hnode.Record("", "{", "}", [], unnamed3)
1165 for k3, v3 in self.named_defaults.iteritems():
1166 unnamed3.append(NewLeaf(k3, color_e.StringConst))
1167 unnamed3.append(v3.PrettyTree(do_abbrev, trav=trav))
1168 L.append(Field('named_defaults', x3))
1169
1170 if self.captured_frame is not None: # Dict
1171 unnamed4 = [] # type: List[hnode_t]
1172 x4 = hnode.Record("", "{", "}", [], unnamed4)
1173 for k4, v4 in self.captured_frame.iteritems():
1174 unnamed4.append(NewLeaf(k4, color_e.StringConst))
1175 unnamed4.append(v4.PrettyTree(do_abbrev, trav=trav))
1176 L.append(Field('captured_frame', x4))
1177
1178 if self.module_frame is not None: # Dict
1179 unnamed5 = [] # type: List[hnode_t]
1180 x5 = hnode.Record("", "{", "}", [], unnamed5)
1181 for k5, v5 in self.module_frame.iteritems():
1182 unnamed5.append(NewLeaf(k5, color_e.StringConst))
1183 unnamed5.append(v5.PrettyTree(do_abbrev, trav=trav))
1184 L.append(Field('module_frame', x5))
1185
1186 return out_node
1187
1188 class BuiltinProc(value_t):
1189 _type_tag = 26
1190 __slots__ = ('builtin',)
1191
1192 def __init__(self, builtin):
1193 # type: (Any) -> None
1194 self.builtin = builtin
1195
1196 @staticmethod
1197 def CreateNull(alloc_lists=False):
1198 # type: () -> value.BuiltinProc
1199 return value.BuiltinProc(cast('Any', None))
1200
1201 def PrettyTree(self, do_abbrev, trav=None):
1202 # type: (bool, 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
1209 out_node = NewRecord('value.BuiltinProc')
1210 L = out_node.fields
1211
1212 x0 = NewLeaf(str(self.builtin), color_e.External)
1213 L.append(Field('builtin', x0))
1214
1215 return out_node
1216
1217 class Proc(value_t):
1218 _type_tag = 27
1219 __slots__ = ('name', 'name_tok', 'sig', 'body', 'defaults', 'sh_compat',
1220 'captured_frame', 'module_frame', 'code_str')
1221
1222 def __init__(self, name, name_tok, sig, body, defaults, sh_compat,
1223 captured_frame, module_frame, code_str):
1224 # type: (str, Token, proc_sig_t, command_t, Optional[ProcDefaults], bool, Dict[str, Cell], Dict[str, Cell], Optional[str]) -> None
1225 self.name = name
1226 self.name_tok = name_tok
1227 self.sig = sig
1228 self.body = body
1229 self.defaults = defaults
1230 self.sh_compat = sh_compat
1231 self.captured_frame = captured_frame
1232 self.module_frame = module_frame
1233 self.code_str = code_str
1234
1235 @staticmethod
1236 def CreateNull(alloc_lists=False):
1237 # type: () -> value.Proc
1238 return value.Proc('', cast('Token', None), cast('proc_sig_t', None), cast('command_t', None), cast('Optional[ProcDefaults]', None), False, cast('Dict[str, Cell]', None), cast('Dict[str, Cell]', None), cast('Optional[str]', None))
1239
1240 def PrettyTree(self, do_abbrev, trav=None):
1241 # type: (bool, Optional[TraversalState]) -> hnode_t
1242 trav = trav or TraversalState()
1243 heap_id = id(self)
1244 if heap_id in trav.seen:
1245 return hnode.AlreadySeen(heap_id)
1246 trav.seen[heap_id] = True
1247
1248 out_node = NewRecord('value.Proc')
1249 L = out_node.fields
1250
1251 x0 = NewLeaf(self.name, color_e.StringConst)
1252 L.append(Field('name', x0))
1253
1254 assert self.name_tok is not None
1255 x1 = self.name_tok.PrettyTree(do_abbrev, trav=trav)
1256 L.append(Field('name_tok', x1))
1257
1258 assert self.sig is not None
1259 x2 = self.sig.PrettyTree(do_abbrev, trav=trav)
1260 L.append(Field('sig', x2))
1261
1262 assert self.body is not None
1263 x3 = self.body.PrettyTree(do_abbrev, trav=trav)
1264 L.append(Field('body', x3))
1265
1266 if self.defaults is not None: # Optional
1267 x4 = self.defaults.PrettyTree(do_abbrev, trav=trav)
1268 L.append(Field('defaults', x4))
1269
1270 x5 = hnode.Leaf('T' if self.sh_compat else 'F', color_e.OtherConst)
1271 L.append(Field('sh_compat', x5))
1272
1273 if self.captured_frame is not None: # Dict
1274 unnamed6 = [] # type: List[hnode_t]
1275 x6 = hnode.Record("", "{", "}", [], unnamed6)
1276 for k6, v6 in self.captured_frame.iteritems():
1277 unnamed6.append(NewLeaf(k6, color_e.StringConst))
1278 unnamed6.append(v6.PrettyTree(do_abbrev, trav=trav))
1279 L.append(Field('captured_frame', x6))
1280
1281 if self.module_frame is not None: # Dict
1282 unnamed7 = [] # type: List[hnode_t]
1283 x7 = hnode.Record("", "{", "}", [], unnamed7)
1284 for k7, v7 in self.module_frame.iteritems():
1285 unnamed7.append(NewLeaf(k7, color_e.StringConst))
1286 unnamed7.append(v7.PrettyTree(do_abbrev, trav=trav))
1287 L.append(Field('module_frame', x7))
1288
1289 if self.code_str is not None: # Optional
1290 x8 = NewLeaf(self.code_str, color_e.StringConst)
1291 L.append(Field('code_str', x8))
1292
1293 return out_node
1294
1295 class Expr(value_t):
1296 _type_tag = 28
1297 __slots__ = ('e', 'captured_frame', 'module_frame')
1298
1299 def __init__(self, e, captured_frame, module_frame):
1300 # type: (expr_t, Dict[str, Cell], Dict[str, Cell]) -> None
1301 self.e = e
1302 self.captured_frame = captured_frame
1303 self.module_frame = module_frame
1304
1305 @staticmethod
1306 def CreateNull(alloc_lists=False):
1307 # type: () -> value.Expr
1308 return value.Expr(cast('expr_t', None), cast('Dict[str, Cell]', None), cast('Dict[str, Cell]', None))
1309
1310 def PrettyTree(self, do_abbrev, trav=None):
1311 # type: (bool, Optional[TraversalState]) -> hnode_t
1312 trav = trav or TraversalState()
1313 heap_id = id(self)
1314 if heap_id in trav.seen:
1315 return hnode.AlreadySeen(heap_id)
1316 trav.seen[heap_id] = True
1317
1318 out_node = NewRecord('value.Expr')
1319 L = out_node.fields
1320
1321 assert self.e is not None
1322 x0 = self.e.PrettyTree(do_abbrev, trav=trav)
1323 L.append(Field('e', x0))
1324
1325 if self.captured_frame is not None: # Dict
1326 unnamed1 = [] # type: List[hnode_t]
1327 x1 = hnode.Record("", "{", "}", [], unnamed1)
1328 for k1, v1 in self.captured_frame.iteritems():
1329 unnamed1.append(NewLeaf(k1, color_e.StringConst))
1330 unnamed1.append(v1.PrettyTree(do_abbrev, trav=trav))
1331 L.append(Field('captured_frame', x1))
1332
1333 if self.module_frame is not None: # Dict
1334 unnamed2 = [] # type: List[hnode_t]
1335 x2 = hnode.Record("", "{", "}", [], unnamed2)
1336 for k2, v2 in self.module_frame.iteritems():
1337 unnamed2.append(NewLeaf(k2, color_e.StringConst))
1338 unnamed2.append(v2.PrettyTree(do_abbrev, trav=trav))
1339 L.append(Field('module_frame', x2))
1340
1341 return out_node
1342
1343 class CommandFrag(value_t):
1344 _type_tag = 29
1345 __slots__ = ('c',)
1346
1347 def __init__(self, c):
1348 # type: (command_t) -> None
1349 self.c = c
1350
1351 @staticmethod
1352 def CreateNull(alloc_lists=False):
1353 # type: () -> value.CommandFrag
1354 return value.CommandFrag(cast('command_t', None))
1355
1356 def PrettyTree(self, do_abbrev, trav=None):
1357 # type: (bool, Optional[TraversalState]) -> hnode_t
1358 trav = trav or TraversalState()
1359 heap_id = id(self)
1360 if heap_id in trav.seen:
1361 return hnode.AlreadySeen(heap_id)
1362 trav.seen[heap_id] = True
1363
1364 out_node = NewRecord('value.CommandFrag')
1365 L = out_node.fields
1366
1367 assert self.c is not None
1368 x0 = self.c.PrettyTree(do_abbrev, trav=trav)
1369 L.append(Field('c', x0))
1370
1371 return out_node
1372
1373 class Command(value_t):
1374 _type_tag = 30
1375 __slots__ = ('frag', 'captured_frame', 'module_frame')
1376
1377 def __init__(self, frag, captured_frame, module_frame):
1378 # type: (cmd_frag_t, Dict[str, Cell], Dict[str, Cell]) -> None
1379 self.frag = frag
1380 self.captured_frame = captured_frame
1381 self.module_frame = module_frame
1382
1383 @staticmethod
1384 def CreateNull(alloc_lists=False):
1385 # type: () -> value.Command
1386 return value.Command(cast('cmd_frag_t', None), cast('Dict[str, Cell]', None), cast('Dict[str, Cell]', None))
1387
1388 def PrettyTree(self, do_abbrev, trav=None):
1389 # type: (bool, 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
1396 out_node = NewRecord('value.Command')
1397 L = out_node.fields
1398
1399 assert self.frag is not None
1400 x0 = self.frag.PrettyTree(do_abbrev, trav=trav)
1401 L.append(Field('frag', x0))
1402
1403 if self.captured_frame is not None: # Dict
1404 unnamed1 = [] # type: List[hnode_t]
1405 x1 = hnode.Record("", "{", "}", [], unnamed1)
1406 for k1, v1 in self.captured_frame.iteritems():
1407 unnamed1.append(NewLeaf(k1, color_e.StringConst))
1408 unnamed1.append(v1.PrettyTree(do_abbrev, trav=trav))
1409 L.append(Field('captured_frame', x1))
1410
1411 if self.module_frame is not None: # Dict
1412 unnamed2 = [] # type: List[hnode_t]
1413 x2 = hnode.Record("", "{", "}", [], unnamed2)
1414 for k2, v2 in self.module_frame.iteritems():
1415 unnamed2.append(NewLeaf(k2, color_e.StringConst))
1416 unnamed2.append(v2.PrettyTree(do_abbrev, trav=trav))
1417 L.append(Field('module_frame', x2))
1418
1419 return out_node
1420
1421 pass
1422
1423class IntBox(pybase.CompoundObj):
1424 _type_tag = 64
1425 __slots__ = ('i',)
1426
1427 def __init__(self, i):
1428 # type: (int) -> None
1429 self.i = i
1430
1431 @staticmethod
1432 def CreateNull(alloc_lists=False):
1433 # type: () -> IntBox
1434 return IntBox(-1)
1435
1436 def PrettyTree(self, do_abbrev, trav=None):
1437 # type: (bool, Optional[TraversalState]) -> hnode_t
1438 trav = trav or TraversalState()
1439 heap_id = id(self)
1440 if heap_id in trav.seen:
1441 return hnode.AlreadySeen(heap_id)
1442 trav.seen[heap_id] = True
1443
1444 out_node = NewRecord('IntBox')
1445 L = out_node.fields
1446
1447 x0 = hnode.Leaf(str(self.i), color_e.OtherConst)
1448 L.append(Field('i', x0))
1449
1450 return out_node
1451
1452class InitializerValue(pybase.CompoundObj):
1453 _type_tag = 65
1454 __slots__ = ('key', 'rval', 'plus_eq')
1455
1456 def __init__(self, key, rval, plus_eq):
1457 # type: (Optional[str], str, bool) -> None
1458 self.key = key
1459 self.rval = rval
1460 self.plus_eq = plus_eq
1461
1462 @staticmethod
1463 def CreateNull(alloc_lists=False):
1464 # type: () -> InitializerValue
1465 return InitializerValue(cast('Optional[str]', None), '', False)
1466
1467 def PrettyTree(self, do_abbrev, trav=None):
1468 # type: (bool, Optional[TraversalState]) -> hnode_t
1469 trav = trav or TraversalState()
1470 heap_id = id(self)
1471 if heap_id in trav.seen:
1472 return hnode.AlreadySeen(heap_id)
1473 trav.seen[heap_id] = True
1474
1475 out_node = NewRecord('InitializerValue')
1476 L = out_node.fields
1477
1478 if self.key is not None: # Optional
1479 x0 = NewLeaf(self.key, color_e.StringConst)
1480 L.append(Field('key', x0))
1481
1482 x1 = NewLeaf(self.rval, color_e.StringConst)
1483 L.append(Field('rval', x1))
1484
1485 x2 = hnode.Leaf('T' if self.plus_eq else 'F', color_e.OtherConst)
1486 L.append(Field('plus_eq', x2))
1487
1488 return out_node
1489
1490class ProcDefaults(pybase.CompoundObj):
1491 _type_tag = 66
1492 __slots__ = ('for_word', 'for_typed', 'for_named', 'for_block')
1493
1494 def __init__(self, for_word, for_typed, for_named, for_block):
1495 # type: (Optional[List[value_t]], Optional[List[value_t]], Optional[Dict[str, value_t]], Optional[value_t]) -> None
1496 self.for_word = for_word
1497 self.for_typed = for_typed
1498 self.for_named = for_named
1499 self.for_block = for_block
1500
1501 @staticmethod
1502 def CreateNull(alloc_lists=False):
1503 # type: () -> ProcDefaults
1504 return ProcDefaults(cast('Optional[List[value_t]]', None), cast('Optional[List[value_t]]', None), cast('Optional[Dict[str, value_t]]', None), cast('Optional[value_t]', None))
1505
1506 def PrettyTree(self, do_abbrev, trav=None):
1507 # type: (bool, Optional[TraversalState]) -> hnode_t
1508 trav = trav or TraversalState()
1509 heap_id = id(self)
1510 if heap_id in trav.seen:
1511 return hnode.AlreadySeen(heap_id)
1512 trav.seen[heap_id] = True
1513
1514 out_node = NewRecord('ProcDefaults')
1515 L = out_node.fields
1516
1517 if self.for_word is not None: # List
1518 x0 = hnode.Array([])
1519 for i0 in self.for_word:
1520 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
1521 i0.PrettyTree(do_abbrev, trav=trav))
1522 x0.children.append(h)
1523 L.append(Field('for_word', x0))
1524
1525 if self.for_typed is not None: # List
1526 x1 = hnode.Array([])
1527 for i1 in self.for_typed:
1528 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
1529 i1.PrettyTree(do_abbrev, trav=trav))
1530 x1.children.append(h)
1531 L.append(Field('for_typed', x1))
1532
1533 if self.for_named is not None: # Dict
1534 unnamed2 = [] # type: List[hnode_t]
1535 x2 = hnode.Record("", "{", "}", [], unnamed2)
1536 for k2, v2 in self.for_named.iteritems():
1537 unnamed2.append(NewLeaf(k2, color_e.StringConst))
1538 unnamed2.append(v2.PrettyTree(do_abbrev, trav=trav))
1539 L.append(Field('for_named', x2))
1540
1541 if self.for_block is not None: # Optional
1542 x3 = self.for_block.PrettyTree(do_abbrev, trav=trav)
1543 L.append(Field('for_block', x3))
1544
1545 return out_node
1546
1547class LeftName(y_lvalue_t, sh_lvalue_t):
1548 _type_tag = 67
1549 __slots__ = ('name', 'blame_loc')
1550
1551 def __init__(self, name, blame_loc):
1552 # type: (str, loc_t) -> None
1553 self.name = name
1554 self.blame_loc = blame_loc
1555
1556 @staticmethod
1557 def CreateNull(alloc_lists=False):
1558 # type: () -> LeftName
1559 return LeftName('', cast('loc_t', None))
1560
1561 def PrettyTree(self, do_abbrev, trav=None):
1562 # type: (bool, Optional[TraversalState]) -> hnode_t
1563 trav = trav or TraversalState()
1564 heap_id = id(self)
1565 if heap_id in trav.seen:
1566 return hnode.AlreadySeen(heap_id)
1567 trav.seen[heap_id] = True
1568
1569 out_node = NewRecord('LeftName')
1570 L = out_node.fields
1571
1572 x0 = NewLeaf(self.name, color_e.StringConst)
1573 L.append(Field('name', x0))
1574
1575 assert self.blame_loc is not None
1576 x1 = self.blame_loc.PrettyTree(do_abbrev, trav=trav)
1577 L.append(Field('blame_loc', x1))
1578
1579 return out_node
1580
1581class RegexMatch(regex_match_t, value_t):
1582 _type_tag = 68
1583 __slots__ = ('s', 'indices', 'ops')
1584
1585 def __init__(self, s, indices, ops):
1586 # type: (str, List[int], eggex_ops_t) -> None
1587 self.s = s
1588 self.indices = indices
1589 self.ops = ops
1590
1591 @staticmethod
1592 def CreateNull(alloc_lists=False):
1593 # type: () -> RegexMatch
1594 return RegexMatch('', [] if alloc_lists else cast('List[int]', None), cast('eggex_ops_t', None))
1595
1596 def PrettyTree(self, do_abbrev, trav=None):
1597 # type: (bool, Optional[TraversalState]) -> hnode_t
1598 trav = trav or TraversalState()
1599 heap_id = id(self)
1600 if heap_id in trav.seen:
1601 return hnode.AlreadySeen(heap_id)
1602 trav.seen[heap_id] = True
1603
1604 out_node = NewRecord('RegexMatch')
1605 L = out_node.fields
1606
1607 x0 = NewLeaf(self.s, color_e.StringConst)
1608 L.append(Field('s', x0))
1609
1610 if self.indices is not None: # List
1611 x1 = hnode.Array([])
1612 for i1 in self.indices:
1613 x1.children.append(hnode.Leaf(str(i1), color_e.OtherConst))
1614 L.append(Field('indices', x1))
1615
1616 assert self.ops is not None
1617 x2 = self.ops.PrettyTree(do_abbrev, trav=trav)
1618 L.append(Field('ops', x2))
1619
1620 return out_node
1621
1622class Obj(value_t):
1623 _type_tag = 69
1624 __slots__ = ('prototype', 'd')
1625
1626 def __init__(self, prototype, d):
1627 # type: (Optional[Obj], Dict[str, value_t]) -> None
1628 self.prototype = prototype
1629 self.d = d
1630
1631 @staticmethod
1632 def CreateNull(alloc_lists=False):
1633 # type: () -> Obj
1634 return Obj(cast('Optional[Obj]', None), cast('Dict[str, value_t]', None))
1635
1636 def PrettyTree(self, do_abbrev, trav=None):
1637 # type: (bool, Optional[TraversalState]) -> hnode_t
1638 trav = trav or TraversalState()
1639 heap_id = id(self)
1640 if heap_id in trav.seen:
1641 return hnode.AlreadySeen(heap_id)
1642 trav.seen[heap_id] = True
1643
1644 out_node = NewRecord('Obj')
1645 L = out_node.fields
1646
1647 if self.prototype is not None: # Optional
1648 x0 = self.prototype.PrettyTree(do_abbrev, trav=trav)
1649 L.append(Field('prototype', x0))
1650
1651 if self.d is not None: # Dict
1652 unnamed1 = [] # type: List[hnode_t]
1653 x1 = hnode.Record("", "{", "}", [], unnamed1)
1654 for k1, v1 in self.d.iteritems():
1655 unnamed1.append(NewLeaf(k1, color_e.StringConst))
1656 unnamed1.append(v1.PrettyTree(do_abbrev, trav=trav))
1657 L.append(Field('d', x1))
1658
1659 return out_node
1660