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

1402 lines, 1011 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.demo_lib_asdl import value_t
7
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 op_id_t(pybase.SimpleObj):
14 pass
15
16class op_id_e(object):
17 Plus = op_id_t(1)
18 Minus = op_id_t(2)
19 Star = op_id_t(3)
20
21_op_id_str = {
22 1: 'op_id.Plus',
23 2: 'op_id.Minus',
24 3: 'op_id.Star',
25}
26
27def op_id_str(val):
28 # type: (op_id_t) -> str
29 return _op_id_str[val]
30
31class cflow_e(object):
32 Break = 1
33 Continue = 2
34 Return = 3
35
36_cflow_str = {
37 1: 'Break',
38 2: 'Continue',
39 3: 'Return',
40}
41
42def cflow_str(tag, dot=True):
43 # type: (int, bool) -> str
44 v = _cflow_str[tag]
45 if dot:
46 return "cflow.%s" % v
47 else:
48 return v
49
50class cflow_t(pybase.CompoundObj):
51 def tag(self):
52 # type: () -> int
53 return self._type_tag
54 pass
55
56class cflow__Break(cflow_t):
57 _type_tag = 1
58 __slots__ = ()
59
60 def __init__(self, ):
61 # type: () -> None
62 pass
63
64 def PrettyTree(self, trav=None):
65 # type: (Optional[TraversalState]) -> hnode_t
66 trav = trav or TraversalState()
67 heap_id = id(self)
68 if heap_id in trav.seen:
69 return hnode.AlreadySeen(heap_id)
70 trav.seen[heap_id] = True
71 out_node = NewRecord('cflow__Break')
72 L = out_node.fields
73
74 return out_node
75
76 def _AbbreviatedTree(self, trav=None):
77 # type: (Optional[TraversalState]) -> hnode_t
78 trav = trav or TraversalState()
79 heap_id = id(self)
80 if heap_id in trav.seen:
81 return hnode.AlreadySeen(heap_id)
82 trav.seen[heap_id] = True
83 out_node = NewRecord('cflow__Break')
84 L = out_node.fields
85 return out_node
86
87 def AbbreviatedTree(self, trav=None):
88 # type: (Optional[TraversalState]) -> hnode_t
89 return self._AbbreviatedTree(trav=trav)
90
91class cflow__Continue(cflow_t):
92 _type_tag = 2
93 __slots__ = ()
94
95 def __init__(self, ):
96 # type: () -> None
97 pass
98
99 def PrettyTree(self, trav=None):
100 # type: (Optional[TraversalState]) -> hnode_t
101 trav = trav or TraversalState()
102 heap_id = id(self)
103 if heap_id in trav.seen:
104 return hnode.AlreadySeen(heap_id)
105 trav.seen[heap_id] = True
106 out_node = NewRecord('cflow__Continue')
107 L = out_node.fields
108
109 return out_node
110
111 def _AbbreviatedTree(self, trav=None):
112 # type: (Optional[TraversalState]) -> hnode_t
113 trav = trav or TraversalState()
114 heap_id = id(self)
115 if heap_id in trav.seen:
116 return hnode.AlreadySeen(heap_id)
117 trav.seen[heap_id] = True
118 out_node = NewRecord('cflow__Continue')
119 L = out_node.fields
120 return out_node
121
122 def AbbreviatedTree(self, trav=None):
123 # type: (Optional[TraversalState]) -> hnode_t
124 return self._AbbreviatedTree(trav=trav)
125
126class cflow(object):
127 Break = cflow__Break()
128
129 Continue = cflow__Continue()
130
131 class Return(cflow_t):
132 _type_tag = 3
133 __slots__ = ('status',)
134
135 def __init__(self, status):
136 # type: (int) -> None
137 self.status = status
138
139 @staticmethod
140 def CreateNull(alloc_lists=False):
141 # type: () -> cflow.Return
142 return cflow.Return(-1)
143
144 def PrettyTree(self, trav=None):
145 # type: (Optional[TraversalState]) -> hnode_t
146 trav = trav or TraversalState()
147 heap_id = id(self)
148 if heap_id in trav.seen:
149 return hnode.AlreadySeen(heap_id)
150 trav.seen[heap_id] = True
151 out_node = NewRecord('cflow.Return')
152 L = out_node.fields
153
154 x0 = hnode.Leaf(str(self.status), color_e.OtherConst)
155 L.append(Field('status', x0))
156
157 return out_node
158
159 def _AbbreviatedTree(self, trav=None):
160 # type: (Optional[TraversalState]) -> hnode_t
161 trav = trav or TraversalState()
162 heap_id = id(self)
163 if heap_id in trav.seen:
164 return hnode.AlreadySeen(heap_id)
165 trav.seen[heap_id] = True
166 out_node = NewRecord('cflow.Return')
167 L = out_node.fields
168 x0 = hnode.Leaf(str(self.status), color_e.OtherConst)
169 L.append(Field('status', x0))
170
171 return out_node
172
173 def AbbreviatedTree(self, trav=None):
174 # type: (Optional[TraversalState]) -> hnode_t
175 return self._AbbreviatedTree(trav=trav)
176
177 pass
178
179class bool_expr_e(object):
180 Binary = 1
181 Unary = 2
182 LogicalNot = 3
183 LogicalBinary = 4
184
185_bool_expr_str = {
186 1: 'Binary',
187 2: 'Unary',
188 3: 'LogicalNot',
189 4: 'LogicalBinary',
190}
191
192def bool_expr_str(tag, dot=True):
193 # type: (int, bool) -> str
194 v = _bool_expr_str[tag]
195 if dot:
196 return "bool_expr.%s" % v
197 else:
198 return v
199
200class bool_expr_t(pybase.CompoundObj):
201 def tag(self):
202 # type: () -> int
203 return self._type_tag
204 pass
205
206class bool_expr(object):
207 class Binary(bool_expr_t):
208 _type_tag = 1
209 __slots__ = ('left', 'right')
210
211 def __init__(self, left, right):
212 # type: (word, word) -> None
213 self.left = left
214 self.right = right
215
216 @staticmethod
217 def CreateNull(alloc_lists=False):
218 # type: () -> bool_expr.Binary
219 return bool_expr.Binary(cast(word, None), cast(word, None))
220
221 def PrettyTree(self, trav=None):
222 # type: (Optional[TraversalState]) -> hnode_t
223 trav = trav or TraversalState()
224 heap_id = id(self)
225 if heap_id in trav.seen:
226 return hnode.AlreadySeen(heap_id)
227 trav.seen[heap_id] = True
228 out_node = NewRecord('bool_expr.Binary')
229 L = out_node.fields
230
231 assert self.left is not None
232 x0 = self.left.PrettyTree(trav=trav)
233 L.append(Field('left', x0))
234
235 assert self.right is not None
236 x1 = self.right.PrettyTree(trav=trav)
237 L.append(Field('right', x1))
238
239 return out_node
240
241 def _AbbreviatedTree(self, trav=None):
242 # type: (Optional[TraversalState]) -> hnode_t
243 trav = trav or TraversalState()
244 heap_id = id(self)
245 if heap_id in trav.seen:
246 return hnode.AlreadySeen(heap_id)
247 trav.seen[heap_id] = True
248 out_node = NewRecord('bool_expr.Binary')
249 L = out_node.fields
250 assert self.left is not None
251 x0 = self.left.AbbreviatedTree(trav=trav)
252 L.append(Field('left', x0))
253
254 assert self.right is not None
255 x1 = self.right.AbbreviatedTree(trav=trav)
256 L.append(Field('right', x1))
257
258 return out_node
259
260 def AbbreviatedTree(self, trav=None):
261 # type: (Optional[TraversalState]) -> hnode_t
262 return self._AbbreviatedTree(trav=trav)
263
264 class Unary(bool_expr_t):
265 _type_tag = 2
266 __slots__ = ('child',)
267
268 def __init__(self, child):
269 # type: (word) -> None
270 self.child = child
271
272 @staticmethod
273 def CreateNull(alloc_lists=False):
274 # type: () -> bool_expr.Unary
275 return bool_expr.Unary(cast(word, None))
276
277 def PrettyTree(self, trav=None):
278 # type: (Optional[TraversalState]) -> hnode_t
279 trav = trav or TraversalState()
280 heap_id = id(self)
281 if heap_id in trav.seen:
282 return hnode.AlreadySeen(heap_id)
283 trav.seen[heap_id] = True
284 out_node = NewRecord('bool_expr.Unary')
285 L = out_node.fields
286
287 assert self.child is not None
288 x0 = self.child.PrettyTree(trav=trav)
289 L.append(Field('child', x0))
290
291 return out_node
292
293 def _AbbreviatedTree(self, trav=None):
294 # type: (Optional[TraversalState]) -> hnode_t
295 trav = trav or TraversalState()
296 heap_id = id(self)
297 if heap_id in trav.seen:
298 return hnode.AlreadySeen(heap_id)
299 trav.seen[heap_id] = True
300 out_node = NewRecord('bool_expr.Unary')
301 L = out_node.fields
302 assert self.child is not None
303 x0 = self.child.AbbreviatedTree(trav=trav)
304 L.append(Field('child', x0))
305
306 return out_node
307
308 def AbbreviatedTree(self, trav=None):
309 # type: (Optional[TraversalState]) -> hnode_t
310 return self._AbbreviatedTree(trav=trav)
311
312 class LogicalNot(bool_expr_t):
313 _type_tag = 3
314 __slots__ = ('b',)
315
316 def __init__(self, b):
317 # type: (bool_expr_t) -> None
318 self.b = b
319
320 @staticmethod
321 def CreateNull(alloc_lists=False):
322 # type: () -> bool_expr.LogicalNot
323 return bool_expr.LogicalNot(cast(bool_expr_t, None))
324
325 def PrettyTree(self, trav=None):
326 # type: (Optional[TraversalState]) -> hnode_t
327 trav = trav or TraversalState()
328 heap_id = id(self)
329 if heap_id in trav.seen:
330 return hnode.AlreadySeen(heap_id)
331 trav.seen[heap_id] = True
332 out_node = NewRecord('bool_expr.LogicalNot')
333 L = out_node.fields
334
335 assert self.b is not None
336 x0 = self.b.PrettyTree(trav=trav)
337 L.append(Field('b', x0))
338
339 return out_node
340
341 def _AbbreviatedTree(self, trav=None):
342 # type: (Optional[TraversalState]) -> hnode_t
343 trav = trav or TraversalState()
344 heap_id = id(self)
345 if heap_id in trav.seen:
346 return hnode.AlreadySeen(heap_id)
347 trav.seen[heap_id] = True
348 out_node = NewRecord('bool_expr.LogicalNot')
349 L = out_node.fields
350 assert self.b is not None
351 x0 = self.b.AbbreviatedTree(trav=trav)
352 L.append(Field('b', x0))
353
354 return out_node
355
356 def AbbreviatedTree(self, trav=None):
357 # type: (Optional[TraversalState]) -> hnode_t
358 return self._AbbreviatedTree(trav=trav)
359
360 class LogicalBinary(bool_expr_t):
361 _type_tag = 4
362 __slots__ = ('op', 'left', 'right')
363
364 def __init__(self, op, left, right):
365 # type: (op_id_t, bool_expr_t, bool_expr_t) -> None
366 self.op = op
367 self.left = left
368 self.right = right
369
370 @staticmethod
371 def CreateNull(alloc_lists=False):
372 # type: () -> bool_expr.LogicalBinary
373 return bool_expr.LogicalBinary(op_id_e.Plus, cast(bool_expr_t, None), cast(bool_expr_t, None))
374
375 def PrettyTree(self, trav=None):
376 # type: (Optional[TraversalState]) -> hnode_t
377 trav = trav or TraversalState()
378 heap_id = id(self)
379 if heap_id in trav.seen:
380 return hnode.AlreadySeen(heap_id)
381 trav.seen[heap_id] = True
382 out_node = NewRecord('bool_expr.LogicalBinary')
383 L = out_node.fields
384
385 x0 = hnode.Leaf(op_id_str(self.op), color_e.TypeName)
386 L.append(Field('op', x0))
387
388 assert self.left is not None
389 x1 = self.left.PrettyTree(trav=trav)
390 L.append(Field('left', x1))
391
392 assert self.right is not None
393 x2 = self.right.PrettyTree(trav=trav)
394 L.append(Field('right', x2))
395
396 return out_node
397
398 def _AbbreviatedTree(self, trav=None):
399 # type: (Optional[TraversalState]) -> hnode_t
400 trav = trav or TraversalState()
401 heap_id = id(self)
402 if heap_id in trav.seen:
403 return hnode.AlreadySeen(heap_id)
404 trav.seen[heap_id] = True
405 out_node = NewRecord('bool_expr.LogicalBinary')
406 L = out_node.fields
407 x0 = hnode.Leaf(op_id_str(self.op), color_e.TypeName)
408 L.append(Field('op', x0))
409
410 assert self.left is not None
411 x1 = self.left.AbbreviatedTree(trav=trav)
412 L.append(Field('left', x1))
413
414 assert self.right is not None
415 x2 = self.right.AbbreviatedTree(trav=trav)
416 L.append(Field('right', x2))
417
418 return out_node
419
420 def AbbreviatedTree(self, trav=None):
421 # type: (Optional[TraversalState]) -> hnode_t
422 return self._AbbreviatedTree(trav=trav)
423
424 pass
425
426class cflow2_e(object):
427 Break = 1
428 Continue = 2
429 Return = 3
430
431_cflow2_str = {
432 1: 'Break',
433 2: 'Continue',
434 3: 'Return',
435}
436
437def cflow2_str(tag, dot=True):
438 # type: (int, bool) -> str
439 v = _cflow2_str[tag]
440 if dot:
441 return "cflow2.%s" % v
442 else:
443 return v
444
445class cflow2_t(pybase.CompoundObj):
446 def tag(self):
447 # type: () -> int
448 return self._type_tag
449 pass
450
451class cflow2__Break(cflow2_t):
452 _type_tag = 1
453 __slots__ = ()
454
455 def __init__(self, ):
456 # type: () -> None
457 pass
458
459 def PrettyTree(self, trav=None):
460 # type: (Optional[TraversalState]) -> hnode_t
461 trav = trav or TraversalState()
462 heap_id = id(self)
463 if heap_id in trav.seen:
464 return hnode.AlreadySeen(heap_id)
465 trav.seen[heap_id] = True
466 out_node = NewRecord('cflow2__Break')
467 L = out_node.fields
468
469 return out_node
470
471 def _AbbreviatedTree(self, trav=None):
472 # type: (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 out_node = NewRecord('cflow2__Break')
479 L = out_node.fields
480 return out_node
481
482 def AbbreviatedTree(self, trav=None):
483 # type: (Optional[TraversalState]) -> hnode_t
484 return self._AbbreviatedTree(trav=trav)
485
486class cflow2__Continue(cflow2_t):
487 _type_tag = 2
488 __slots__ = ()
489
490 def __init__(self, ):
491 # type: () -> None
492 pass
493
494 def PrettyTree(self, trav=None):
495 # type: (Optional[TraversalState]) -> hnode_t
496 trav = trav or TraversalState()
497 heap_id = id(self)
498 if heap_id in trav.seen:
499 return hnode.AlreadySeen(heap_id)
500 trav.seen[heap_id] = True
501 out_node = NewRecord('cflow2__Continue')
502 L = out_node.fields
503
504 return out_node
505
506 def _AbbreviatedTree(self, trav=None):
507 # type: (Optional[TraversalState]) -> hnode_t
508 trav = trav or TraversalState()
509 heap_id = id(self)
510 if heap_id in trav.seen:
511 return hnode.AlreadySeen(heap_id)
512 trav.seen[heap_id] = True
513 out_node = NewRecord('cflow2__Continue')
514 L = out_node.fields
515 return out_node
516
517 def AbbreviatedTree(self, trav=None):
518 # type: (Optional[TraversalState]) -> hnode_t
519 return self._AbbreviatedTree(trav=trav)
520
521class cflow2(object):
522 Break = cflow2__Break()
523
524 Continue = cflow2__Continue()
525
526 class Return(cflow2_t):
527 _type_tag = 3
528 __slots__ = ('status',)
529
530 def __init__(self, status):
531 # type: (int) -> None
532 self.status = status
533
534 @staticmethod
535 def CreateNull(alloc_lists=False):
536 # type: () -> cflow2.Return
537 return cflow2.Return(-1)
538
539 def PrettyTree(self, trav=None):
540 # type: (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 out_node = NewRecord('cflow2.Return')
547 L = out_node.fields
548
549 x0 = hnode.Leaf(str(self.status), color_e.OtherConst)
550 L.append(Field('status', x0))
551
552 return out_node
553
554 def _AbbreviatedTree(self, trav=None):
555 # type: (Optional[TraversalState]) -> hnode_t
556 trav = trav or TraversalState()
557 heap_id = id(self)
558 if heap_id in trav.seen:
559 return hnode.AlreadySeen(heap_id)
560 trav.seen[heap_id] = True
561 out_node = NewRecord('cflow2.Return')
562 L = out_node.fields
563 x0 = hnode.Leaf(str(self.status), color_e.OtherConst)
564 L.append(Field('status', x0))
565
566 return out_node
567
568 def AbbreviatedTree(self, trav=None):
569 # type: (Optional[TraversalState]) -> hnode_t
570 return self._AbbreviatedTree(trav=trav)
571
572 pass
573
574class flag_type_e(object):
575 Bool = 1
576 Int = 2
577 Float = 3
578 Str = 4
579 Enum = 5
580
581_flag_type_str = {
582 1: 'Bool',
583 2: 'Int',
584 3: 'Float',
585 4: 'Str',
586 5: 'Enum',
587}
588
589def flag_type_str(tag, dot=True):
590 # type: (int, bool) -> str
591 v = _flag_type_str[tag]
592 if dot:
593 return "flag_type.%s" % v
594 else:
595 return v
596
597class flag_type_t(pybase.CompoundObj):
598 def tag(self):
599 # type: () -> int
600 return self._type_tag
601 pass
602
603class flag_type__Bool(flag_type_t):
604 _type_tag = 1
605 __slots__ = ()
606
607 def __init__(self, ):
608 # type: () -> None
609 pass
610
611 def PrettyTree(self, trav=None):
612 # type: (Optional[TraversalState]) -> hnode_t
613 trav = trav or TraversalState()
614 heap_id = id(self)
615 if heap_id in trav.seen:
616 return hnode.AlreadySeen(heap_id)
617 trav.seen[heap_id] = True
618 out_node = NewRecord('flag_type__Bool')
619 L = out_node.fields
620
621 return out_node
622
623 def _AbbreviatedTree(self, trav=None):
624 # type: (Optional[TraversalState]) -> hnode_t
625 trav = trav or TraversalState()
626 heap_id = id(self)
627 if heap_id in trav.seen:
628 return hnode.AlreadySeen(heap_id)
629 trav.seen[heap_id] = True
630 out_node = NewRecord('flag_type__Bool')
631 L = out_node.fields
632 return out_node
633
634 def AbbreviatedTree(self, trav=None):
635 # type: (Optional[TraversalState]) -> hnode_t
636 return self._AbbreviatedTree(trav=trav)
637
638class flag_type__Int(flag_type_t):
639 _type_tag = 2
640 __slots__ = ()
641
642 def __init__(self, ):
643 # type: () -> None
644 pass
645
646 def PrettyTree(self, trav=None):
647 # type: (Optional[TraversalState]) -> hnode_t
648 trav = trav or TraversalState()
649 heap_id = id(self)
650 if heap_id in trav.seen:
651 return hnode.AlreadySeen(heap_id)
652 trav.seen[heap_id] = True
653 out_node = NewRecord('flag_type__Int')
654 L = out_node.fields
655
656 return out_node
657
658 def _AbbreviatedTree(self, trav=None):
659 # type: (Optional[TraversalState]) -> hnode_t
660 trav = trav or TraversalState()
661 heap_id = id(self)
662 if heap_id in trav.seen:
663 return hnode.AlreadySeen(heap_id)
664 trav.seen[heap_id] = True
665 out_node = NewRecord('flag_type__Int')
666 L = out_node.fields
667 return out_node
668
669 def AbbreviatedTree(self, trav=None):
670 # type: (Optional[TraversalState]) -> hnode_t
671 return self._AbbreviatedTree(trav=trav)
672
673class flag_type__Float(flag_type_t):
674 _type_tag = 3
675 __slots__ = ()
676
677 def __init__(self, ):
678 # type: () -> None
679 pass
680
681 def PrettyTree(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('flag_type__Float')
689 L = out_node.fields
690
691 return out_node
692
693 def _AbbreviatedTree(self, trav=None):
694 # type: (Optional[TraversalState]) -> hnode_t
695 trav = trav or TraversalState()
696 heap_id = id(self)
697 if heap_id in trav.seen:
698 return hnode.AlreadySeen(heap_id)
699 trav.seen[heap_id] = True
700 out_node = NewRecord('flag_type__Float')
701 L = out_node.fields
702 return out_node
703
704 def AbbreviatedTree(self, trav=None):
705 # type: (Optional[TraversalState]) -> hnode_t
706 return self._AbbreviatedTree(trav=trav)
707
708class flag_type__Str(flag_type_t):
709 _type_tag = 4
710 __slots__ = ()
711
712 def __init__(self, ):
713 # type: () -> None
714 pass
715
716 def PrettyTree(self, trav=None):
717 # type: (Optional[TraversalState]) -> hnode_t
718 trav = trav or TraversalState()
719 heap_id = id(self)
720 if heap_id in trav.seen:
721 return hnode.AlreadySeen(heap_id)
722 trav.seen[heap_id] = True
723 out_node = NewRecord('flag_type__Str')
724 L = out_node.fields
725
726 return out_node
727
728 def _AbbreviatedTree(self, trav=None):
729 # type: (Optional[TraversalState]) -> hnode_t
730 trav = trav or TraversalState()
731 heap_id = id(self)
732 if heap_id in trav.seen:
733 return hnode.AlreadySeen(heap_id)
734 trav.seen[heap_id] = True
735 out_node = NewRecord('flag_type__Str')
736 L = out_node.fields
737 return out_node
738
739 def AbbreviatedTree(self, trav=None):
740 # type: (Optional[TraversalState]) -> hnode_t
741 return self._AbbreviatedTree(trav=trav)
742
743class flag_type(object):
744 Bool = flag_type__Bool()
745
746 Int = flag_type__Int()
747
748 Float = flag_type__Float()
749
750 Str = flag_type__Str()
751
752 class Enum(flag_type_t):
753 _type_tag = 5
754 __slots__ = ('alts',)
755
756 def __init__(self, alts):
757 # type: (List[str]) -> None
758 self.alts = alts
759
760 @staticmethod
761 def CreateNull(alloc_lists=False):
762 # type: () -> flag_type.Enum
763 return flag_type.Enum([] if alloc_lists else cast('List[str]', None))
764
765 def PrettyTree(self, trav=None):
766 # type: (Optional[TraversalState]) -> hnode_t
767 trav = trav or TraversalState()
768 heap_id = id(self)
769 if heap_id in trav.seen:
770 return hnode.AlreadySeen(heap_id)
771 trav.seen[heap_id] = True
772 out_node = NewRecord('flag_type.Enum')
773 L = out_node.fields
774
775 if self.alts is not None: # List
776 x0 = hnode.Array([])
777 for i0 in self.alts:
778 x0.children.append(NewLeaf(i0, color_e.StringConst))
779 L.append(Field('alts', x0))
780
781 return out_node
782
783 def _AbbreviatedTree(self, trav=None):
784 # type: (Optional[TraversalState]) -> hnode_t
785 trav = trav or TraversalState()
786 heap_id = id(self)
787 if heap_id in trav.seen:
788 return hnode.AlreadySeen(heap_id)
789 trav.seen[heap_id] = True
790 out_node = NewRecord('flag_type.Enum')
791 L = out_node.fields
792 if self.alts is not None: # List
793 x0 = hnode.Array([])
794 for i0 in self.alts:
795 x0.children.append(NewLeaf(i0, color_e.StringConst))
796 L.append(Field('alts', x0))
797
798 return out_node
799
800 def AbbreviatedTree(self, trav=None):
801 # type: (Optional[TraversalState]) -> hnode_t
802 return self._AbbreviatedTree(trav=trav)
803
804 pass
805
806class op_array(pybase.CompoundObj):
807 _type_tag = 64
808 __slots__ = ('ops',)
809
810 def __init__(self, ops):
811 # type: (List[op_id_t]) -> None
812 self.ops = ops
813
814 @staticmethod
815 def CreateNull(alloc_lists=False):
816 # type: () -> op_array
817 return op_array([] if alloc_lists else cast('List[op_id_t]', None))
818
819 def PrettyTree(self, trav=None):
820 # type: (Optional[TraversalState]) -> hnode_t
821 trav = trav or TraversalState()
822 heap_id = id(self)
823 if heap_id in trav.seen:
824 return hnode.AlreadySeen(heap_id)
825 trav.seen[heap_id] = True
826 out_node = NewRecord('op_array')
827 L = out_node.fields
828
829 if self.ops is not None: # List
830 x0 = hnode.Array([])
831 for i0 in self.ops:
832 x0.children.append(hnode.Leaf(op_id_str(i0), color_e.TypeName))
833 L.append(Field('ops', x0))
834
835 return out_node
836
837 def _AbbreviatedTree(self, trav=None):
838 # type: (Optional[TraversalState]) -> hnode_t
839 trav = trav or TraversalState()
840 heap_id = id(self)
841 if heap_id in trav.seen:
842 return hnode.AlreadySeen(heap_id)
843 trav.seen[heap_id] = True
844 out_node = NewRecord('op_array')
845 L = out_node.fields
846 if self.ops is not None: # List
847 x0 = hnode.Array([])
848 for i0 in self.ops:
849 x0.children.append(hnode.Leaf(op_id_str(i0), color_e.TypeName))
850 L.append(Field('ops', x0))
851
852 return out_node
853
854 def AbbreviatedTree(self, trav=None):
855 # type: (Optional[TraversalState]) -> hnode_t
856 return self._AbbreviatedTree(trav=trav)
857
858class assign(pybase.CompoundObj):
859 _type_tag = 65
860 __slots__ = ('name', 'flags')
861
862 def __init__(self, name, flags):
863 # type: (str, List[str]) -> None
864 self.name = name
865 self.flags = flags
866
867 @staticmethod
868 def CreateNull(alloc_lists=False):
869 # type: () -> assign
870 return assign('', [] if alloc_lists else cast('List[str]', None))
871
872 def PrettyTree(self, trav=None):
873 # type: (Optional[TraversalState]) -> hnode_t
874 trav = trav or TraversalState()
875 heap_id = id(self)
876 if heap_id in trav.seen:
877 return hnode.AlreadySeen(heap_id)
878 trav.seen[heap_id] = True
879 out_node = NewRecord('assign')
880 L = out_node.fields
881
882 x0 = NewLeaf(self.name, color_e.StringConst)
883 L.append(Field('name', x0))
884
885 if self.flags is not None: # List
886 x1 = hnode.Array([])
887 for i1 in self.flags:
888 x1.children.append(NewLeaf(i1, color_e.StringConst))
889 L.append(Field('flags', x1))
890
891 return out_node
892
893 def _AbbreviatedTree(self, trav=None):
894 # type: (Optional[TraversalState]) -> hnode_t
895 trav = trav or TraversalState()
896 heap_id = id(self)
897 if heap_id in trav.seen:
898 return hnode.AlreadySeen(heap_id)
899 trav.seen[heap_id] = True
900 out_node = NewRecord('assign')
901 L = out_node.fields
902 x0 = NewLeaf(self.name, color_e.StringConst)
903 L.append(Field('name', x0))
904
905 if self.flags is not None: # List
906 x1 = hnode.Array([])
907 for i1 in self.flags:
908 x1.children.append(NewLeaf(i1, color_e.StringConst))
909 L.append(Field('flags', x1))
910
911 return out_node
912
913 def AbbreviatedTree(self, trav=None):
914 # type: (Optional[TraversalState]) -> hnode_t
915 return self._AbbreviatedTree(trav=trav)
916
917class source_location(pybase.CompoundObj):
918 _type_tag = 66
919 __slots__ = ('path', 'line', 'col', 'length')
920
921 def __init__(self, path, line, col, length):
922 # type: (str, int, int, int) -> None
923 self.path = path
924 self.line = line
925 self.col = col
926 self.length = length
927
928 @staticmethod
929 def CreateNull(alloc_lists=False):
930 # type: () -> source_location
931 return source_location('', -1, -1, -1)
932
933 def PrettyTree(self, trav=None):
934 # type: (Optional[TraversalState]) -> hnode_t
935 trav = trav or TraversalState()
936 heap_id = id(self)
937 if heap_id in trav.seen:
938 return hnode.AlreadySeen(heap_id)
939 trav.seen[heap_id] = True
940 out_node = NewRecord('source_location')
941 L = out_node.fields
942
943 x0 = NewLeaf(self.path, color_e.StringConst)
944 L.append(Field('path', x0))
945
946 x1 = hnode.Leaf(str(self.line), color_e.OtherConst)
947 L.append(Field('line', x1))
948
949 x2 = hnode.Leaf(str(self.col), color_e.OtherConst)
950 L.append(Field('col', x2))
951
952 x3 = hnode.Leaf(str(self.length), color_e.OtherConst)
953 L.append(Field('length', x3))
954
955 return out_node
956
957 def _AbbreviatedTree(self, trav=None):
958 # type: (Optional[TraversalState]) -> hnode_t
959 trav = trav or TraversalState()
960 heap_id = id(self)
961 if heap_id in trav.seen:
962 return hnode.AlreadySeen(heap_id)
963 trav.seen[heap_id] = True
964 out_node = NewRecord('source_location')
965 L = out_node.fields
966 x0 = NewLeaf(self.path, color_e.StringConst)
967 L.append(Field('path', x0))
968
969 x1 = hnode.Leaf(str(self.line), color_e.OtherConst)
970 L.append(Field('line', x1))
971
972 x2 = hnode.Leaf(str(self.col), color_e.OtherConst)
973 L.append(Field('col', x2))
974
975 x3 = hnode.Leaf(str(self.length), color_e.OtherConst)
976 L.append(Field('length', x3))
977
978 return out_node
979
980 def AbbreviatedTree(self, trav=None):
981 # type: (Optional[TraversalState]) -> hnode_t
982 return self._AbbreviatedTree(trav=trav)
983
984class word(pybase.CompoundObj):
985 _type_tag = 67
986 __slots__ = ('value',)
987
988 def __init__(self, value):
989 # type: (str) -> None
990 self.value = value
991
992 @staticmethod
993 def CreateNull(alloc_lists=False):
994 # type: () -> word
995 return word('')
996
997 def PrettyTree(self, trav=None):
998 # type: (Optional[TraversalState]) -> hnode_t
999 trav = trav or TraversalState()
1000 heap_id = id(self)
1001 if heap_id in trav.seen:
1002 return hnode.AlreadySeen(heap_id)
1003 trav.seen[heap_id] = True
1004 out_node = NewRecord('word')
1005 L = out_node.fields
1006
1007 x0 = NewLeaf(self.value, color_e.StringConst)
1008 L.append(Field('value', x0))
1009
1010 return out_node
1011
1012 def _AbbreviatedTree(self, trav=None):
1013 # type: (Optional[TraversalState]) -> hnode_t
1014 trav = trav or TraversalState()
1015 heap_id = id(self)
1016 if heap_id in trav.seen:
1017 return hnode.AlreadySeen(heap_id)
1018 trav.seen[heap_id] = True
1019 out_node = NewRecord('word')
1020 L = out_node.fields
1021 x0 = NewLeaf(self.value, color_e.StringConst)
1022 L.append(Field('value', x0))
1023
1024 return out_node
1025
1026 def AbbreviatedTree(self, trav=None):
1027 # type: (Optional[TraversalState]) -> hnode_t
1028 return self._AbbreviatedTree(trav=trav)
1029
1030class Token(pybase.CompoundObj):
1031 _type_tag = 68
1032 __slots__ = ('s', 'b')
1033
1034 def __init__(self, s, b):
1035 # type: (str, bool) -> None
1036 self.s = s
1037 self.b = b
1038
1039 @staticmethod
1040 def CreateNull(alloc_lists=False):
1041 # type: () -> Token
1042 return Token('', False)
1043
1044 def PrettyTree(self, trav=None):
1045 # type: (Optional[TraversalState]) -> hnode_t
1046 trav = trav or TraversalState()
1047 heap_id = id(self)
1048 if heap_id in trav.seen:
1049 return hnode.AlreadySeen(heap_id)
1050 trav.seen[heap_id] = True
1051 out_node = NewRecord('Token')
1052 L = out_node.fields
1053
1054 x0 = NewLeaf(self.s, color_e.StringConst)
1055 L.append(Field('s', x0))
1056
1057 x1 = hnode.Leaf('T' if self.b else 'F', color_e.OtherConst)
1058 L.append(Field('b', x1))
1059
1060 return out_node
1061
1062 def _AbbreviatedTree(self, trav=None):
1063 # type: (Optional[TraversalState]) -> hnode_t
1064 trav = trav or TraversalState()
1065 heap_id = id(self)
1066 if heap_id in trav.seen:
1067 return hnode.AlreadySeen(heap_id)
1068 trav.seen[heap_id] = True
1069 out_node = NewRecord('Token')
1070 L = out_node.fields
1071 x0 = NewLeaf(self.s, color_e.StringConst)
1072 L.append(Field('s', x0))
1073
1074 x1 = hnode.Leaf('T' if self.b else 'F', color_e.OtherConst)
1075 L.append(Field('b', x1))
1076
1077 return out_node
1078
1079 def AbbreviatedTree(self, trav=None):
1080 # type: (Optional[TraversalState]) -> hnode_t
1081 return self._AbbreviatedTree(trav=trav)
1082
1083class Dicts(pybase.CompoundObj):
1084 _type_tag = 69
1085 __slots__ = ('ss', 'ib', 'tokens')
1086
1087 def __init__(self, ss, ib, tokens):
1088 # type: (Dict[str, str], Dict[int, bool], Dict[str, Token]) -> None
1089 self.ss = ss
1090 self.ib = ib
1091 self.tokens = tokens
1092
1093 @staticmethod
1094 def CreateNull(alloc_lists=False):
1095 # type: () -> Dicts
1096 return Dicts(cast('Dict[str, str]', None), cast('Dict[int, bool]', None), cast('Dict[str, Token]', None))
1097
1098 def PrettyTree(self, trav=None):
1099 # type: (Optional[TraversalState]) -> hnode_t
1100 trav = trav or TraversalState()
1101 heap_id = id(self)
1102 if heap_id in trav.seen:
1103 return hnode.AlreadySeen(heap_id)
1104 trav.seen[heap_id] = True
1105 out_node = NewRecord('Dicts')
1106 L = out_node.fields
1107
1108 if self.ss is not None: # Dict
1109 m = hnode.Leaf("Dict", color_e.OtherConst)
1110 x0 = hnode.Array([m])
1111 for k0, v0 in self.ss.iteritems():
1112 x0.children.append(NewLeaf(k0, color_e.StringConst))
1113 x0.children.append(NewLeaf(v0, color_e.StringConst))
1114 L.append(Field('ss', x0))
1115
1116 if self.ib is not None: # Dict
1117 m = hnode.Leaf("Dict", color_e.OtherConst)
1118 x1 = hnode.Array([m])
1119 for k1, v1 in self.ib.iteritems():
1120 x1.children.append(hnode.Leaf(str(k1), color_e.OtherConst))
1121 x1.children.append(hnode.Leaf('T' if v1 else 'F', color_e.OtherConst))
1122 L.append(Field('ib', x1))
1123
1124 if self.tokens is not None: # Dict
1125 m = hnode.Leaf("Dict", color_e.OtherConst)
1126 x2 = hnode.Array([m])
1127 for k2, v2 in self.tokens.iteritems():
1128 x2.children.append(NewLeaf(k2, color_e.StringConst))
1129 x2.children.append(v2.PrettyTree(trav=trav))
1130 L.append(Field('tokens', x2))
1131
1132 return out_node
1133
1134 def _AbbreviatedTree(self, trav=None):
1135 # type: (Optional[TraversalState]) -> hnode_t
1136 trav = trav or TraversalState()
1137 heap_id = id(self)
1138 if heap_id in trav.seen:
1139 return hnode.AlreadySeen(heap_id)
1140 trav.seen[heap_id] = True
1141 out_node = NewRecord('Dicts')
1142 L = out_node.fields
1143 if self.ss is not None: # Dict
1144 m = hnode.Leaf("Dict", color_e.OtherConst)
1145 x0 = hnode.Array([m])
1146 for k0, v0 in self.ss.iteritems():
1147 x0.children.append(NewLeaf(k0, color_e.StringConst))
1148 x0.children.append(NewLeaf(v0, color_e.StringConst))
1149 L.append(Field('ss', x0))
1150
1151 if self.ib is not None: # Dict
1152 m = hnode.Leaf("Dict", color_e.OtherConst)
1153 x1 = hnode.Array([m])
1154 for k1, v1 in self.ib.iteritems():
1155 x1.children.append(hnode.Leaf(str(k1), color_e.OtherConst))
1156 x1.children.append(hnode.Leaf('T' if v1 else 'F', color_e.OtherConst))
1157 L.append(Field('ib', x1))
1158
1159 if self.tokens is not None: # Dict
1160 m = hnode.Leaf("Dict", color_e.OtherConst)
1161 x2 = hnode.Array([m])
1162 for k2, v2 in self.tokens.iteritems():
1163 x2.children.append(NewLeaf(k2, color_e.StringConst))
1164 x2.children.append(v2.AbbreviatedTree(trav=trav))
1165 L.append(Field('tokens', x2))
1166
1167 return out_node
1168
1169 def AbbreviatedTree(self, trav=None):
1170 # type: (Optional[TraversalState]) -> hnode_t
1171 return self._AbbreviatedTree(trav=trav)
1172
1173class SetToArg_(pybase.CompoundObj):
1174 _type_tag = 70
1175 __slots__ = ('name', 'flag_type', 'quit_parsing_flags')
1176
1177 def __init__(self, name, flag_type, quit_parsing_flags):
1178 # type: (str, flag_type_t, bool) -> None
1179 self.name = name
1180 self.flag_type = flag_type
1181 self.quit_parsing_flags = quit_parsing_flags
1182
1183 @staticmethod
1184 def CreateNull(alloc_lists=False):
1185 # type: () -> SetToArg_
1186 return SetToArg_('', cast(flag_type_t, None), False)
1187
1188 def PrettyTree(self, trav=None):
1189 # type: (Optional[TraversalState]) -> hnode_t
1190 trav = trav or TraversalState()
1191 heap_id = id(self)
1192 if heap_id in trav.seen:
1193 return hnode.AlreadySeen(heap_id)
1194 trav.seen[heap_id] = True
1195 out_node = NewRecord('SetToArg_')
1196 L = out_node.fields
1197
1198 x0 = NewLeaf(self.name, color_e.StringConst)
1199 L.append(Field('name', x0))
1200
1201 assert self.flag_type is not None
1202 x1 = self.flag_type.PrettyTree(trav=trav)
1203 L.append(Field('flag_type', x1))
1204
1205 x2 = hnode.Leaf('T' if self.quit_parsing_flags else 'F', color_e.OtherConst)
1206 L.append(Field('quit_parsing_flags', x2))
1207
1208 return out_node
1209
1210 def _AbbreviatedTree(self, trav=None):
1211 # type: (Optional[TraversalState]) -> hnode_t
1212 trav = trav or TraversalState()
1213 heap_id = id(self)
1214 if heap_id in trav.seen:
1215 return hnode.AlreadySeen(heap_id)
1216 trav.seen[heap_id] = True
1217 out_node = NewRecord('SetToArg_')
1218 L = out_node.fields
1219 x0 = NewLeaf(self.name, color_e.StringConst)
1220 L.append(Field('name', x0))
1221
1222 assert self.flag_type is not None
1223 x1 = self.flag_type.AbbreviatedTree(trav=trav)
1224 L.append(Field('flag_type', x1))
1225
1226 x2 = hnode.Leaf('T' if self.quit_parsing_flags else 'F', color_e.OtherConst)
1227 L.append(Field('quit_parsing_flags', x2))
1228
1229 return out_node
1230
1231 def AbbreviatedTree(self, trav=None):
1232 # type: (Optional[TraversalState]) -> hnode_t
1233 return self._AbbreviatedTree(trav=trav)
1234
1235class Strings(pybase.CompoundObj):
1236 _type_tag = 71
1237 __slots__ = ('required', 'optional')
1238
1239 def __init__(self, required, optional):
1240 # type: (str, Optional[str]) -> None
1241 self.required = required
1242 self.optional = optional
1243
1244 @staticmethod
1245 def CreateNull(alloc_lists=False):
1246 # type: () -> Strings
1247 return Strings('', cast('Optional[str]', None))
1248
1249 def PrettyTree(self, trav=None):
1250 # type: (Optional[TraversalState]) -> hnode_t
1251 trav = trav or TraversalState()
1252 heap_id = id(self)
1253 if heap_id in trav.seen:
1254 return hnode.AlreadySeen(heap_id)
1255 trav.seen[heap_id] = True
1256 out_node = NewRecord('Strings')
1257 L = out_node.fields
1258
1259 x0 = NewLeaf(self.required, color_e.StringConst)
1260 L.append(Field('required', x0))
1261
1262 if self.optional is not None: # Optional
1263 x1 = NewLeaf(self.optional, color_e.StringConst)
1264 L.append(Field('optional', x1))
1265
1266 return out_node
1267
1268 def _AbbreviatedTree(self, trav=None):
1269 # type: (Optional[TraversalState]) -> hnode_t
1270 trav = trav or TraversalState()
1271 heap_id = id(self)
1272 if heap_id in trav.seen:
1273 return hnode.AlreadySeen(heap_id)
1274 trav.seen[heap_id] = True
1275 out_node = NewRecord('Strings')
1276 L = out_node.fields
1277 x0 = NewLeaf(self.required, color_e.StringConst)
1278 L.append(Field('required', x0))
1279
1280 if self.optional is not None: # Optional
1281 x1 = NewLeaf(self.optional, color_e.StringConst)
1282 L.append(Field('optional', x1))
1283
1284 return out_node
1285
1286 def AbbreviatedTree(self, trav=None):
1287 # type: (Optional[TraversalState]) -> hnode_t
1288 return self._AbbreviatedTree(trav=trav)
1289
1290class Maybes(pybase.CompoundObj):
1291 _type_tag = 72
1292 __slots__ = ('op', 'arg')
1293
1294 def __init__(self, op, arg):
1295 # type: (Optional[Token], Optional[word]) -> None
1296 self.op = op
1297 self.arg = arg
1298
1299 @staticmethod
1300 def CreateNull(alloc_lists=False):
1301 # type: () -> Maybes
1302 return Maybes(cast('Optional[Token]', None), cast('Optional[word]', None))
1303
1304 def PrettyTree(self, trav=None):
1305 # type: (Optional[TraversalState]) -> hnode_t
1306 trav = trav or TraversalState()
1307 heap_id = id(self)
1308 if heap_id in trav.seen:
1309 return hnode.AlreadySeen(heap_id)
1310 trav.seen[heap_id] = True
1311 out_node = NewRecord('Maybes')
1312 L = out_node.fields
1313
1314 if self.op is not None: # Optional
1315 x0 = self.op.PrettyTree(trav=trav)
1316 L.append(Field('op', x0))
1317
1318 if self.arg is not None: # Optional
1319 x1 = self.arg.PrettyTree(trav=trav)
1320 L.append(Field('arg', x1))
1321
1322 return out_node
1323
1324 def _AbbreviatedTree(self, trav=None):
1325 # type: (Optional[TraversalState]) -> hnode_t
1326 trav = trav or TraversalState()
1327 heap_id = id(self)
1328 if heap_id in trav.seen:
1329 return hnode.AlreadySeen(heap_id)
1330 trav.seen[heap_id] = True
1331 out_node = NewRecord('Maybes')
1332 L = out_node.fields
1333 if self.op is not None: # Optional
1334 x0 = self.op.AbbreviatedTree(trav=trav)
1335 L.append(Field('op', x0))
1336
1337 if self.arg is not None: # Optional
1338 x1 = self.arg.AbbreviatedTree(trav=trav)
1339 L.append(Field('arg', x1))
1340
1341 return out_node
1342
1343 def AbbreviatedTree(self, trav=None):
1344 # type: (Optional[TraversalState]) -> hnode_t
1345 return self._AbbreviatedTree(trav=trav)
1346
1347class OptionalList(pybase.CompoundObj):
1348 _type_tag = 73
1349 __slots__ = ('words',)
1350
1351 def __init__(self, words):
1352 # type: (Optional[List[word]]) -> None
1353 self.words = words
1354
1355 @staticmethod
1356 def CreateNull(alloc_lists=False):
1357 # type: () -> OptionalList
1358 return OptionalList(cast('Optional[List[word]]', None))
1359
1360 def PrettyTree(self, trav=None):
1361 # type: (Optional[TraversalState]) -> hnode_t
1362 trav = trav or TraversalState()
1363 heap_id = id(self)
1364 if heap_id in trav.seen:
1365 return hnode.AlreadySeen(heap_id)
1366 trav.seen[heap_id] = True
1367 out_node = NewRecord('OptionalList')
1368 L = out_node.fields
1369
1370 if self.words is not None: # List
1371 x0 = hnode.Array([])
1372 for i0 in self.words:
1373 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
1374 i0.PrettyTree(trav=trav))
1375 x0.children.append(h)
1376 L.append(Field('words', x0))
1377
1378 return out_node
1379
1380 def _AbbreviatedTree(self, trav=None):
1381 # type: (Optional[TraversalState]) -> hnode_t
1382 trav = trav or TraversalState()
1383 heap_id = id(self)
1384 if heap_id in trav.seen:
1385 return hnode.AlreadySeen(heap_id)
1386 trav.seen[heap_id] = True
1387 out_node = NewRecord('OptionalList')
1388 L = out_node.fields
1389 if self.words is not None: # List
1390 x0 = hnode.Array([])
1391 for i0 in self.words:
1392 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
1393 i0.AbbreviatedTree(trav=trav))
1394 x0.children.append(h)
1395 L.append(Field('words', x0))
1396
1397 return out_node
1398
1399 def AbbreviatedTree(self, trav=None):
1400 # type: (Optional[TraversalState]) -> hnode_t
1401 return self._AbbreviatedTree(trav=trav)
1402