1 """Python abstract syntax node definitions
3 This file is automatically generated by Tools/compiler/astgen.py
5 from compiler
.consts
import CO_VARARGS
, CO_VARKEYWORDS
11 if t
is tuple or t
is list:
12 for elt2
in flatten(elt
):
18 def flatten_nodes(seq
):
19 return [n
for n
in flatten(seq
) if isinstance(n
, Node
)]
24 """Abstract base class for ast nodes."""
25 def getChildren(self
):
26 pass # implemented by subclasses
28 for n
in self
.getChildren():
30 def asList(self
): # for backwards compatibility
31 return self
.getChildren()
32 def getChildNodes(self
):
33 pass # implemented by subclasses
35 class EmptyNode(Node
):
38 class Expression(Node
):
39 # Expression is an artificial node class to support "eval"
40 nodes
["expression"] = "Expression"
41 def __init__(self
, node
):
44 def getChildren(self
):
47 def getChildNodes(self
):
51 return "Expression(%s)" % (repr(self
.node
))
54 def __init__(self
, leftright
, lineno
=None):
55 self
.left
= leftright
[0]
56 self
.right
= leftright
[1]
59 def getChildren(self
):
60 return self
.left
, self
.right
62 def getChildNodes(self
):
63 return self
.left
, self
.right
66 return "Add((%s, %s))" % (repr(self
.left
), repr(self
.right
))
69 def __init__(self
, nodes
, lineno
=None):
73 def getChildren(self
):
74 return tuple(flatten(self
.nodes
))
76 def getChildNodes(self
):
78 nodelist
.extend(flatten_nodes(self
.nodes
))
79 return tuple(nodelist
)
82 return "And(%s)" % (repr(self
.nodes
),)
85 def __init__(self
, expr
, attrname
, flags
, lineno
=None):
87 self
.attrname
= attrname
91 def getChildren(self
):
92 return self
.expr
, self
.attrname
, self
.flags
94 def getChildNodes(self
):
98 return "AssAttr(%s, %s, %s)" % (repr(self
.expr
), repr(self
.attrname
), repr(self
.flags
))
101 def __init__(self
, nodes
, lineno
=None):
105 def getChildren(self
):
106 return tuple(flatten(self
.nodes
))
108 def getChildNodes(self
):
110 nodelist
.extend(flatten_nodes(self
.nodes
))
111 return tuple(nodelist
)
114 return "AssList(%s)" % (repr(self
.nodes
),)
117 def __init__(self
, name
, flags
, lineno
=None):
122 def getChildren(self
):
123 return self
.name
, self
.flags
125 def getChildNodes(self
):
129 return "AssName(%s, %s)" % (repr(self
.name
), repr(self
.flags
))
131 class AssTuple(Node
):
132 def __init__(self
, nodes
, lineno
=None):
136 def getChildren(self
):
137 return tuple(flatten(self
.nodes
))
139 def getChildNodes(self
):
141 nodelist
.extend(flatten_nodes(self
.nodes
))
142 return tuple(nodelist
)
145 return "AssTuple(%s)" % (repr(self
.nodes
),)
148 def __init__(self
, test
, fail
, lineno
=None):
153 def getChildren(self
):
155 children
.append(self
.test
)
156 children
.append(self
.fail
)
157 return tuple(children
)
159 def getChildNodes(self
):
161 nodelist
.append(self
.test
)
162 if self
.fail
is not None:
163 nodelist
.append(self
.fail
)
164 return tuple(nodelist
)
167 return "Assert(%s, %s)" % (repr(self
.test
), repr(self
.fail
))
170 def __init__(self
, nodes
, expr
, lineno
=None):
175 def getChildren(self
):
177 children
.extend(flatten(self
.nodes
))
178 children
.append(self
.expr
)
179 return tuple(children
)
181 def getChildNodes(self
):
183 nodelist
.extend(flatten_nodes(self
.nodes
))
184 nodelist
.append(self
.expr
)
185 return tuple(nodelist
)
188 return "Assign(%s, %s)" % (repr(self
.nodes
), repr(self
.expr
))
190 class AugAssign(Node
):
191 def __init__(self
, node
, op
, expr
, lineno
=None):
197 def getChildren(self
):
198 return self
.node
, self
.op
, self
.expr
200 def getChildNodes(self
):
201 return self
.node
, self
.expr
204 return "AugAssign(%s, %s, %s)" % (repr(self
.node
), repr(self
.op
), repr(self
.expr
))
206 class Backquote(Node
):
207 def __init__(self
, expr
, lineno
=None):
211 def getChildren(self
):
214 def getChildNodes(self
):
218 return "Backquote(%s)" % (repr(self
.expr
),)
221 def __init__(self
, nodes
, lineno
=None):
225 def getChildren(self
):
226 return tuple(flatten(self
.nodes
))
228 def getChildNodes(self
):
230 nodelist
.extend(flatten_nodes(self
.nodes
))
231 return tuple(nodelist
)
234 return "Bitand(%s)" % (repr(self
.nodes
),)
237 def __init__(self
, nodes
, lineno
=None):
241 def getChildren(self
):
242 return tuple(flatten(self
.nodes
))
244 def getChildNodes(self
):
246 nodelist
.extend(flatten_nodes(self
.nodes
))
247 return tuple(nodelist
)
250 return "Bitor(%s)" % (repr(self
.nodes
),)
253 def __init__(self
, nodes
, lineno
=None):
257 def getChildren(self
):
258 return tuple(flatten(self
.nodes
))
260 def getChildNodes(self
):
262 nodelist
.extend(flatten_nodes(self
.nodes
))
263 return tuple(nodelist
)
266 return "Bitxor(%s)" % (repr(self
.nodes
),)
269 def __init__(self
, lineno
=None):
272 def getChildren(self
):
275 def getChildNodes(self
):
281 class CallFunc(Node
):
282 def __init__(self
, node
, args
, star_args
= None, dstar_args
= None, lineno
=None):
285 self
.star_args
= star_args
286 self
.dstar_args
= dstar_args
289 def getChildren(self
):
291 children
.append(self
.node
)
292 children
.extend(flatten(self
.args
))
293 children
.append(self
.star_args
)
294 children
.append(self
.dstar_args
)
295 return tuple(children
)
297 def getChildNodes(self
):
299 nodelist
.append(self
.node
)
300 nodelist
.extend(flatten_nodes(self
.args
))
301 if self
.star_args
is not None:
302 nodelist
.append(self
.star_args
)
303 if self
.dstar_args
is not None:
304 nodelist
.append(self
.dstar_args
)
305 return tuple(nodelist
)
308 return "CallFunc(%s, %s, %s, %s)" % (repr(self
.node
), repr(self
.args
), repr(self
.star_args
), repr(self
.dstar_args
))
311 def __init__(self
, name
, bases
, doc
, code
, decorators
= None, lineno
=None):
316 self
.decorators
= decorators
319 def getChildren(self
):
321 children
.append(self
.name
)
322 children
.extend(flatten(self
.bases
))
323 children
.append(self
.doc
)
324 children
.append(self
.code
)
325 children
.append(self
.decorators
)
326 return tuple(children
)
328 def getChildNodes(self
):
330 nodelist
.extend(flatten_nodes(self
.bases
))
331 nodelist
.append(self
.code
)
332 if self
.decorators
is not None:
333 nodelist
.append(self
.decorators
)
334 return tuple(nodelist
)
337 return "Class(%s, %s, %s, %s, %s)" % (repr(self
.name
), repr(self
.bases
), repr(self
.doc
), repr(self
.code
), repr(self
.decorators
))
340 def __init__(self
, expr
, ops
, lineno
=None):
345 def getChildren(self
):
347 children
.append(self
.expr
)
348 children
.extend(flatten(self
.ops
))
349 return tuple(children
)
351 def getChildNodes(self
):
353 nodelist
.append(self
.expr
)
354 nodelist
.extend(flatten_nodes(self
.ops
))
355 return tuple(nodelist
)
358 return "Compare(%s, %s)" % (repr(self
.expr
), repr(self
.ops
))
361 def __init__(self
, value
, lineno
=None):
365 def getChildren(self
):
368 def getChildNodes(self
):
372 return "Const(%s)" % (repr(self
.value
),)
374 class Continue(Node
):
375 def __init__(self
, lineno
=None):
378 def getChildren(self
):
381 def getChildNodes(self
):
387 class Decorators(Node
):
388 def __init__(self
, nodes
, lineno
=None):
392 def getChildren(self
):
393 return tuple(flatten(self
.nodes
))
395 def getChildNodes(self
):
397 nodelist
.extend(flatten_nodes(self
.nodes
))
398 return tuple(nodelist
)
401 return "Decorators(%s)" % (repr(self
.nodes
),)
404 def __init__(self
, items
, lineno
=None):
408 def getChildren(self
):
409 return tuple(flatten(self
.items
))
411 def getChildNodes(self
):
413 nodelist
.extend(flatten_nodes(self
.items
))
414 return tuple(nodelist
)
417 return "Dict(%s)" % (repr(self
.items
),)
420 def __init__(self
, expr
, lineno
=None):
424 def getChildren(self
):
427 def getChildNodes(self
):
431 return "Discard(%s)" % (repr(self
.expr
),)
434 def __init__(self
, leftright
, lineno
=None):
435 self
.left
= leftright
[0]
436 self
.right
= leftright
[1]
439 def getChildren(self
):
440 return self
.left
, self
.right
442 def getChildNodes(self
):
443 return self
.left
, self
.right
446 return "Div((%s, %s))" % (repr(self
.left
), repr(self
.right
))
448 class Ellipsis(Node
):
449 def __init__(self
, lineno
=None):
452 def getChildren(self
):
455 def getChildNodes(self
):
462 def __init__(self
, expr
, locals, globals, lineno
=None):
465 self
.globals = globals
468 def getChildren(self
):
470 children
.append(self
.expr
)
471 children
.append(self
.locals)
472 children
.append(self
.globals)
473 return tuple(children
)
475 def getChildNodes(self
):
477 nodelist
.append(self
.expr
)
478 if self
.locals is not None:
479 nodelist
.append(self
.locals)
480 if self
.globals is not None:
481 nodelist
.append(self
.globals)
482 return tuple(nodelist
)
485 return "Exec(%s, %s, %s)" % (repr(self
.expr
), repr(self
.locals), repr(self
.globals))
487 class FloorDiv(Node
):
488 def __init__(self
, leftright
, lineno
=None):
489 self
.left
= leftright
[0]
490 self
.right
= leftright
[1]
493 def getChildren(self
):
494 return self
.left
, self
.right
496 def getChildNodes(self
):
497 return self
.left
, self
.right
500 return "FloorDiv((%s, %s))" % (repr(self
.left
), repr(self
.right
))
503 def __init__(self
, assign
, list, body
, else_
, lineno
=None):
510 def getChildren(self
):
512 children
.append(self
.assign
)
513 children
.append(self
.list)
514 children
.append(self
.body
)
515 children
.append(self
.else_
)
516 return tuple(children
)
518 def getChildNodes(self
):
520 nodelist
.append(self
.assign
)
521 nodelist
.append(self
.list)
522 nodelist
.append(self
.body
)
523 if self
.else_
is not None:
524 nodelist
.append(self
.else_
)
525 return tuple(nodelist
)
528 return "For(%s, %s, %s, %s)" % (repr(self
.assign
), repr(self
.list), repr(self
.body
), repr(self
.else_
))
531 def __init__(self
, modname
, names
, level
, lineno
=None):
532 self
.modname
= modname
537 def getChildren(self
):
538 return self
.modname
, self
.names
, self
.level
540 def getChildNodes(self
):
544 return "From(%s, %s, %s)" % (repr(self
.modname
), repr(self
.names
), repr(self
.level
))
546 class Function(Node
):
547 def __init__(self
, decorators
, name
, argnames
, defaults
, flags
, doc
, code
, lineno
=None):
548 self
.decorators
= decorators
550 self
.argnames
= argnames
551 self
.defaults
= defaults
556 self
.varargs
= self
.kwargs
= None
557 if flags
& CO_VARARGS
:
559 if flags
& CO_VARKEYWORDS
:
563 def getChildren(self
):
565 children
.append(self
.decorators
)
566 children
.append(self
.name
)
567 children
.append(self
.argnames
)
568 children
.extend(flatten(self
.defaults
))
569 children
.append(self
.flags
)
570 children
.append(self
.doc
)
571 children
.append(self
.code
)
572 return tuple(children
)
574 def getChildNodes(self
):
576 if self
.decorators
is not None:
577 nodelist
.append(self
.decorators
)
578 nodelist
.extend(flatten_nodes(self
.defaults
))
579 nodelist
.append(self
.code
)
580 return tuple(nodelist
)
583 return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self
.decorators
), repr(self
.name
), repr(self
.argnames
), repr(self
.defaults
), repr(self
.flags
), repr(self
.doc
), repr(self
.code
))
586 def __init__(self
, code
, lineno
=None):
589 self
.argnames
= ['.0']
590 self
.varargs
= self
.kwargs
= None
593 def getChildren(self
):
596 def getChildNodes(self
):
600 return "GenExpr(%s)" % (repr(self
.code
),)
602 class GenExprFor(Node
):
603 def __init__(self
, assign
, iter, ifs
, lineno
=None):
608 self
.is_outmost
= False
610 def getChildren(self
):
612 children
.append(self
.assign
)
613 children
.append(self
.iter)
614 children
.extend(flatten(self
.ifs
))
615 return tuple(children
)
617 def getChildNodes(self
):
619 nodelist
.append(self
.assign
)
620 nodelist
.append(self
.iter)
621 nodelist
.extend(flatten_nodes(self
.ifs
))
622 return tuple(nodelist
)
625 return "GenExprFor(%s, %s, %s)" % (repr(self
.assign
), repr(self
.iter), repr(self
.ifs
))
627 class GenExprIf(Node
):
628 def __init__(self
, test
, lineno
=None):
632 def getChildren(self
):
635 def getChildNodes(self
):
639 return "GenExprIf(%s)" % (repr(self
.test
),)
641 class GenExprInner(Node
):
642 def __init__(self
, expr
, quals
, lineno
=None):
647 def getChildren(self
):
649 children
.append(self
.expr
)
650 children
.extend(flatten(self
.quals
))
651 return tuple(children
)
653 def getChildNodes(self
):
655 nodelist
.append(self
.expr
)
656 nodelist
.extend(flatten_nodes(self
.quals
))
657 return tuple(nodelist
)
660 return "GenExprInner(%s, %s)" % (repr(self
.expr
), repr(self
.quals
))
663 def __init__(self
, expr
, attrname
, lineno
=None):
665 self
.attrname
= attrname
668 def getChildren(self
):
669 return self
.expr
, self
.attrname
671 def getChildNodes(self
):
675 return "Getattr(%s, %s)" % (repr(self
.expr
), repr(self
.attrname
))
678 def __init__(self
, names
, lineno
=None):
682 def getChildren(self
):
685 def getChildNodes(self
):
689 return "Global(%s)" % (repr(self
.names
),)
692 def __init__(self
, tests
, else_
, lineno
=None):
697 def getChildren(self
):
699 children
.extend(flatten(self
.tests
))
700 children
.append(self
.else_
)
701 return tuple(children
)
703 def getChildNodes(self
):
705 nodelist
.extend(flatten_nodes(self
.tests
))
706 if self
.else_
is not None:
707 nodelist
.append(self
.else_
)
708 return tuple(nodelist
)
711 return "If(%s, %s)" % (repr(self
.tests
), repr(self
.else_
))
714 def __init__(self
, test
, then
, else_
, lineno
=None):
720 def getChildren(self
):
721 return self
.test
, self
.then
, self
.else_
723 def getChildNodes(self
):
724 return self
.test
, self
.then
, self
.else_
727 return "IfExp(%s, %s, %s)" % (repr(self
.test
), repr(self
.then
), repr(self
.else_
))
730 def __init__(self
, names
, lineno
=None):
734 def getChildren(self
):
737 def getChildNodes(self
):
741 return "Import(%s)" % (repr(self
.names
),)
744 def __init__(self
, expr
, lineno
=None):
748 def getChildren(self
):
751 def getChildNodes(self
):
755 return "Invert(%s)" % (repr(self
.expr
),)
758 def __init__(self
, name
, expr
, lineno
=None):
763 def getChildren(self
):
764 return self
.name
, self
.expr
766 def getChildNodes(self
):
770 return "Keyword(%s, %s)" % (repr(self
.name
), repr(self
.expr
))
773 def __init__(self
, argnames
, defaults
, flags
, code
, lineno
=None):
774 self
.argnames
= argnames
775 self
.defaults
= defaults
779 self
.varargs
= self
.kwargs
= None
780 if flags
& CO_VARARGS
:
782 if flags
& CO_VARKEYWORDS
:
786 def getChildren(self
):
788 children
.append(self
.argnames
)
789 children
.extend(flatten(self
.defaults
))
790 children
.append(self
.flags
)
791 children
.append(self
.code
)
792 return tuple(children
)
794 def getChildNodes(self
):
796 nodelist
.extend(flatten_nodes(self
.defaults
))
797 nodelist
.append(self
.code
)
798 return tuple(nodelist
)
801 return "Lambda(%s, %s, %s, %s)" % (repr(self
.argnames
), repr(self
.defaults
), repr(self
.flags
), repr(self
.code
))
803 class LeftShift(Node
):
804 def __init__(self
, leftright
, lineno
=None):
805 self
.left
= leftright
[0]
806 self
.right
= leftright
[1]
809 def getChildren(self
):
810 return self
.left
, self
.right
812 def getChildNodes(self
):
813 return self
.left
, self
.right
816 return "LeftShift((%s, %s))" % (repr(self
.left
), repr(self
.right
))
819 def __init__(self
, nodes
, lineno
=None):
823 def getChildren(self
):
824 return tuple(flatten(self
.nodes
))
826 def getChildNodes(self
):
828 nodelist
.extend(flatten_nodes(self
.nodes
))
829 return tuple(nodelist
)
832 return "List(%s)" % (repr(self
.nodes
),)
834 class ListComp(Node
):
835 def __init__(self
, expr
, quals
, lineno
=None):
840 def getChildren(self
):
842 children
.append(self
.expr
)
843 children
.extend(flatten(self
.quals
))
844 return tuple(children
)
846 def getChildNodes(self
):
848 nodelist
.append(self
.expr
)
849 nodelist
.extend(flatten_nodes(self
.quals
))
850 return tuple(nodelist
)
853 return "ListComp(%s, %s)" % (repr(self
.expr
), repr(self
.quals
))
855 class ListCompFor(Node
):
856 def __init__(self
, assign
, list, ifs
, lineno
=None):
862 def getChildren(self
):
864 children
.append(self
.assign
)
865 children
.append(self
.list)
866 children
.extend(flatten(self
.ifs
))
867 return tuple(children
)
869 def getChildNodes(self
):
871 nodelist
.append(self
.assign
)
872 nodelist
.append(self
.list)
873 nodelist
.extend(flatten_nodes(self
.ifs
))
874 return tuple(nodelist
)
877 return "ListCompFor(%s, %s, %s)" % (repr(self
.assign
), repr(self
.list), repr(self
.ifs
))
879 class ListCompIf(Node
):
880 def __init__(self
, test
, lineno
=None):
884 def getChildren(self
):
887 def getChildNodes(self
):
891 return "ListCompIf(%s)" % (repr(self
.test
),)
894 def __init__(self
, leftright
, lineno
=None):
895 self
.left
= leftright
[0]
896 self
.right
= leftright
[1]
899 def getChildren(self
):
900 return self
.left
, self
.right
902 def getChildNodes(self
):
903 return self
.left
, self
.right
906 return "Mod((%s, %s))" % (repr(self
.left
), repr(self
.right
))
909 def __init__(self
, doc
, node
, lineno
=None):
914 def getChildren(self
):
915 return self
.doc
, self
.node
917 def getChildNodes(self
):
921 return "Module(%s, %s)" % (repr(self
.doc
), repr(self
.node
))
924 def __init__(self
, leftright
, lineno
=None):
925 self
.left
= leftright
[0]
926 self
.right
= leftright
[1]
929 def getChildren(self
):
930 return self
.left
, self
.right
932 def getChildNodes(self
):
933 return self
.left
, self
.right
936 return "Mul((%s, %s))" % (repr(self
.left
), repr(self
.right
))
939 def __init__(self
, name
, lineno
=None):
943 def getChildren(self
):
946 def getChildNodes(self
):
950 return "Name(%s)" % (repr(self
.name
),)
953 def __init__(self
, expr
, lineno
=None):
957 def getChildren(self
):
960 def getChildNodes(self
):
964 return "Not(%s)" % (repr(self
.expr
),)
967 def __init__(self
, nodes
, lineno
=None):
971 def getChildren(self
):
972 return tuple(flatten(self
.nodes
))
974 def getChildNodes(self
):
976 nodelist
.extend(flatten_nodes(self
.nodes
))
977 return tuple(nodelist
)
980 return "Or(%s)" % (repr(self
.nodes
),)
983 def __init__(self
, lineno
=None):
986 def getChildren(self
):
989 def getChildNodes(self
):
996 def __init__(self
, leftright
, lineno
=None):
997 self
.left
= leftright
[0]
998 self
.right
= leftright
[1]
1001 def getChildren(self
):
1002 return self
.left
, self
.right
1004 def getChildNodes(self
):
1005 return self
.left
, self
.right
1008 return "Power((%s, %s))" % (repr(self
.left
), repr(self
.right
))
1011 def __init__(self
, nodes
, dest
, lineno
=None):
1014 self
.lineno
= lineno
1016 def getChildren(self
):
1018 children
.extend(flatten(self
.nodes
))
1019 children
.append(self
.dest
)
1020 return tuple(children
)
1022 def getChildNodes(self
):
1024 nodelist
.extend(flatten_nodes(self
.nodes
))
1025 if self
.dest
is not None:
1026 nodelist
.append(self
.dest
)
1027 return tuple(nodelist
)
1030 return "Print(%s, %s)" % (repr(self
.nodes
), repr(self
.dest
))
1032 class Printnl(Node
):
1033 def __init__(self
, nodes
, dest
, lineno
=None):
1036 self
.lineno
= lineno
1038 def getChildren(self
):
1040 children
.extend(flatten(self
.nodes
))
1041 children
.append(self
.dest
)
1042 return tuple(children
)
1044 def getChildNodes(self
):
1046 nodelist
.extend(flatten_nodes(self
.nodes
))
1047 if self
.dest
is not None:
1048 nodelist
.append(self
.dest
)
1049 return tuple(nodelist
)
1052 return "Printnl(%s, %s)" % (repr(self
.nodes
), repr(self
.dest
))
1055 def __init__(self
, expr1
, expr2
, expr3
, lineno
=None):
1059 self
.lineno
= lineno
1061 def getChildren(self
):
1063 children
.append(self
.expr1
)
1064 children
.append(self
.expr2
)
1065 children
.append(self
.expr3
)
1066 return tuple(children
)
1068 def getChildNodes(self
):
1070 if self
.expr1
is not None:
1071 nodelist
.append(self
.expr1
)
1072 if self
.expr2
is not None:
1073 nodelist
.append(self
.expr2
)
1074 if self
.expr3
is not None:
1075 nodelist
.append(self
.expr3
)
1076 return tuple(nodelist
)
1079 return "Raise(%s, %s, %s)" % (repr(self
.expr1
), repr(self
.expr2
), repr(self
.expr3
))
1082 def __init__(self
, value
, lineno
=None):
1084 self
.lineno
= lineno
1086 def getChildren(self
):
1089 def getChildNodes(self
):
1093 return "Return(%s)" % (repr(self
.value
),)
1095 class RightShift(Node
):
1096 def __init__(self
, leftright
, lineno
=None):
1097 self
.left
= leftright
[0]
1098 self
.right
= leftright
[1]
1099 self
.lineno
= lineno
1101 def getChildren(self
):
1102 return self
.left
, self
.right
1104 def getChildNodes(self
):
1105 return self
.left
, self
.right
1108 return "RightShift((%s, %s))" % (repr(self
.left
), repr(self
.right
))
1111 def __init__(self
, expr
, flags
, lower
, upper
, lineno
=None):
1116 self
.lineno
= lineno
1118 def getChildren(self
):
1120 children
.append(self
.expr
)
1121 children
.append(self
.flags
)
1122 children
.append(self
.lower
)
1123 children
.append(self
.upper
)
1124 return tuple(children
)
1126 def getChildNodes(self
):
1128 nodelist
.append(self
.expr
)
1129 if self
.lower
is not None:
1130 nodelist
.append(self
.lower
)
1131 if self
.upper
is not None:
1132 nodelist
.append(self
.upper
)
1133 return tuple(nodelist
)
1136 return "Slice(%s, %s, %s, %s)" % (repr(self
.expr
), repr(self
.flags
), repr(self
.lower
), repr(self
.upper
))
1138 class Sliceobj(Node
):
1139 def __init__(self
, nodes
, lineno
=None):
1141 self
.lineno
= lineno
1143 def getChildren(self
):
1144 return tuple(flatten(self
.nodes
))
1146 def getChildNodes(self
):
1148 nodelist
.extend(flatten_nodes(self
.nodes
))
1149 return tuple(nodelist
)
1152 return "Sliceobj(%s)" % (repr(self
.nodes
),)
1155 def __init__(self
, nodes
, lineno
=None):
1157 self
.lineno
= lineno
1159 def getChildren(self
):
1160 return tuple(flatten(self
.nodes
))
1162 def getChildNodes(self
):
1164 nodelist
.extend(flatten_nodes(self
.nodes
))
1165 return tuple(nodelist
)
1168 return "Stmt(%s)" % (repr(self
.nodes
),)
1171 def __init__(self
, leftright
, lineno
=None):
1172 self
.left
= leftright
[0]
1173 self
.right
= leftright
[1]
1174 self
.lineno
= lineno
1176 def getChildren(self
):
1177 return self
.left
, self
.right
1179 def getChildNodes(self
):
1180 return self
.left
, self
.right
1183 return "Sub((%s, %s))" % (repr(self
.left
), repr(self
.right
))
1185 class Subscript(Node
):
1186 def __init__(self
, expr
, flags
, subs
, lineno
=None):
1190 self
.lineno
= lineno
1192 def getChildren(self
):
1194 children
.append(self
.expr
)
1195 children
.append(self
.flags
)
1196 children
.extend(flatten(self
.subs
))
1197 return tuple(children
)
1199 def getChildNodes(self
):
1201 nodelist
.append(self
.expr
)
1202 nodelist
.extend(flatten_nodes(self
.subs
))
1203 return tuple(nodelist
)
1206 return "Subscript(%s, %s, %s)" % (repr(self
.expr
), repr(self
.flags
), repr(self
.subs
))
1208 class TryExcept(Node
):
1209 def __init__(self
, body
, handlers
, else_
, lineno
=None):
1211 self
.handlers
= handlers
1213 self
.lineno
= lineno
1215 def getChildren(self
):
1217 children
.append(self
.body
)
1218 children
.extend(flatten(self
.handlers
))
1219 children
.append(self
.else_
)
1220 return tuple(children
)
1222 def getChildNodes(self
):
1224 nodelist
.append(self
.body
)
1225 nodelist
.extend(flatten_nodes(self
.handlers
))
1226 if self
.else_
is not None:
1227 nodelist
.append(self
.else_
)
1228 return tuple(nodelist
)
1231 return "TryExcept(%s, %s, %s)" % (repr(self
.body
), repr(self
.handlers
), repr(self
.else_
))
1233 class TryFinally(Node
):
1234 def __init__(self
, body
, final
, lineno
=None):
1237 self
.lineno
= lineno
1239 def getChildren(self
):
1240 return self
.body
, self
.final
1242 def getChildNodes(self
):
1243 return self
.body
, self
.final
1246 return "TryFinally(%s, %s)" % (repr(self
.body
), repr(self
.final
))
1249 def __init__(self
, nodes
, lineno
=None):
1251 self
.lineno
= lineno
1253 def getChildren(self
):
1254 return tuple(flatten(self
.nodes
))
1256 def getChildNodes(self
):
1258 nodelist
.extend(flatten_nodes(self
.nodes
))
1259 return tuple(nodelist
)
1262 return "Tuple(%s)" % (repr(self
.nodes
),)
1264 class UnaryAdd(Node
):
1265 def __init__(self
, expr
, lineno
=None):
1267 self
.lineno
= lineno
1269 def getChildren(self
):
1272 def getChildNodes(self
):
1276 return "UnaryAdd(%s)" % (repr(self
.expr
),)
1278 class UnarySub(Node
):
1279 def __init__(self
, expr
, lineno
=None):
1281 self
.lineno
= lineno
1283 def getChildren(self
):
1286 def getChildNodes(self
):
1290 return "UnarySub(%s)" % (repr(self
.expr
),)
1293 def __init__(self
, test
, body
, else_
, lineno
=None):
1297 self
.lineno
= lineno
1299 def getChildren(self
):
1301 children
.append(self
.test
)
1302 children
.append(self
.body
)
1303 children
.append(self
.else_
)
1304 return tuple(children
)
1306 def getChildNodes(self
):
1308 nodelist
.append(self
.test
)
1309 nodelist
.append(self
.body
)
1310 if self
.else_
is not None:
1311 nodelist
.append(self
.else_
)
1312 return tuple(nodelist
)
1315 return "While(%s, %s, %s)" % (repr(self
.test
), repr(self
.body
), repr(self
.else_
))
1318 def __init__(self
, expr
, vars, body
, lineno
=None):
1322 self
.lineno
= lineno
1324 def getChildren(self
):
1326 children
.append(self
.expr
)
1327 children
.append(self
.vars)
1328 children
.append(self
.body
)
1329 return tuple(children
)
1331 def getChildNodes(self
):
1333 nodelist
.append(self
.expr
)
1334 if self
.vars is not None:
1335 nodelist
.append(self
.vars)
1336 nodelist
.append(self
.body
)
1337 return tuple(nodelist
)
1340 return "With(%s, %s, %s)" % (repr(self
.expr
), repr(self
.vars), repr(self
.body
))
1343 def __init__(self
, value
, lineno
=None):
1345 self
.lineno
= lineno
1347 def getChildren(self
):
1350 def getChildNodes(self
):
1354 return "Yield(%s)" % (repr(self
.value
),)
1356 for name
, obj
in globals().items():
1357 if isinstance(obj
, type) and issubclass(obj
, Node
):
1358 nodes
[name
.lower()] = obj