Lines Matching refs:self
25 def getChildren(self): argument
27 def __iter__(self): argument
28 for n in self.getChildren():
30 def asList(self): # for backwards compatibility argument
31 return self.getChildren()
32 def getChildNodes(self): argument
41 def __init__(self, node): argument
42 self.node = node
44 def getChildren(self): argument
45 return self.node,
47 def getChildNodes(self): argument
48 return self.node,
50 def __repr__(self): argument
51 return "Expression(%s)" % (repr(self.node))
54 def __init__(self, leftright, lineno=None): argument
55 self.left = leftright[0]
56 self.right = leftright[1]
57 self.lineno = lineno
59 def getChildren(self): argument
60 return self.left, self.right
62 def getChildNodes(self): argument
63 return self.left, self.right
65 def __repr__(self): argument
66 return "Add((%s, %s))" % (repr(self.left), repr(self.right))
69 def __init__(self, nodes, lineno=None): argument
70 self.nodes = nodes
71 self.lineno = lineno
73 def getChildren(self): argument
74 return tuple(flatten(self.nodes))
76 def getChildNodes(self): argument
78 nodelist.extend(flatten_nodes(self.nodes))
81 def __repr__(self): argument
82 return "And(%s)" % (repr(self.nodes),)
85 def __init__(self, expr, attrname, flags, lineno=None): argument
86 self.expr = expr
87 self.attrname = attrname
88 self.flags = flags
89 self.lineno = lineno
91 def getChildren(self): argument
92 return self.expr, self.attrname, self.flags
94 def getChildNodes(self): argument
95 return self.expr,
97 def __repr__(self): argument
98 return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
101 def __init__(self, nodes, lineno=None): argument
102 self.nodes = nodes
103 self.lineno = lineno
105 def getChildren(self): argument
106 return tuple(flatten(self.nodes))
108 def getChildNodes(self): argument
110 nodelist.extend(flatten_nodes(self.nodes))
113 def __repr__(self): argument
114 return "AssList(%s)" % (repr(self.nodes),)
117 def __init__(self, name, flags, lineno=None): argument
118 self.name = name
119 self.flags = flags
120 self.lineno = lineno
122 def getChildren(self): argument
123 return self.name, self.flags
125 def getChildNodes(self): argument
128 def __repr__(self): argument
129 return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
132 def __init__(self, nodes, lineno=None): argument
133 self.nodes = nodes
134 self.lineno = lineno
136 def getChildren(self): argument
137 return tuple(flatten(self.nodes))
139 def getChildNodes(self): argument
141 nodelist.extend(flatten_nodes(self.nodes))
144 def __repr__(self): argument
145 return "AssTuple(%s)" % (repr(self.nodes),)
148 def __init__(self, test, fail, lineno=None): argument
149 self.test = test
150 self.fail = fail
151 self.lineno = lineno
153 def getChildren(self): argument
155 children.append(self.test)
156 children.append(self.fail)
159 def getChildNodes(self): argument
161 nodelist.append(self.test)
162 if self.fail is not None:
163 nodelist.append(self.fail)
166 def __repr__(self): argument
167 return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
170 def __init__(self, nodes, expr, lineno=None): argument
171 self.nodes = nodes
172 self.expr = expr
173 self.lineno = lineno
175 def getChildren(self): argument
177 children.extend(flatten(self.nodes))
178 children.append(self.expr)
181 def getChildNodes(self): argument
183 nodelist.extend(flatten_nodes(self.nodes))
184 nodelist.append(self.expr)
187 def __repr__(self): argument
188 return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
191 def __init__(self, node, op, expr, lineno=None): argument
192 self.node = node
193 self.op = op
194 self.expr = expr
195 self.lineno = lineno
197 def getChildren(self): argument
198 return self.node, self.op, self.expr
200 def getChildNodes(self): argument
201 return self.node, self.expr
203 def __repr__(self): argument
204 return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
207 def __init__(self, expr, lineno=None): argument
208 self.expr = expr
209 self.lineno = lineno
211 def getChildren(self): argument
212 return self.expr,
214 def getChildNodes(self): argument
215 return self.expr,
217 def __repr__(self): argument
218 return "Backquote(%s)" % (repr(self.expr),)
221 def __init__(self, nodes, lineno=None): argument
222 self.nodes = nodes
223 self.lineno = lineno
225 def getChildren(self): argument
226 return tuple(flatten(self.nodes))
228 def getChildNodes(self): argument
230 nodelist.extend(flatten_nodes(self.nodes))
233 def __repr__(self): argument
234 return "Bitand(%s)" % (repr(self.nodes),)
237 def __init__(self, nodes, lineno=None): argument
238 self.nodes = nodes
239 self.lineno = lineno
241 def getChildren(self): argument
242 return tuple(flatten(self.nodes))
244 def getChildNodes(self): argument
246 nodelist.extend(flatten_nodes(self.nodes))
249 def __repr__(self): argument
250 return "Bitor(%s)" % (repr(self.nodes),)
253 def __init__(self, nodes, lineno=None): argument
254 self.nodes = nodes
255 self.lineno = lineno
257 def getChildren(self): argument
258 return tuple(flatten(self.nodes))
260 def getChildNodes(self): argument
262 nodelist.extend(flatten_nodes(self.nodes))
265 def __repr__(self): argument
266 return "Bitxor(%s)" % (repr(self.nodes),)
269 def __init__(self, lineno=None): argument
270 self.lineno = lineno
272 def getChildren(self): argument
275 def getChildNodes(self): argument
278 def __repr__(self): argument
282 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): argument
283 self.node = node
284 self.args = args
285 self.star_args = star_args
286 self.dstar_args = dstar_args
287 self.lineno = lineno
289 def getChildren(self): argument
291 children.append(self.node)
292 children.extend(flatten(self.args))
293 children.append(self.star_args)
294 children.append(self.dstar_args)
297 def getChildNodes(self): argument
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)
307 def __repr__(self): argument
308 …return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(…
311 def __init__(self, name, bases, doc, code, decorators = None, lineno=None): argument
312 self.name = name
313 self.bases = bases
314 self.doc = doc
315 self.code = code
316 self.decorators = decorators
317 self.lineno = lineno
319 def getChildren(self): argument
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)
328 def getChildNodes(self): argument
330 nodelist.extend(flatten_nodes(self.bases))
331 nodelist.append(self.code)
332 if self.decorators is not None:
333 nodelist.append(self.decorators)
336 def __repr__(self): argument
337 …urn "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.co…
340 def __init__(self, expr, ops, lineno=None): argument
341 self.expr = expr
342 self.ops = ops
343 self.lineno = lineno
345 def getChildren(self): argument
347 children.append(self.expr)
348 children.extend(flatten(self.ops))
351 def getChildNodes(self): argument
353 nodelist.append(self.expr)
354 nodelist.extend(flatten_nodes(self.ops))
357 def __repr__(self): argument
358 return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
361 def __init__(self, value, lineno=None): argument
362 self.value = value
363 self.lineno = lineno
365 def getChildren(self): argument
366 return self.value,
368 def getChildNodes(self): argument
371 def __repr__(self): argument
372 return "Const(%s)" % (repr(self.value),)
375 def __init__(self, lineno=None): argument
376 self.lineno = lineno
378 def getChildren(self): argument
381 def getChildNodes(self): argument
384 def __repr__(self): argument
388 def __init__(self, nodes, lineno=None): argument
389 self.nodes = nodes
390 self.lineno = lineno
392 def getChildren(self): argument
393 return tuple(flatten(self.nodes))
395 def getChildNodes(self): argument
397 nodelist.extend(flatten_nodes(self.nodes))
400 def __repr__(self): argument
401 return "Decorators(%s)" % (repr(self.nodes),)
404 def __init__(self, items, lineno=None): argument
405 self.items = items
406 self.lineno = lineno
408 def getChildren(self): argument
409 return tuple(flatten(self.items))
411 def getChildNodes(self): argument
413 nodelist.extend(flatten_nodes(self.items))
416 def __repr__(self): argument
417 return "Dict(%s)" % (repr(self.items),)
420 def __init__(self, expr, lineno=None): argument
421 self.expr = expr
422 self.lineno = lineno
424 def getChildren(self): argument
425 return self.expr,
427 def getChildNodes(self): argument
428 return self.expr,
430 def __repr__(self): argument
431 return "Discard(%s)" % (repr(self.expr),)
434 def __init__(self, leftright, lineno=None): argument
435 self.left = leftright[0]
436 self.right = leftright[1]
437 self.lineno = lineno
439 def getChildren(self): argument
440 return self.left, self.right
442 def getChildNodes(self): argument
443 return self.left, self.right
445 def __repr__(self): argument
446 return "Div((%s, %s))" % (repr(self.left), repr(self.right))
449 def __init__(self, lineno=None): argument
450 self.lineno = lineno
452 def getChildren(self): argument
455 def getChildNodes(self): argument
458 def __repr__(self): argument
462 def __init__(self, expr, locals, globals, lineno=None): argument
463 self.expr = expr
464 self.locals = locals
465 self.globals = globals
466 self.lineno = lineno
468 def getChildren(self): argument
470 children.append(self.expr)
471 children.append(self.locals)
472 children.append(self.globals)
475 def getChildNodes(self): argument
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)
484 def __repr__(self): argument
485 return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
488 def __init__(self, leftright, lineno=None): argument
489 self.left = leftright[0]
490 self.right = leftright[1]
491 self.lineno = lineno
493 def getChildren(self): argument
494 return self.left, self.right
496 def getChildNodes(self): argument
497 return self.left, self.right
499 def __repr__(self): argument
500 return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
503 def __init__(self, assign, list, body, else_, lineno=None): argument
504 self.assign = assign
505 self.list = list
506 self.body = body
507 self.else_ = else_
508 self.lineno = lineno
510 def getChildren(self): argument
512 children.append(self.assign)
513 children.append(self.list)
514 children.append(self.body)
515 children.append(self.else_)
518 def getChildNodes(self): argument
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_)
527 def __repr__(self): argument
528 …return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.els…
531 def __init__(self, modname, names, level, lineno=None): argument
532 self.modname = modname
533 self.names = names
534 self.level = level
535 self.lineno = lineno
537 def getChildren(self): argument
538 return self.modname, self.names, self.level
540 def getChildNodes(self): argument
543 def __repr__(self): argument
544 return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
547 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): argument
548 self.decorators = decorators
549 self.name = name
550 self.argnames = argnames
551 self.defaults = defaults
552 self.flags = flags
553 self.doc = doc
554 self.code = code
555 self.lineno = lineno
556 self.varargs = self.kwargs = None
558 self.varargs = 1
560 self.kwargs = 1
563 def getChildren(self): argument
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)
574 def getChildNodes(self): argument
576 if self.decorators is not None:
577 nodelist.append(self.decorators)
578 nodelist.extend(flatten_nodes(self.defaults))
579 nodelist.append(self.code)
582 def __repr__(self): argument
583 …s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(…
586 def __init__(self, code, lineno=None): argument
587 self.code = code
588 self.lineno = lineno
589 self.argnames = ['.0']
590 self.varargs = self.kwargs = None
593 def getChildren(self): argument
594 return self.code,
596 def getChildNodes(self): argument
597 return self.code,
599 def __repr__(self): argument
600 return "GenExpr(%s)" % (repr(self.code),)
603 def __init__(self, assign, iter, ifs, lineno=None): argument
604 self.assign = assign
605 self.iter = iter
606 self.ifs = ifs
607 self.lineno = lineno
608 self.is_outmost = False
610 def getChildren(self): argument
612 children.append(self.assign)
613 children.append(self.iter)
614 children.extend(flatten(self.ifs))
617 def getChildNodes(self): argument
619 nodelist.append(self.assign)
620 nodelist.append(self.iter)
621 nodelist.extend(flatten_nodes(self.ifs))
624 def __repr__(self): argument
625 return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
628 def __init__(self, test, lineno=None): argument
629 self.test = test
630 self.lineno = lineno
632 def getChildren(self): argument
633 return self.test,
635 def getChildNodes(self): argument
636 return self.test,
638 def __repr__(self): argument
639 return "GenExprIf(%s)" % (repr(self.test),)
642 def __init__(self, expr, quals, lineno=None): argument
643 self.expr = expr
644 self.quals = quals
645 self.lineno = lineno
647 def getChildren(self): argument
649 children.append(self.expr)
650 children.extend(flatten(self.quals))
653 def getChildNodes(self): argument
655 nodelist.append(self.expr)
656 nodelist.extend(flatten_nodes(self.quals))
659 def __repr__(self): argument
660 return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
663 def __init__(self, expr, attrname, lineno=None): argument
664 self.expr = expr
665 self.attrname = attrname
666 self.lineno = lineno
668 def getChildren(self): argument
669 return self.expr, self.attrname
671 def getChildNodes(self): argument
672 return self.expr,
674 def __repr__(self): argument
675 return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
678 def __init__(self, names, lineno=None): argument
679 self.names = names
680 self.lineno = lineno
682 def getChildren(self): argument
683 return self.names,
685 def getChildNodes(self): argument
688 def __repr__(self): argument
689 return "Global(%s)" % (repr(self.names),)
692 def __init__(self, tests, else_, lineno=None): argument
693 self.tests = tests
694 self.else_ = else_
695 self.lineno = lineno
697 def getChildren(self): argument
699 children.extend(flatten(self.tests))
700 children.append(self.else_)
703 def getChildNodes(self): argument
705 nodelist.extend(flatten_nodes(self.tests))
706 if self.else_ is not None:
707 nodelist.append(self.else_)
710 def __repr__(self): argument
711 return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
714 def __init__(self, test, then, else_, lineno=None): argument
715 self.test = test
716 self.then = then
717 self.else_ = else_
718 self.lineno = lineno
720 def getChildren(self): argument
721 return self.test, self.then, self.else_
723 def getChildNodes(self): argument
724 return self.test, self.then, self.else_
726 def __repr__(self): argument
727 return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
730 def __init__(self, names, lineno=None): argument
731 self.names = names
732 self.lineno = lineno
734 def getChildren(self): argument
735 return self.names,
737 def getChildNodes(self): argument
740 def __repr__(self): argument
741 return "Import(%s)" % (repr(self.names),)
744 def __init__(self, expr, lineno=None): argument
745 self.expr = expr
746 self.lineno = lineno
748 def getChildren(self): argument
749 return self.expr,
751 def getChildNodes(self): argument
752 return self.expr,
754 def __repr__(self): argument
755 return "Invert(%s)" % (repr(self.expr),)
758 def __init__(self, name, expr, lineno=None): argument
759 self.name = name
760 self.expr = expr
761 self.lineno = lineno
763 def getChildren(self): argument
764 return self.name, self.expr
766 def getChildNodes(self): argument
767 return self.expr,
769 def __repr__(self): argument
770 return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
773 def __init__(self, argnames, defaults, flags, code, lineno=None): argument
774 self.argnames = argnames
775 self.defaults = defaults
776 self.flags = flags
777 self.code = code
778 self.lineno = lineno
779 self.varargs = self.kwargs = None
781 self.varargs = 1
783 self.kwargs = 1
786 def getChildren(self): argument
788 children.append(self.argnames)
789 children.extend(flatten(self.defaults))
790 children.append(self.flags)
791 children.append(self.code)
794 def getChildNodes(self): argument
796 nodelist.extend(flatten_nodes(self.defaults))
797 nodelist.append(self.code)
800 def __repr__(self): argument
801 …return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), rep…
804 def __init__(self, leftright, lineno=None): argument
805 self.left = leftright[0]
806 self.right = leftright[1]
807 self.lineno = lineno
809 def getChildren(self): argument
810 return self.left, self.right
812 def getChildNodes(self): argument
813 return self.left, self.right
815 def __repr__(self): argument
816 return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
819 def __init__(self, nodes, lineno=None): argument
820 self.nodes = nodes
821 self.lineno = lineno
823 def getChildren(self): argument
824 return tuple(flatten(self.nodes))
826 def getChildNodes(self): argument
828 nodelist.extend(flatten_nodes(self.nodes))
831 def __repr__(self): argument
832 return "List(%s)" % (repr(self.nodes),)
835 def __init__(self, expr, quals, lineno=None): argument
836 self.expr = expr
837 self.quals = quals
838 self.lineno = lineno
840 def getChildren(self): argument
842 children.append(self.expr)
843 children.extend(flatten(self.quals))
846 def getChildNodes(self): argument
848 nodelist.append(self.expr)
849 nodelist.extend(flatten_nodes(self.quals))
852 def __repr__(self): argument
853 return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
856 def __init__(self, assign, list, ifs, lineno=None): argument
857 self.assign = assign
858 self.list = list
859 self.ifs = ifs
860 self.lineno = lineno
862 def getChildren(self): argument
864 children.append(self.assign)
865 children.append(self.list)
866 children.extend(flatten(self.ifs))
869 def getChildNodes(self): argument
871 nodelist.append(self.assign)
872 nodelist.append(self.list)
873 nodelist.extend(flatten_nodes(self.ifs))
876 def __repr__(self): argument
877 return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
880 def __init__(self, test, lineno=None): argument
881 self.test = test
882 self.lineno = lineno
884 def getChildren(self): argument
885 return self.test,
887 def getChildNodes(self): argument
888 return self.test,
890 def __repr__(self): argument
891 return "ListCompIf(%s)" % (repr(self.test),)
894 def __init__(self, expr, quals, lineno=None): argument
895 self.expr = expr
896 self.quals = quals
897 self.lineno = lineno
899 def getChildren(self): argument
901 children.append(self.expr)
902 children.extend(flatten(self.quals))
905 def getChildNodes(self): argument
907 nodelist.append(self.expr)
908 nodelist.extend(flatten_nodes(self.quals))
911 def __repr__(self): argument
912 return "SetComp(%s, %s)" % (repr(self.expr), repr(self.quals))
915 def __init__(self, key, value, quals, lineno=None): argument
916 self.key = key
917 self.value = value
918 self.quals = quals
919 self.lineno = lineno
921 def getChildren(self): argument
923 children.append(self.key)
924 children.append(self.value)
925 children.extend(flatten(self.quals))
928 def getChildNodes(self): argument
930 nodelist.append(self.key)
931 nodelist.append(self.value)
932 nodelist.extend(flatten_nodes(self.quals))
935 def __repr__(self): argument
936 return "DictComp(%s, %s, %s)" % (repr(self.key), repr(self.value), repr(self.quals))
939 def __init__(self, leftright, lineno=None): argument
940 self.left = leftright[0]
941 self.right = leftright[1]
942 self.lineno = lineno
944 def getChildren(self): argument
945 return self.left, self.right
947 def getChildNodes(self): argument
948 return self.left, self.right
950 def __repr__(self): argument
951 return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
954 def __init__(self, doc, node, lineno=None): argument
955 self.doc = doc
956 self.node = node
957 self.lineno = lineno
959 def getChildren(self): argument
960 return self.doc, self.node
962 def getChildNodes(self): argument
963 return self.node,
965 def __repr__(self): argument
966 return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
969 def __init__(self, leftright, lineno=None): argument
970 self.left = leftright[0]
971 self.right = leftright[1]
972 self.lineno = lineno
974 def getChildren(self): argument
975 return self.left, self.right
977 def getChildNodes(self): argument
978 return self.left, self.right
980 def __repr__(self): argument
981 return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
984 def __init__(self, name, lineno=None): argument
985 self.name = name
986 self.lineno = lineno
988 def getChildren(self): argument
989 return self.name,
991 def getChildNodes(self): argument
994 def __repr__(self): argument
995 return "Name(%s)" % (repr(self.name),)
998 def __init__(self, expr, lineno=None): argument
999 self.expr = expr
1000 self.lineno = lineno
1002 def getChildren(self): argument
1003 return self.expr,
1005 def getChildNodes(self): argument
1006 return self.expr,
1008 def __repr__(self): argument
1009 return "Not(%s)" % (repr(self.expr),)
1012 def __init__(self, nodes, lineno=None): argument
1013 self.nodes = nodes
1014 self.lineno = lineno
1016 def getChildren(self): argument
1017 return tuple(flatten(self.nodes))
1019 def getChildNodes(self): argument
1021 nodelist.extend(flatten_nodes(self.nodes))
1024 def __repr__(self): argument
1025 return "Or(%s)" % (repr(self.nodes),)
1028 def __init__(self, lineno=None): argument
1029 self.lineno = lineno
1031 def getChildren(self): argument
1034 def getChildNodes(self): argument
1037 def __repr__(self): argument
1041 def __init__(self, leftright, lineno=None): argument
1042 self.left = leftright[0]
1043 self.right = leftright[1]
1044 self.lineno = lineno
1046 def getChildren(self): argument
1047 return self.left, self.right
1049 def getChildNodes(self): argument
1050 return self.left, self.right
1052 def __repr__(self): argument
1053 return "Power((%s, %s))" % (repr(self.left), repr(self.right))
1056 def __init__(self, nodes, dest, lineno=None): argument
1057 self.nodes = nodes
1058 self.dest = dest
1059 self.lineno = lineno
1061 def getChildren(self): argument
1063 children.extend(flatten(self.nodes))
1064 children.append(self.dest)
1067 def getChildNodes(self): argument
1069 nodelist.extend(flatten_nodes(self.nodes))
1070 if self.dest is not None:
1071 nodelist.append(self.dest)
1074 def __repr__(self): argument
1075 return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
1078 def __init__(self, nodes, dest, lineno=None): argument
1079 self.nodes = nodes
1080 self.dest = dest
1081 self.lineno = lineno
1083 def getChildren(self): argument
1085 children.extend(flatten(self.nodes))
1086 children.append(self.dest)
1089 def getChildNodes(self): argument
1091 nodelist.extend(flatten_nodes(self.nodes))
1092 if self.dest is not None:
1093 nodelist.append(self.dest)
1096 def __repr__(self): argument
1097 return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
1100 def __init__(self, expr1, expr2, expr3, lineno=None): argument
1101 self.expr1 = expr1
1102 self.expr2 = expr2
1103 self.expr3 = expr3
1104 self.lineno = lineno
1106 def getChildren(self): argument
1108 children.append(self.expr1)
1109 children.append(self.expr2)
1110 children.append(self.expr3)
1113 def getChildNodes(self): argument
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)
1123 def __repr__(self): argument
1124 return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
1127 def __init__(self, value, lineno=None): argument
1128 self.value = value
1129 self.lineno = lineno
1131 def getChildren(self): argument
1132 return self.value,
1134 def getChildNodes(self): argument
1135 return self.value,
1137 def __repr__(self): argument
1138 return "Return(%s)" % (repr(self.value),)
1141 def __init__(self, leftright, lineno=None): argument
1142 self.left = leftright[0]
1143 self.right = leftright[1]
1144 self.lineno = lineno
1146 def getChildren(self): argument
1147 return self.left, self.right
1149 def getChildNodes(self): argument
1150 return self.left, self.right
1152 def __repr__(self): argument
1153 return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
1156 def __init__(self, nodes, lineno=None): argument
1157 self.nodes = nodes
1158 self.lineno = lineno
1160 def getChildren(self): argument
1161 return tuple(flatten(self.nodes))
1163 def getChildNodes(self): argument
1165 nodelist.extend(flatten_nodes(self.nodes))
1168 def __repr__(self): argument
1169 return "Set(%s)" % (repr(self.nodes),)
1172 def __init__(self, expr, flags, lower, upper, lineno=None): argument
1173 self.expr = expr
1174 self.flags = flags
1175 self.lower = lower
1176 self.upper = upper
1177 self.lineno = lineno
1179 def getChildren(self): argument
1181 children.append(self.expr)
1182 children.append(self.flags)
1183 children.append(self.lower)
1184 children.append(self.upper)
1187 def getChildNodes(self): argument
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)
1196 def __repr__(self): argument
1197 …return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.u…
1200 def __init__(self, nodes, lineno=None): argument
1201 self.nodes = nodes
1202 self.lineno = lineno
1204 def getChildren(self): argument
1205 return tuple(flatten(self.nodes))
1207 def getChildNodes(self): argument
1209 nodelist.extend(flatten_nodes(self.nodes))
1212 def __repr__(self): argument
1213 return "Sliceobj(%s)" % (repr(self.nodes),)
1216 def __init__(self, nodes, lineno=None): argument
1217 self.nodes = nodes
1218 self.lineno = lineno
1220 def getChildren(self): argument
1221 return tuple(flatten(self.nodes))
1223 def getChildNodes(self): argument
1225 nodelist.extend(flatten_nodes(self.nodes))
1228 def __repr__(self): argument
1229 return "Stmt(%s)" % (repr(self.nodes),)
1232 def __init__(self, leftright, lineno=None): argument
1233 self.left = leftright[0]
1234 self.right = leftright[1]
1235 self.lineno = lineno
1237 def getChildren(self): argument
1238 return self.left, self.right
1240 def getChildNodes(self): argument
1241 return self.left, self.right
1243 def __repr__(self): argument
1244 return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
1247 def __init__(self, expr, flags, subs, lineno=None): argument
1248 self.expr = expr
1249 self.flags = flags
1250 self.subs = subs
1251 self.lineno = lineno
1253 def getChildren(self): argument
1255 children.append(self.expr)
1256 children.append(self.flags)
1257 children.extend(flatten(self.subs))
1260 def getChildNodes(self): argument
1262 nodelist.append(self.expr)
1263 nodelist.extend(flatten_nodes(self.subs))
1266 def __repr__(self): argument
1267 return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
1270 def __init__(self, body, handlers, else_, lineno=None): argument
1271 self.body = body
1272 self.handlers = handlers
1273 self.else_ = else_
1274 self.lineno = lineno
1276 def getChildren(self): argument
1278 children.append(self.body)
1279 children.extend(flatten(self.handlers))
1280 children.append(self.else_)
1283 def getChildNodes(self): argument
1285 nodelist.append(self.body)
1286 nodelist.extend(flatten_nodes(self.handlers))
1287 if self.else_ is not None:
1288 nodelist.append(self.else_)
1291 def __repr__(self): argument
1292 return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
1295 def __init__(self, body, final, lineno=None): argument
1296 self.body = body
1297 self.final = final
1298 self.lineno = lineno
1300 def getChildren(self): argument
1301 return self.body, self.final
1303 def getChildNodes(self): argument
1304 return self.body, self.final
1306 def __repr__(self): argument
1307 return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
1310 def __init__(self, nodes, lineno=None): argument
1311 self.nodes = nodes
1312 self.lineno = lineno
1314 def getChildren(self): argument
1315 return tuple(flatten(self.nodes))
1317 def getChildNodes(self): argument
1319 nodelist.extend(flatten_nodes(self.nodes))
1322 def __repr__(self): argument
1323 return "Tuple(%s)" % (repr(self.nodes),)
1326 def __init__(self, expr, lineno=None): argument
1327 self.expr = expr
1328 self.lineno = lineno
1330 def getChildren(self): argument
1331 return self.expr,
1333 def getChildNodes(self): argument
1334 return self.expr,
1336 def __repr__(self): argument
1337 return "UnaryAdd(%s)" % (repr(self.expr),)
1340 def __init__(self, expr, lineno=None): argument
1341 self.expr = expr
1342 self.lineno = lineno
1344 def getChildren(self): argument
1345 return self.expr,
1347 def getChildNodes(self): argument
1348 return self.expr,
1350 def __repr__(self): argument
1351 return "UnarySub(%s)" % (repr(self.expr),)
1354 def __init__(self, test, body, else_, lineno=None): argument
1355 self.test = test
1356 self.body = body
1357 self.else_ = else_
1358 self.lineno = lineno
1360 def getChildren(self): argument
1362 children.append(self.test)
1363 children.append(self.body)
1364 children.append(self.else_)
1367 def getChildNodes(self): argument
1369 nodelist.append(self.test)
1370 nodelist.append(self.body)
1371 if self.else_ is not None:
1372 nodelist.append(self.else_)
1375 def __repr__(self): argument
1376 return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
1379 def __init__(self, expr, vars, body, lineno=None): argument
1380 self.expr = expr
1381 self.vars = vars
1382 self.body = body
1383 self.lineno = lineno
1385 def getChildren(self): argument
1387 children.append(self.expr)
1388 children.append(self.vars)
1389 children.append(self.body)
1392 def getChildNodes(self): argument
1394 nodelist.append(self.expr)
1395 if self.vars is not None:
1396 nodelist.append(self.vars)
1397 nodelist.append(self.body)
1400 def __repr__(self): argument
1401 return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
1404 def __init__(self, value, lineno=None): argument
1405 self.value = value
1406 self.lineno = lineno
1408 def getChildren(self): argument
1409 return self.value,
1411 def getChildNodes(self): argument
1412 return self.value,
1414 def __repr__(self): argument
1415 return "Yield(%s)" % (repr(self.value),)