]>
git.proxmox.com Git - mirror_edk2.git/blob - AppPkg/Applications/Python/Python-2.7.2/Lib/compiler/ast.py
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
, expr
, quals
, lineno
=None):
899 def getChildren(self
):
901 children
.append(self
.expr
)
902 children
.extend(flatten(self
.quals
))
903 return tuple(children
)
905 def getChildNodes(self
):
907 nodelist
.append(self
.expr
)
908 nodelist
.extend(flatten_nodes(self
.quals
))
909 return tuple(nodelist
)
912 return "SetComp(%s, %s)" % (repr(self
.expr
), repr(self
.quals
))
914 class DictComp(Node
):
915 def __init__(self
, key
, value
, quals
, lineno
=None):
921 def getChildren(self
):
923 children
.append(self
.key
)
924 children
.append(self
.value
)
925 children
.extend(flatten(self
.quals
))
926 return tuple(children
)
928 def getChildNodes(self
):
930 nodelist
.append(self
.key
)
931 nodelist
.append(self
.value
)
932 nodelist
.extend(flatten_nodes(self
.quals
))
933 return tuple(nodelist
)
936 return "DictComp(%s, %s, %s)" % (repr(self
.key
), repr(self
.value
), repr(self
.quals
))
939 def __init__(self
, leftright
, lineno
=None):
940 self
.left
= leftright
[0]
941 self
.right
= leftright
[1]
944 def getChildren(self
):
945 return self
.left
, self
.right
947 def getChildNodes(self
):
948 return self
.left
, self
.right
951 return "Mod((%s, %s))" % (repr(self
.left
), repr(self
.right
))
954 def __init__(self
, doc
, node
, lineno
=None):
959 def getChildren(self
):
960 return self
.doc
, self
.node
962 def getChildNodes(self
):
966 return "Module(%s, %s)" % (repr(self
.doc
), repr(self
.node
))
969 def __init__(self
, leftright
, lineno
=None):
970 self
.left
= leftright
[0]
971 self
.right
= leftright
[1]
974 def getChildren(self
):
975 return self
.left
, self
.right
977 def getChildNodes(self
):
978 return self
.left
, self
.right
981 return "Mul((%s, %s))" % (repr(self
.left
), repr(self
.right
))
984 def __init__(self
, name
, lineno
=None):
988 def getChildren(self
):
991 def getChildNodes(self
):
995 return "Name(%s)" % (repr(self
.name
),)
998 def __init__(self
, expr
, lineno
=None):
1000 self
.lineno
= lineno
1002 def getChildren(self
):
1005 def getChildNodes(self
):
1009 return "Not(%s)" % (repr(self
.expr
),)
1012 def __init__(self
, nodes
, lineno
=None):
1014 self
.lineno
= lineno
1016 def getChildren(self
):
1017 return tuple(flatten(self
.nodes
))
1019 def getChildNodes(self
):
1021 nodelist
.extend(flatten_nodes(self
.nodes
))
1022 return tuple(nodelist
)
1025 return "Or(%s)" % (repr(self
.nodes
),)
1028 def __init__(self
, lineno
=None):
1029 self
.lineno
= lineno
1031 def getChildren(self
):
1034 def getChildNodes(self
):
1041 def __init__(self
, leftright
, lineno
=None):
1042 self
.left
= leftright
[0]
1043 self
.right
= leftright
[1]
1044 self
.lineno
= lineno
1046 def getChildren(self
):
1047 return self
.left
, self
.right
1049 def getChildNodes(self
):
1050 return self
.left
, self
.right
1053 return "Power((%s, %s))" % (repr(self
.left
), repr(self
.right
))
1056 def __init__(self
, nodes
, dest
, lineno
=None):
1059 self
.lineno
= lineno
1061 def getChildren(self
):
1063 children
.extend(flatten(self
.nodes
))
1064 children
.append(self
.dest
)
1065 return tuple(children
)
1067 def getChildNodes(self
):
1069 nodelist
.extend(flatten_nodes(self
.nodes
))
1070 if self
.dest
is not None:
1071 nodelist
.append(self
.dest
)
1072 return tuple(nodelist
)
1075 return "Print(%s, %s)" % (repr(self
.nodes
), repr(self
.dest
))
1077 class Printnl(Node
):
1078 def __init__(self
, nodes
, dest
, lineno
=None):
1081 self
.lineno
= lineno
1083 def getChildren(self
):
1085 children
.extend(flatten(self
.nodes
))
1086 children
.append(self
.dest
)
1087 return tuple(children
)
1089 def getChildNodes(self
):
1091 nodelist
.extend(flatten_nodes(self
.nodes
))
1092 if self
.dest
is not None:
1093 nodelist
.append(self
.dest
)
1094 return tuple(nodelist
)
1097 return "Printnl(%s, %s)" % (repr(self
.nodes
), repr(self
.dest
))
1100 def __init__(self
, expr1
, expr2
, expr3
, lineno
=None):
1104 self
.lineno
= lineno
1106 def getChildren(self
):
1108 children
.append(self
.expr1
)
1109 children
.append(self
.expr2
)
1110 children
.append(self
.expr3
)
1111 return tuple(children
)
1113 def getChildNodes(self
):
1115 if self
.expr1
is not None:
1116 nodelist
.append(self
.expr1
)
1117 if self
.expr2
is not None:
1118 nodelist
.append(self
.expr2
)
1119 if self
.expr3
is not None:
1120 nodelist
.append(self
.expr3
)
1121 return tuple(nodelist
)
1124 return "Raise(%s, %s, %s)" % (repr(self
.expr1
), repr(self
.expr2
), repr(self
.expr3
))
1127 def __init__(self
, value
, lineno
=None):
1129 self
.lineno
= lineno
1131 def getChildren(self
):
1134 def getChildNodes(self
):
1138 return "Return(%s)" % (repr(self
.value
),)
1140 class RightShift(Node
):
1141 def __init__(self
, leftright
, lineno
=None):
1142 self
.left
= leftright
[0]
1143 self
.right
= leftright
[1]
1144 self
.lineno
= lineno
1146 def getChildren(self
):
1147 return self
.left
, self
.right
1149 def getChildNodes(self
):
1150 return self
.left
, self
.right
1153 return "RightShift((%s, %s))" % (repr(self
.left
), repr(self
.right
))
1156 def __init__(self
, nodes
, lineno
=None):
1158 self
.lineno
= lineno
1160 def getChildren(self
):
1161 return tuple(flatten(self
.nodes
))
1163 def getChildNodes(self
):
1165 nodelist
.extend(flatten_nodes(self
.nodes
))
1166 return tuple(nodelist
)
1169 return "Set(%s)" % (repr(self
.nodes
),)
1172 def __init__(self
, expr
, flags
, lower
, upper
, lineno
=None):
1177 self
.lineno
= lineno
1179 def getChildren(self
):
1181 children
.append(self
.expr
)
1182 children
.append(self
.flags
)
1183 children
.append(self
.lower
)
1184 children
.append(self
.upper
)
1185 return tuple(children
)
1187 def getChildNodes(self
):
1189 nodelist
.append(self
.expr
)
1190 if self
.lower
is not None:
1191 nodelist
.append(self
.lower
)
1192 if self
.upper
is not None:
1193 nodelist
.append(self
.upper
)
1194 return tuple(nodelist
)
1197 return "Slice(%s, %s, %s, %s)" % (repr(self
.expr
), repr(self
.flags
), repr(self
.lower
), repr(self
.upper
))
1199 class Sliceobj(Node
):
1200 def __init__(self
, nodes
, lineno
=None):
1202 self
.lineno
= lineno
1204 def getChildren(self
):
1205 return tuple(flatten(self
.nodes
))
1207 def getChildNodes(self
):
1209 nodelist
.extend(flatten_nodes(self
.nodes
))
1210 return tuple(nodelist
)
1213 return "Sliceobj(%s)" % (repr(self
.nodes
),)
1216 def __init__(self
, nodes
, lineno
=None):
1218 self
.lineno
= lineno
1220 def getChildren(self
):
1221 return tuple(flatten(self
.nodes
))
1223 def getChildNodes(self
):
1225 nodelist
.extend(flatten_nodes(self
.nodes
))
1226 return tuple(nodelist
)
1229 return "Stmt(%s)" % (repr(self
.nodes
),)
1232 def __init__(self
, leftright
, lineno
=None):
1233 self
.left
= leftright
[0]
1234 self
.right
= leftright
[1]
1235 self
.lineno
= lineno
1237 def getChildren(self
):
1238 return self
.left
, self
.right
1240 def getChildNodes(self
):
1241 return self
.left
, self
.right
1244 return "Sub((%s, %s))" % (repr(self
.left
), repr(self
.right
))
1246 class Subscript(Node
):
1247 def __init__(self
, expr
, flags
, subs
, lineno
=None):
1251 self
.lineno
= lineno
1253 def getChildren(self
):
1255 children
.append(self
.expr
)
1256 children
.append(self
.flags
)
1257 children
.extend(flatten(self
.subs
))
1258 return tuple(children
)
1260 def getChildNodes(self
):
1262 nodelist
.append(self
.expr
)
1263 nodelist
.extend(flatten_nodes(self
.subs
))
1264 return tuple(nodelist
)
1267 return "Subscript(%s, %s, %s)" % (repr(self
.expr
), repr(self
.flags
), repr(self
.subs
))
1269 class TryExcept(Node
):
1270 def __init__(self
, body
, handlers
, else_
, lineno
=None):
1272 self
.handlers
= handlers
1274 self
.lineno
= lineno
1276 def getChildren(self
):
1278 children
.append(self
.body
)
1279 children
.extend(flatten(self
.handlers
))
1280 children
.append(self
.else_
)
1281 return tuple(children
)
1283 def getChildNodes(self
):
1285 nodelist
.append(self
.body
)
1286 nodelist
.extend(flatten_nodes(self
.handlers
))
1287 if self
.else_
is not None:
1288 nodelist
.append(self
.else_
)
1289 return tuple(nodelist
)
1292 return "TryExcept(%s, %s, %s)" % (repr(self
.body
), repr(self
.handlers
), repr(self
.else_
))
1294 class TryFinally(Node
):
1295 def __init__(self
, body
, final
, lineno
=None):
1298 self
.lineno
= lineno
1300 def getChildren(self
):
1301 return self
.body
, self
.final
1303 def getChildNodes(self
):
1304 return self
.body
, self
.final
1307 return "TryFinally(%s, %s)" % (repr(self
.body
), repr(self
.final
))
1310 def __init__(self
, nodes
, lineno
=None):
1312 self
.lineno
= lineno
1314 def getChildren(self
):
1315 return tuple(flatten(self
.nodes
))
1317 def getChildNodes(self
):
1319 nodelist
.extend(flatten_nodes(self
.nodes
))
1320 return tuple(nodelist
)
1323 return "Tuple(%s)" % (repr(self
.nodes
),)
1325 class UnaryAdd(Node
):
1326 def __init__(self
, expr
, lineno
=None):
1328 self
.lineno
= lineno
1330 def getChildren(self
):
1333 def getChildNodes(self
):
1337 return "UnaryAdd(%s)" % (repr(self
.expr
),)
1339 class UnarySub(Node
):
1340 def __init__(self
, expr
, lineno
=None):
1342 self
.lineno
= lineno
1344 def getChildren(self
):
1347 def getChildNodes(self
):
1351 return "UnarySub(%s)" % (repr(self
.expr
),)
1354 def __init__(self
, test
, body
, else_
, lineno
=None):
1358 self
.lineno
= lineno
1360 def getChildren(self
):
1362 children
.append(self
.test
)
1363 children
.append(self
.body
)
1364 children
.append(self
.else_
)
1365 return tuple(children
)
1367 def getChildNodes(self
):
1369 nodelist
.append(self
.test
)
1370 nodelist
.append(self
.body
)
1371 if self
.else_
is not None:
1372 nodelist
.append(self
.else_
)
1373 return tuple(nodelist
)
1376 return "While(%s, %s, %s)" % (repr(self
.test
), repr(self
.body
), repr(self
.else_
))
1379 def __init__(self
, expr
, vars, body
, lineno
=None):
1383 self
.lineno
= lineno
1385 def getChildren(self
):
1387 children
.append(self
.expr
)
1388 children
.append(self
.vars)
1389 children
.append(self
.body
)
1390 return tuple(children
)
1392 def getChildNodes(self
):
1394 nodelist
.append(self
.expr
)
1395 if self
.vars is not None:
1396 nodelist
.append(self
.vars)
1397 nodelist
.append(self
.body
)
1398 return tuple(nodelist
)
1401 return "With(%s, %s, %s)" % (repr(self
.expr
), repr(self
.vars), repr(self
.body
))
1404 def __init__(self
, value
, lineno
=None):
1406 self
.lineno
= lineno
1408 def getChildren(self
):
1411 def getChildNodes(self
):
1415 return "Yield(%s)" % (repr(self
.value
),)
1417 for name
, obj
in globals().items():
1418 if isinstance(obj
, type) and issubclass(obj
, Node
):
1419 nodes
[name
.lower()] = obj