Lines Matching refs:node
150 def visitDict(self, node):
153 def visitGlobal(self, node):
154 for name in node.names:
157 def visitFunction(self, node):
158 self.names.add(node.name)
160 def visitLambda(self, node):
163 def visitImport(self, node):
164 for name, alias in node.names:
167 def visitFrom(self, node):
168 for name, alias in node.names:
171 def visitClass(self, node):
172 self.names.add(node.name)
174 def visitAssName(self, node):
175 self.names.add(node.name)
177 def is_constant_false(node):
178 if isinstance(node, ast.Const):
179 if not node.value:
316 def set_lineno(self, node, force=False):
319 The instruction is considered necessary if the node has a
325 There are no rules for when an AST node should have a lineno
330 lineno = getattr(node, 'lineno', None)
346 def visitModule(self, node):
347 self.scopes = self.parseSymbols(node)
348 self.scope = self.scopes[node]
350 if node.doc:
351 self.emit('LOAD_CONST', node.doc)
353 lnf = walk(node.node, self.NameFinder(), verbose=0)
355 self.visit(node.node)
359 def visitExpression(self, node):
360 self.set_lineno(node)
361 self.scopes = self.parseSymbols(node)
362 self.scope = self.scopes[node]
363 self.visit(node.node)
366 def visitFunction(self, node):
367 self._visitFuncOrLambda(node, isLambda=0)
368 if node.doc:
369 self.setDocstring(node.doc)
370 self.storeName(node.name)
372 def visitLambda(self, node):
373 self._visitFuncOrLambda(node, isLambda=1)
375 def _visitFuncOrLambda(self, node, isLambda=0):
376 if not isLambda and node.decorators:
377 for decorator in node.decorators.nodes:
379 ndecorators = len(node.decorators.nodes)
383 gen = self.FunctionGen(node, self.scopes, isLambda,
385 walk(node.code, gen)
387 self.set_lineno(node)
388 for default in node.defaults:
390 self._makeClosure(gen, len(node.defaults))
394 def visitClass(self, node):
395 gen = self.ClassGen(node, self.scopes,
397 walk(node.code, gen)
399 self.set_lineno(node)
400 self.emit('LOAD_CONST', node.name)
401 for base in node.bases:
403 self.emit('BUILD_TUPLE', len(node.bases))
407 self.storeName(node.name)
413 def visitIf(self, node):
415 numtests = len(node.tests)
417 test, suite = node.tests[i]
429 if node.else_:
430 self.visit(node.else_)
433 def visitWhile(self, node):
434 self.set_lineno(node)
445 self.set_lineno(node, force=True)
446 self.visit(node.test)
450 self.visit(node.body)
456 if node.else_:
457 self.visit(node.else_)
460 def visitFor(self, node):
466 self.set_lineno(node)
468 self.visit(node.list)
472 self.set_lineno(node, force=1)
474 self.visit(node.assign)
475 self.visit(node.body)
480 if node.else_:
481 self.visit(node.else_)
484 def visitBreak(self, node):
487 (node.filename, node.lineno)
488 self.set_lineno(node)
491 def visitContinue(self, node):
494 (node.filename, node.lineno)
497 self.set_lineno(node)
501 self.set_lineno(node)
511 (node.filename, node.lineno)
516 raise SyntaxError, msg % (node.filename, node.lineno)
518 def visitTest(self, node, jump):
520 for child in node.nodes[:-1]:
524 node.nodes[-1])
527 def visitAnd(self, node):
528 self.visitTest(node, 'JUMP_IF_FALSE_OR_POP')
530 def visitOr(self, node):
531 self.visitTest(node, 'JUMP_IF_TRUE_OR_POP')
533 def visitIfExp(self, node):
536 self.visit(node.test)
538 self.visit(node.then)
541 self.visit(node.else_)
544 def visitCompare(self, node):
545 self.visit(node.expr)
547 for op, code in node.ops[:-1]:
555 if node.ops:
556 op, code = node.ops[-1]
559 if len(node.ops) > 1:
568 def visitListComp(self, node):
569 self.set_lineno(node)
574 for i, for_ in zip(range(len(node.quals)), node.quals):
583 self.visit(node.expr)
584 self.emit('LIST_APPEND', len(node.quals) + 1)
592 def visitSetComp(self, node):
593 self.set_lineno(node)
598 for i, for_ in zip(range(len(node.quals)), node.quals):
607 self.visit(node.expr)
608 self.emit('SET_ADD', len(node.quals) + 1)
616 def visitDictComp(self, node):
617 self.set_lineno(node)
622 for i, for_ in zip(range(len(node.quals)), node.quals):
631 self.visit(node.value)
632 self.visit(node.key)
633 self.emit('MAP_ADD', len(node.quals) + 1)
641 def visitListCompFor(self, node):
645 self.visit(node.list)
648 self.set_lineno(node, force=True)
651 self.visit(node.assign)
654 def visitListCompIf(self, node, branch):
655 self.set_lineno(node, force=True)
656 self.visit(node.test)
672 def visitGenExpr(self, node):
673 gen = GenExprCodeGenerator(node, self.scopes, self.class_name,
675 walk(node.code, gen)
677 self.set_lineno(node)
680 self.visit(node.code.quals[0].iter)
684 def visitGenExprInner(self, node):
685 self.set_lineno(node)
689 for i, for_ in zip(range(len(node.quals)), node.quals):
698 self.visit(node.expr)
713 def visitGenExprFor(self, node):
721 if node.is_outmost:
724 self.visit(node.iter)
728 self.set_lineno(node, force=True)
731 self.visit(node.assign)
734 def visitGenExprIf(self, node, branch):
735 self.set_lineno(node, force=True)
736 self.visit(node.test)
742 def visitAssert(self, node):
747 self.set_lineno(node)
752 self.visit(node.test)
756 if node.fail:
757 self.visit(node.fail)
763 def visitRaise(self, node):
764 self.set_lineno(node)
766 if node.expr1:
767 self.visit(node.expr1)
769 if node.expr2:
770 self.visit(node.expr2)
772 if node.expr3:
773 self.visit(node.expr3)
777 def visitTryExcept(self, node):
781 if node.else_:
785 self.set_lineno(node)
789 self.visit(node.body)
795 last = len(node.handlers) - 1
796 for i in range(len(node.handlers)):
797 expr, target, body = node.handlers[i]
819 if node.else_:
821 self.visit(node.else_)
824 def visitTryFinally(self, node):
827 self.set_lineno(node)
831 self.visit(node.body)
837 self.visit(node.final)
843 def visitWith(self, node):
848 self.set_lineno(node)
849 self.visit(node.expr)
855 if node.vars is None:
862 if node.vars is not None:
865 self.visit(node.vars)
866 self.visit(node.body)
879 def visitDiscard(self, node):
880 self.set_lineno(node)
881 self.visit(node.expr)
884 def visitConst(self, node):
885 self.emit('LOAD_CONST', node.value)
887 def visitKeyword(self, node):
888 self.emit('LOAD_CONST', node.name)
889 self.visit(node.expr)
891 def visitGlobal(self, node):
895 def visitName(self, node):
896 self.set_lineno(node)
897 self.loadName(node.name)
899 def visitPass(self, node):
900 self.set_lineno(node)
902 def visitImport(self, node):
903 self.set_lineno(node)
905 for name, alias in node.names:
917 def visitFrom(self, node):
918 self.set_lineno(node)
919 level = node.level
922 fromlist = tuple(name for (name, alias) in node.names)
926 self.emit('IMPORT_NAME', node.modname)
927 for name, alias in node.names:
933 assert len(node.names) == 1
950 def visitGetattr(self, node):
951 self.visit(node.expr)
952 self.emit('LOAD_ATTR', self.mangle(node.attrname))
956 def visitAssign(self, node):
957 self.set_lineno(node)
958 self.visit(node.expr)
959 dups = len(node.nodes) - 1
960 for i in range(len(node.nodes)):
961 elt = node.nodes[i]
964 if isinstance(elt, ast.Node):
967 def visitAssName(self, node):
968 if node.flags == 'OP_ASSIGN':
969 self.storeName(node.name)
970 elif node.flags == 'OP_DELETE':
971 self.set_lineno(node)
972 self.delName(node.name)
974 print "oops", node.flags
976 def visitAssAttr(self, node):
977 self.visit(node.expr)
978 if node.flags == 'OP_ASSIGN':
979 self.emit('STORE_ATTR', self.mangle(node.attrname))
980 elif node.flags == 'OP_DELETE':
981 self.emit('DELETE_ATTR', self.mangle(node.attrname))
983 print "warning: unexpected flags:", node.flags
984 print node
986 def _visitAssSequence(self, node, op='UNPACK_SEQUENCE'):
987 if findOp(node) != 'OP_DELETE':
988 self.emit(op, len(node.nodes))
989 for child in node.nodes:
996 def visitAssTuple(self, node):
997 self._visitAssSequence(node, 'UNPACK_TUPLE')
999 def visitAssList(self, node):
1000 self._visitAssSequence(node, 'UNPACK_LIST')
1004 def visitAugAssign(self, node):
1005 self.set_lineno(node)
1006 aug_node = wrap_aug(node.node)
1008 self.visit(node.expr)
1009 self.emit(self._augmented_opcode[node.op])
1027 def visitAugName(self, node, mode):
1029 self.loadName(node.name)
1031 self.storeName(node.name)
1033 def visitAugGetattr(self, node, mode):
1035 self.visit(node.expr)
1037 self.emit('LOAD_ATTR', self.mangle(node.attrname))
1040 self.emit('STORE_ATTR', self.mangle(node.attrname))
1042 def visitAugSlice(self, node, mode):
1044 self.visitSlice(node, 1)
1047 if node.lower:
1049 if node.upper:
1059 def visitAugSubscript(self, node, mode):
1061 self.visitSubscript(node, 1)
1066 def visitExec(self, node):
1067 self.visit(node.expr)
1068 if node.locals is None:
1071 self.visit(node.locals)
1072 if node.globals is None:
1075 self.visit(node.globals)
1078 def visitCallFunc(self, node):
1081 self.set_lineno(node)
1082 self.visit(node.node)
1083 for arg in node.args:
1089 if node.star_args is not None:
1090 self.visit(node.star_args)
1091 if node.dstar_args is not None:
1092 self.visit(node.dstar_args)
1093 have_star = node.star_args is not None
1094 have_dstar = node.dstar_args is not None
1098 def visitPrint(self, node, newline=0):
1099 self.set_lineno(node)
1100 if node.dest:
1101 self.visit(node.dest)
1102 for child in node.nodes:
1103 if node.dest:
1106 if node.dest:
1111 if node.dest and not newline:
1114 def visitPrintnl(self, node):
1115 self.visitPrint(node, newline=1)
1116 if node.dest:
1121 def visitReturn(self, node):
1122 self.set_lineno(node)
1123 self.visit(node.value)
1126 def visitYield(self, node):
1127 self.set_lineno(node)
1128 self.visit(node.value)
1133 def visitSlice(self, node, aug_flag=None):
1135 self.visit(node.expr)
1137 if node.lower:
1138 self.visit(node.lower)
1140 if node.upper:
1141 self.visit(node.upper)
1150 if node.flags == 'OP_APPLY':
1152 elif node.flags == 'OP_ASSIGN':
1154 elif node.flags == 'OP_DELETE':
1157 print "weird slice", node.flags
1160 def visitSubscript(self, node, aug_flag=None):
1161 self.visit(node.expr)
1162 for sub in node.subs:
1164 if len(node.subs) > 1:
1165 self.emit('BUILD_TUPLE', len(node.subs))
1168 if node.flags == 'OP_APPLY':
1170 elif node.flags == 'OP_ASSIGN':
1172 elif node.flags == 'OP_DELETE':
1177 def binaryOp(self, node, op):
1178 self.visit(node.left)
1179 self.visit(node.right)
1182 def visitAdd(self, node):
1183 return self.binaryOp(node, 'BINARY_ADD')
1185 def visitSub(self, node):
1186 return self.binaryOp(node, 'BINARY_SUBTRACT')
1188 def visitMul(self, node):
1189 return self.binaryOp(node, 'BINARY_MULTIPLY')
1191 def visitDiv(self, node):
1192 return self.binaryOp(node, self._div_op)
1194 def visitFloorDiv(self, node):
1195 return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE')
1197 def visitMod(self, node):
1198 return self.binaryOp(node, 'BINARY_MODULO')
1200 def visitPower(self, node):
1201 return self.binaryOp(node, 'BINARY_POWER')
1203 def visitLeftShift(self, node):
1204 return self.binaryOp(node, 'BINARY_LSHIFT')
1206 def visitRightShift(self, node):
1207 return self.binaryOp(node, 'BINARY_RSHIFT')
1211 def unaryOp(self, node, op):
1212 self.visit(node.expr)
1215 def visitInvert(self, node):
1216 return self.unaryOp(node, 'UNARY_INVERT')
1218 def visitUnarySub(self, node):
1219 return self.unaryOp(node, 'UNARY_NEGATIVE')
1221 def visitUnaryAdd(self, node):
1222 return self.unaryOp(node, 'UNARY_POSITIVE')
1224 def visitUnaryInvert(self, node):
1225 return self.unaryOp(node, 'UNARY_INVERT')
1227 def visitNot(self, node):
1228 return self.unaryOp(node, 'UNARY_NOT')
1230 def visitBackquote(self, node):
1231 return self.unaryOp(node, 'UNARY_CONVERT')
1237 for node in nodes[1:]:
1238 self.visit(node)
1241 def visitBitand(self, node):
1242 return self.bitOp(node.nodes, 'BINARY_AND')
1244 def visitBitor(self, node):
1245 return self.bitOp(node.nodes, 'BINARY_OR')
1247 def visitBitxor(self, node):
1248 return self.bitOp(node.nodes, 'BINARY_XOR')
1252 def visitEllipsis(self, node):
1255 def visitTuple(self, node):
1256 self.set_lineno(node)
1257 for elt in node.nodes:
1259 self.emit('BUILD_TUPLE', len(node.nodes))
1261 def visitList(self, node):
1262 self.set_lineno(node)
1263 for elt in node.nodes:
1265 self.emit('BUILD_LIST', len(node.nodes))
1267 def visitSet(self, node):
1268 self.set_lineno(node)
1269 for elt in node.nodes:
1271 self.emit('BUILD_SET', len(node.nodes))
1273 def visitSliceobj(self, node):
1274 for child in node.nodes:
1276 self.emit('BUILD_SLICE', len(node.nodes))
1278 def visitDict(self, node):
1279 self.set_lineno(node)
1281 for k, v in node.items:
1340 def visitDiscard(self, node):
1343 self.visit(node.expr)
1497 def findOp(node):
1500 walk(node, v, verbose=0)
1506 def visitAssName(self, node):
1508 self.op = node.flags
1509 elif self.op != node.flags:
1518 wrapper classes. In visitAugAssign, the left-hand expression node
1520 for that node . The second time the visit uses a different method
1550 def wrap_aug(node):
1551 return wrapper[node.__class__](node)
