1 import imp 2 import os 3 import marshal 4 import struct 5 import sys 6 from cStringIO import StringIO 7 8 from compiler import ast, parse, walk, syntax 9 from compiler import pyassem, misc, future, symbols 10 from compiler.consts import SC_LOCAL, SC_GLOBAL_IMPLICIT, SC_GLOBAL_EXPLICIT, \ 11 SC_FREE, SC_CELL 12 from compiler.consts import (CO_VARARGS, CO_VARKEYWORDS, CO_NEWLOCALS, 13 CO_NESTED, CO_GENERATOR, CO_FUTURE_DIVISION, 14 CO_FUTURE_ABSIMPORT, CO_FUTURE_WITH_STATEMENT, CO_FUTURE_PRINT_FUNCTION) 15 from compiler.pyassem import TupleArg 16 17 # XXX The version-specific code can go, since this code only works with 2.x. 18 # Do we have Python 1.x or Python 2.x? 19 try: 20 VERSION = sys.version_info[0] 21 except AttributeError: 22 VERSION = 1 23 24 callfunc_opcode_info = { 25 # (Have *args, Have **args) : opcode 26 (0,0) : "CALL_FUNCTION", 27 (1,0) : "CALL_FUNCTION_VAR", 28 (0,1) : "CALL_FUNCTION_KW", 29 (1,1) : "CALL_FUNCTION_VAR_KW", 30 } 31 32 LOOP = 1 33 EXCEPT = 2 34 TRY_FINALLY = 3 35 END_FINALLY = 4 36 37 def compileFile(filename, display=0): 38 f = open(filename, 'U') 39 buf = f.read() 40 f.close() 41 mod = Module(buf, filename) 42 try: 43 mod.compile(display) 44 except SyntaxError: 45 raise 46 else: 47 f = open(filename + "c", "wb") 48 mod.dump(f) 49 f.close() 50 51 def compile(source, filename, mode, flags=None, dont_inherit=None): 52 """Replacement for builtin compile() function""" 53 if flags is not None or dont_inherit is not None: 54 raise RuntimeError, "not implemented yet" 55 56 if mode == "single": 57 gen = Interactive(source, filename) 58 elif mode == "exec": 59 gen = Module(source, filename) 60 elif mode == "eval": 61 gen = Expression(source, filename) 62 else: 63 raise ValueError("compile() 3rd arg must be 'exec' or " 64 "'eval' or 'single'") 65 gen.compile() 66 return gen.code 67 68 class AbstractCompileMode: 69 70 mode = None # defined by subclass 71 72 def __init__(self, source, filename): 73 self.source = source 74 self.filename = filename 75 self.code = None 76 77 def _get_tree(self): 78 tree = parse(self.source, self.mode) 79 misc.set_filename(self.filename, tree) 80 syntax.check(tree) 81 return tree 82 83 def compile(self): 84 pass # implemented by subclass 85 86 def getCode(self): 87 return self.code 88 89 class Expression(AbstractCompileMode): 90 91 mode = "eval" 92 93 def compile(self): 94 tree = self._get_tree() 95 gen = ExpressionCodeGenerator(tree) 96 self.code = gen.getCode() 97 98 class Interactive(AbstractCompileMode): 99 100 mode = "single" 101 102 def compile(self): 103 tree = self._get_tree() 104 gen = InteractiveCodeGenerator(tree) 105 self.code = gen.getCode() 106 107 class Module(AbstractCompileMode): 108 109 mode = "exec" 110 111 def compile(self, display=0): 112 tree = self._get_tree() 113 gen = ModuleCodeGenerator(tree) 114 if display: 115 import pprint 116 print pprint.pprint(tree) 117 self.code = gen.getCode() 118 119 def dump(self, f): 120 f.write(self.getPycHeader()) 121 marshal.dump(self.code, f) 122 123 MAGIC = imp.get_magic() 124 125 def getPycHeader(self): 126 # compile.c uses marshal to write a long directly, with 127 # calling the interface that would also generate a 1-byte code 128 # to indicate the type of the value. simplest way to get the 129 # same effect is to call marshal and then skip the code. 130 mtime = os.path.getmtime(self.filename) 131 mtime = struct.pack('<i', mtime) 132 return self.MAGIC + mtime 133 134 class LocalNameFinder: 135 """Find local names in scope""" 136 def __init__(self, names=()): 137 self.names = misc.Set() 138 self.globals = misc.Set() 139 for name in names: 140 self.names.add(name) 141 142 # XXX list comprehensions and for loops 143 144 def getLocals(self): 145 for elt in self.globals.elements(): 146 if self.names.has_elt(elt): 147 self.names.remove(elt) 148 return self.names 149 150 def visitDict(self, node): 151 pass 152 153 def visitGlobal(self, node): 154 for name in node.names: 155 self.globals.add(name) 156 157 def visitFunction(self, node): 158 self.names.add(node.name) 159 160 def visitLambda(self, node): 161 pass 162 163 def visitImport(self, node): 164 for name, alias in node.names: 165 self.names.add(alias or name) 166 167 def visitFrom(self, node): 168 for name, alias in node.names: 169 self.names.add(alias or name) 170 171 def visitClass(self, node): 172 self.names.add(node.name) 173 174 def visitAssName(self, node): 175 self.names.add(node.name) 176 177 def is_constant_false(node): 178 if isinstance(node, ast.Const): 179 if not node.value: 180 return 1 181 return 0 182 183 class CodeGenerator: 184 """Defines basic code generator for Python bytecode 185 186 This class is an abstract base class. Concrete subclasses must 187 define an __init__() that defines self.graph and then calls the 188 __init__() defined in this class. 189 190 The concrete class must also define the class attributes 191 NameFinder, FunctionGen, and ClassGen. These attributes can be 192 defined in the initClass() method, which is a hook for 193 initializing these methods after all the classes have been 194 defined. 195 """ 196 197 optimized = 0 # is namespace access optimized? 198 __initialized = None 199 class_name = None # provide default for instance variable 200 201 def __init__(self): 202 if self.__initialized is None: 203 self.initClass() 204 self.__class__.__initialized = 1 205 self.checkClass() 206 self.locals = misc.Stack() 207 self.setups = misc.Stack() 208 self.last_lineno = None 209 self._setupGraphDelegation() 210 self._div_op = "BINARY_DIVIDE" 211 212 # XXX set flags based on future features 213 futures = self.get_module().futures 214 for feature in futures: 215 if feature == "division": 216 self.graph.setFlag(CO_FUTURE_DIVISION) 217 self._div_op = "BINARY_TRUE_DIVIDE" 218 elif feature == "absolute_import": 219 self.graph.setFlag(CO_FUTURE_ABSIMPORT) 220 elif feature == "with_statement": 221 self.graph.setFlag(CO_FUTURE_WITH_STATEMENT) 222 elif feature == "print_function": 223 self.graph.setFlag(CO_FUTURE_PRINT_FUNCTION) 224 225 def initClass(self): 226 """This method is called once for each class""" 227 228 def checkClass(self): 229 """Verify that class is constructed correctly""" 230 try: 231 assert hasattr(self, 'graph') 232 assert getattr(self, 'NameFinder') 233 assert getattr(self, 'FunctionGen') 234 assert getattr(self, 'ClassGen') 235 except AssertionError, msg: 236 intro = "Bad class construction for %s" % self.__class__.__name__ 237 raise AssertionError, intro 238 239 def _setupGraphDelegation(self): 240 self.emit = self.graph.emit 241 self.newBlock = self.graph.newBlock 242 self.startBlock = self.graph.startBlock 243 self.nextBlock = self.graph.nextBlock 244 self.setDocstring = self.graph.setDocstring 245 246 def getCode(self): 247 """Return a code object""" 248 return self.graph.getCode() 249 250 def mangle(self, name): 251 if self.class_name is not None: 252 return misc.mangle(name, self.class_name) 253 else: 254 return name 255 256 def parseSymbols(self, tree): 257 s = symbols.SymbolVisitor() 258 walk(tree, s) 259 return s.scopes 260 261 def get_module(self): 262 raise RuntimeError, "should be implemented by subclasses" 263 264 # Next five methods handle name access 265 266 def isLocalName(self, name): 267 return self.locals.top().has_elt(name) 268 269 def storeName(self, name): 270 self._nameOp('STORE', name) 271 272 def loadName(self, name): 273 self._nameOp('LOAD', name) 274 275 def delName(self, name): 276 self._nameOp('DELETE', name) 277 278 def _nameOp(self, prefix, name): 279 name = self.mangle(name) 280 scope = self.scope.check_name(name) 281 if scope == SC_LOCAL: 282 if not self.optimized: 283 self.emit(prefix + '_NAME', name) 284 else: 285 self.emit(prefix + '_FAST', name) 286 elif scope == SC_GLOBAL_EXPLICIT: 287 self.emit(prefix + '_GLOBAL', name) 288 elif scope == SC_GLOBAL_IMPLICIT: 289 if not self.optimized: 290 self.emit(prefix + '_NAME', name) 291 else: 292 self.emit(prefix + '_GLOBAL', name) 293 elif scope == SC_FREE or scope == SC_CELL: 294 self.emit(prefix + '_DEREF', name) 295 else: 296 raise RuntimeError, "unsupported scope for var %s: %d" % \ 297 (name, scope) 298 299 def _implicitNameOp(self, prefix, name): 300 """Emit name ops for names generated implicitly by for loops 301 302 The interpreter generates names that start with a period or 303 dollar sign. The symbol table ignores these names because 304 they aren't present in the program text. 305 """ 306 if self.optimized: 307 self.emit(prefix + '_FAST', name) 308 else: 309 self.emit(prefix + '_NAME', name) 310 311 # The set_lineno() function and the explicit emit() calls for 312 # SET_LINENO below are only used to generate the line number table. 313 # As of Python 2.3, the interpreter does not have a SET_LINENO 314 # instruction. pyassem treats SET_LINENO opcodes as a special case. 315 316 def set_lineno(self, node, force=False): 317 """Emit SET_LINENO if necessary. 318 319 The instruction is considered necessary if the node has a 320 lineno attribute and it is different than the last lineno 321 emitted. 322 323 Returns true if SET_LINENO was emitted. 324 325 There are no rules for when an AST node should have a lineno 326 attribute. The transformer and AST code need to be reviewed 327 and a consistent policy implemented and documented. Until 328 then, this method works around missing line numbers. 329 """ 330 lineno = getattr(node, 'lineno', None) 331 if lineno is not None and (lineno != self.last_lineno 332 or force): 333 self.emit('SET_LINENO', lineno) 334 self.last_lineno = lineno 335 return True 336 return False 337 338 # The first few visitor methods handle nodes that generator new 339 # code objects. They use class attributes to determine what 340 # specialized code generators to use. 341 342 NameFinder = LocalNameFinder 343 FunctionGen = None 344 ClassGen = None 345 346 def visitModule(self, node): 347 self.scopes = self.parseSymbols(node) 348 self.scope = self.scopes[node] 349 self.emit('SET_LINENO', 0) 350 if node.doc: 351 self.emit('LOAD_CONST', node.doc) 352 self.storeName('__doc__') 353 lnf = walk(node.node, self.NameFinder(), verbose=0) 354 self.locals.push(lnf.getLocals()) 355 self.visit(node.node) 356 self.emit('LOAD_CONST', None) 357 self.emit('RETURN_VALUE') 358 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) 364 self.emit('RETURN_VALUE') 365 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) 371 372 def visitLambda(self, node): 373 self._visitFuncOrLambda(node, isLambda=1) 374 375 def _visitFuncOrLambda(self, node, isLambda=0): 376 if not isLambda and node.decorators: 377 for decorator in node.decorators.nodes: 378 self.visit(decorator) 379 ndecorators = len(node.decorators.nodes) 380 else: 381 ndecorators = 0 382 383 gen = self.FunctionGen(node, self.scopes, isLambda, 384 self.class_name, self.get_module()) 385 walk(node.code, gen) 386 gen.finish() 387 self.set_lineno(node) 388 for default in node.defaults: 389 self.visit(default) 390 self._makeClosure(gen, len(node.defaults)) 391 for i in range(ndecorators): 392 self.emit('CALL_FUNCTION', 1) 393 394 def visitClass(self, node): 395 gen = self.ClassGen(node, self.scopes, 396 self.get_module()) 397 walk(node.code, gen) 398 gen.finish() 399 self.set_lineno(node) 400 self.emit('LOAD_CONST', node.name) 401 for base in node.bases: 402 self.visit(base) 403 self.emit('BUILD_TUPLE', len(node.bases)) 404 self._makeClosure(gen, 0) 405 self.emit('CALL_FUNCTION', 0) 406 self.emit('BUILD_CLASS') 407 self.storeName(node.name) 408 409 # The rest are standard visitor methods 410 411 # The next few implement control-flow statements 412 413 def visitIf(self, node): 414 end = self.newBlock() 415 numtests = len(node.tests) 416 for i in range(numtests): 417 test, suite = node.tests[i] 418 if is_constant_false(test): 419 # XXX will need to check generator stuff here 420 continue 421 self.set_lineno(test) 422 self.visit(test) 423 nextTest = self.newBlock() 424 self.emit('POP_JUMP_IF_FALSE', nextTest) 425 self.nextBlock() 426 self.visit(suite) 427 self.emit('JUMP_FORWARD', end) 428 self.startBlock(nextTest) 429 if node.else_: 430 self.visit(node.else_) 431 self.nextBlock(end) 432 433 def visitWhile(self, node): 434 self.set_lineno(node) 435 436 loop = self.newBlock() 437 else_ = self.newBlock() 438 439 after = self.newBlock() 440 self.emit('SETUP_LOOP', after) 441 442 self.nextBlock(loop) 443 self.setups.push((LOOP, loop)) 444 445 self.set_lineno(node, force=True) 446 self.visit(node.test) 447 self.emit('POP_JUMP_IF_FALSE', else_ or after) 448 449 self.nextBlock() 450 self.visit(node.body) 451 self.emit('JUMP_ABSOLUTE', loop) 452 453 self.startBlock(else_) # or just the POPs if not else clause 454 self.emit('POP_BLOCK') 455 self.setups.pop() 456 if node.else_: 457 self.visit(node.else_) 458 self.nextBlock(after) 459 460 def visitFor(self, node): 461 start = self.newBlock() 462 anchor = self.newBlock() 463 after = self.newBlock() 464 self.setups.push((LOOP, start)) 465 466 self.set_lineno(node) 467 self.emit('SETUP_LOOP', after) 468 self.visit(node.list) 469 self.emit('GET_ITER') 470 471 self.nextBlock(start) 472 self.set_lineno(node, force=1) 473 self.emit('FOR_ITER', anchor) 474 self.visit(node.assign) 475 self.visit(node.body) 476 self.emit('JUMP_ABSOLUTE', start) 477 self.nextBlock(anchor) 478 self.emit('POP_BLOCK') 479 self.setups.pop() 480 if node.else_: 481 self.visit(node.else_) 482 self.nextBlock(after) 483 484 def visitBreak(self, node): 485 if not self.setups: 486 raise SyntaxError, "'break' outside loop (%s, %d)" % \ 487 (node.filename, node.lineno) 488 self.set_lineno(node) 489 self.emit('BREAK_LOOP') 490 491 def visitContinue(self, node): 492 if not self.setups: 493 raise SyntaxError, "'continue' outside loop (%s, %d)" % \ 494 (node.filename, node.lineno) 495 kind, block = self.setups.top() 496 if kind == LOOP: 497 self.set_lineno(node) 498 self.emit('JUMP_ABSOLUTE', block) 499 self.nextBlock() 500 elif kind == EXCEPT or kind == TRY_FINALLY: 501 self.set_lineno(node) 502 # find the block that starts the loop 503 top = len(self.setups) 504 while top > 0: 505 top = top - 1 506 kind, loop_block = self.setups[top] 507 if kind == LOOP: 508 break 509 if kind != LOOP: 510 raise SyntaxError, "'continue' outside loop (%s, %d)" % \ 511 (node.filename, node.lineno) 512 self.emit('CONTINUE_LOOP', loop_block) 513 self.nextBlock() 514 elif kind == END_FINALLY: 515 msg = "'continue' not allowed inside 'finally' clause (%s, %d)" 516 raise SyntaxError, msg % (node.filename, node.lineno) 517 518 def visitTest(self, node, jump): 519 end = self.newBlock() 520 for child in node.nodes[:-1]: 521 self.visit(child) 522 self.emit(jump, end) 523 self.nextBlock() 524 self.visit(node.nodes[-1]) 525 self.nextBlock(end) 526 527 def visitAnd(self, node): 528 self.visitTest(node, 'JUMP_IF_FALSE_OR_POP') 529 530 def visitOr(self, node): 531 self.visitTest(node, 'JUMP_IF_TRUE_OR_POP') 532 533 def visitIfExp(self, node): 534 endblock = self.newBlock() 535 elseblock = self.newBlock() 536 self.visit(node.test) 537 self.emit('POP_JUMP_IF_FALSE', elseblock) 538 self.visit(node.then) 539 self.emit('JUMP_FORWARD', endblock) 540 self.nextBlock(elseblock) 541 self.visit(node.else_) 542 self.nextBlock(endblock) 543 544 def visitCompare(self, node): 545 self.visit(node.expr) 546 cleanup = self.newBlock() 547 for op, code in node.ops[:-1]: 548 self.visit(code) 549 self.emit('DUP_TOP') 550 self.emit('ROT_THREE') 551 self.emit('COMPARE_OP', op) 552 self.emit('JUMP_IF_FALSE_OR_POP', cleanup) 553 self.nextBlock() 554 # now do the last comparison 555 if node.ops: 556 op, code = node.ops[-1] 557 self.visit(code) 558 self.emit('COMPARE_OP', op) 559 if len(node.ops) > 1: 560 end = self.newBlock() 561 self.emit('JUMP_FORWARD', end) 562 self.startBlock(cleanup) 563 self.emit('ROT_TWO') 564 self.emit('POP_TOP') 565 self.nextBlock(end) 566 567 # list comprehensions 568 def visitListComp(self, node): 569 self.set_lineno(node) 570 # setup list 571 self.emit('BUILD_LIST', 0) 572 573 stack = [] 574 for i, for_ in zip(range(len(node.quals)), node.quals): 575 start, anchor = self.visit(for_) 576 cont = None 577 for if_ in for_.ifs: 578 if cont is None: 579 cont = self.newBlock() 580 self.visit(if_, cont) 581 stack.insert(0, (start, cont, anchor)) 582 583 self.visit(node.expr) 584 self.emit('LIST_APPEND', len(node.quals) + 1) 585 586 for start, cont, anchor in stack: 587 if cont: 588 self.nextBlock(cont) 589 self.emit('JUMP_ABSOLUTE', start) 590 self.startBlock(anchor) 591 592 def visitSetComp(self, node): 593 self.set_lineno(node) 594 # setup list 595 self.emit('BUILD_SET', 0) 596 597 stack = [] 598 for i, for_ in zip(range(len(node.quals)), node.quals): 599 start, anchor = self.visit(for_) 600 cont = None 601 for if_ in for_.ifs: 602 if cont is None: 603 cont = self.newBlock() 604 self.visit(if_, cont) 605 stack.insert(0, (start, cont, anchor)) 606 607 self.visit(node.expr) 608 self.emit('SET_ADD', len(node.quals) + 1) 609 610 for start, cont, anchor in stack: 611 if cont: 612 self.nextBlock(cont) 613 self.emit('JUMP_ABSOLUTE', start) 614 self.startBlock(anchor) 615 616 def visitDictComp(self, node): 617 self.set_lineno(node) 618 # setup list 619 self.emit('BUILD_MAP', 0) 620 621 stack = [] 622 for i, for_ in zip(range(len(node.quals)), node.quals): 623 start, anchor = self.visit(for_) 624 cont = None 625 for if_ in for_.ifs: 626 if cont is None: 627 cont = self.newBlock() 628 self.visit(if_, cont) 629 stack.insert(0, (start, cont, anchor)) 630 631 self.visit(node.value) 632 self.visit(node.key) 633 self.emit('MAP_ADD', len(node.quals) + 1) 634 635 for start, cont, anchor in stack: 636 if cont: 637 self.nextBlock(cont) 638 self.emit('JUMP_ABSOLUTE', start) 639 self.startBlock(anchor) 640 641 def visitListCompFor(self, node): 642 start = self.newBlock() 643 anchor = self.newBlock() 644 645 self.visit(node.list) 646 self.emit('GET_ITER') 647 self.nextBlock(start) 648 self.set_lineno(node, force=True) 649 self.emit('FOR_ITER', anchor) 650 self.nextBlock() 651 self.visit(node.assign) 652 return start, anchor 653 654 def visitListCompIf(self, node, branch): 655 self.set_lineno(node, force=True) 656 self.visit(node.test) 657 self.emit('POP_JUMP_IF_FALSE', branch) 658 self.newBlock() 659 660 def _makeClosure(self, gen, args): 661 frees = gen.scope.get_free_vars() 662 if frees: 663 for name in frees: 664 self.emit('LOAD_CLOSURE', name) 665 self.emit('BUILD_TUPLE', len(frees)) 666 self.emit('LOAD_CONST', gen) 667 self.emit('MAKE_CLOSURE', args) 668 else: 669 self.emit('LOAD_CONST', gen) 670 self.emit('MAKE_FUNCTION', args) 671 672 def visitGenExpr(self, node): 673 gen = GenExprCodeGenerator(node, self.scopes, self.class_name, 674 self.get_module()) 675 walk(node.code, gen) 676 gen.finish() 677 self.set_lineno(node) 678 self._makeClosure(gen, 0) 679 # precomputation of outmost iterable 680 self.visit(node.code.quals[0].iter) 681 self.emit('GET_ITER') 682 self.emit('CALL_FUNCTION', 1) 683 684 def visitGenExprInner(self, node): 685 self.set_lineno(node) 686 # setup list 687 688 stack = [] 689 for i, for_ in zip(range(len(node.quals)), node.quals): 690 start, anchor, end = self.visit(for_) 691 cont = None 692 for if_ in for_.ifs: 693 if cont is None: 694 cont = self.newBlock() 695 self.visit(if_, cont) 696 stack.insert(0, (start, cont, anchor, end)) 697 698 self.visit(node.expr) 699 self.emit('YIELD_VALUE') 700 self.emit('POP_TOP') 701 702 for start, cont, anchor, end in stack: 703 if cont: 704 self.nextBlock(cont) 705 self.emit('JUMP_ABSOLUTE', start) 706 self.startBlock(anchor) 707 self.emit('POP_BLOCK') 708 self.setups.pop() 709 self.nextBlock(end) 710 711 self.emit('LOAD_CONST', None) 712 713 def visitGenExprFor(self, node): 714 start = self.newBlock() 715 anchor = self.newBlock() 716 end = self.newBlock() 717 718 self.setups.push((LOOP, start)) 719 self.emit('SETUP_LOOP', end) 720 721 if node.is_outmost: 722 self.loadName('.0') 723 else: 724 self.visit(node.iter) 725 self.emit('GET_ITER') 726 727 self.nextBlock(start) 728 self.set_lineno(node, force=True) 729 self.emit('FOR_ITER', anchor) 730 self.nextBlock() 731 self.visit(node.assign) 732 return start, anchor, end 733 734 def visitGenExprIf(self, node, branch): 735 self.set_lineno(node, force=True) 736 self.visit(node.test) 737 self.emit('POP_JUMP_IF_FALSE', branch) 738 self.newBlock() 739 740 # exception related 741 742 def visitAssert(self, node): 743 # XXX would be interesting to implement this via a 744 # transformation of the AST before this stage 745 if __debug__: 746 end = self.newBlock() 747 self.set_lineno(node) 748 # XXX AssertionError appears to be special case -- it is always 749 # loaded as a global even if there is a local name. I guess this 750 # is a sort of renaming op. 751 self.nextBlock() 752 self.visit(node.test) 753 self.emit('POP_JUMP_IF_TRUE', end) 754 self.nextBlock() 755 self.emit('LOAD_GLOBAL', 'AssertionError') 756 if node.fail: 757 self.visit(node.fail) 758 self.emit('RAISE_VARARGS', 2) 759 else: 760 self.emit('RAISE_VARARGS', 1) 761 self.nextBlock(end) 762 763 def visitRaise(self, node): 764 self.set_lineno(node) 765 n = 0 766 if node.expr1: 767 self.visit(node.expr1) 768 n = n + 1 769 if node.expr2: 770 self.visit(node.expr2) 771 n = n + 1 772 if node.expr3: 773 self.visit(node.expr3) 774 n = n + 1 775 self.emit('RAISE_VARARGS', n) 776 777 def visitTryExcept(self, node): 778 body = self.newBlock() 779 handlers = self.newBlock() 780 end = self.newBlock() 781 if node.else_: 782 lElse = self.newBlock() 783 else: 784 lElse = end 785 self.set_lineno(node) 786 self.emit('SETUP_EXCEPT', handlers) 787 self.nextBlock(body) 788 self.setups.push((EXCEPT, body)) 789 self.visit(node.body) 790 self.emit('POP_BLOCK') 791 self.setups.pop() 792 self.emit('JUMP_FORWARD', lElse) 793 self.startBlock(handlers) 794 795 last = len(node.handlers) - 1 796 for i in range(len(node.handlers)): 797 expr, target, body = node.handlers[i] 798 self.set_lineno(expr) 799 if expr: 800 self.emit('DUP_TOP') 801 self.visit(expr) 802 self.emit('COMPARE_OP', 'exception match') 803 next = self.newBlock() 804 self.emit('POP_JUMP_IF_FALSE', next) 805 self.nextBlock() 806 self.emit('POP_TOP') 807 if target: 808 self.visit(target) 809 else: 810 self.emit('POP_TOP') 811 self.emit('POP_TOP') 812 self.visit(body) 813 self.emit('JUMP_FORWARD', end) 814 if expr: 815 self.nextBlock(next) 816 else: 817 self.nextBlock() 818 self.emit('END_FINALLY') 819 if node.else_: 820 self.nextBlock(lElse) 821 self.visit(node.else_) 822 self.nextBlock(end) 823 824 def visitTryFinally(self, node): 825 body = self.newBlock() 826 final = self.newBlock() 827 self.set_lineno(node) 828 self.emit('SETUP_FINALLY', final) 829 self.nextBlock(body) 830 self.setups.push((TRY_FINALLY, body)) 831 self.visit(node.body) 832 self.emit('POP_BLOCK') 833 self.setups.pop() 834 self.emit('LOAD_CONST', None) 835 self.nextBlock(final) 836 self.setups.push((END_FINALLY, final)) 837 self.visit(node.final) 838 self.emit('END_FINALLY') 839 self.setups.pop() 840 841 __with_count = 0 842 843 def visitWith(self, node): 844 body = self.newBlock() 845 final = self.newBlock() 846 self.__with_count += 1 847 valuevar = "_[%d]" % self.__with_count 848 self.set_lineno(node) 849 self.visit(node.expr) 850 self.emit('DUP_TOP') 851 self.emit('LOAD_ATTR', '__exit__') 852 self.emit('ROT_TWO') 853 self.emit('LOAD_ATTR', '__enter__') 854 self.emit('CALL_FUNCTION', 0) 855 if node.vars is None: 856 self.emit('POP_TOP') 857 else: 858 self._implicitNameOp('STORE', valuevar) 859 self.emit('SETUP_FINALLY', final) 860 self.nextBlock(body) 861 self.setups.push((TRY_FINALLY, body)) 862 if node.vars is not None: 863 self._implicitNameOp('LOAD', valuevar) 864 self._implicitNameOp('DELETE', valuevar) 865 self.visit(node.vars) 866 self.visit(node.body) 867 self.emit('POP_BLOCK') 868 self.setups.pop() 869 self.emit('LOAD_CONST', None) 870 self.nextBlock(final) 871 self.setups.push((END_FINALLY, final)) 872 self.emit('WITH_CLEANUP') 873 self.emit('END_FINALLY') 874 self.setups.pop() 875 self.__with_count -= 1 876 877 # misc 878 879 def visitDiscard(self, node): 880 self.set_lineno(node) 881 self.visit(node.expr) 882 self.emit('POP_TOP') 883 884 def visitConst(self, node): 885 self.emit('LOAD_CONST', node.value) 886 887 def visitKeyword(self, node): 888 self.emit('LOAD_CONST', node.name) 889 self.visit(node.expr) 890 891 def visitGlobal(self, node): 892 # no code to generate 893 pass 894 895 def visitName(self, node): 896 self.set_lineno(node) 897 self.loadName(node.name) 898 899 def visitPass(self, node): 900 self.set_lineno(node) 901 902 def visitImport(self, node): 903 self.set_lineno(node) 904 level = 0 if self.graph.checkFlag(CO_FUTURE_ABSIMPORT) else -1 905 for name, alias in node.names: 906 if VERSION > 1: 907 self.emit('LOAD_CONST', level) 908 self.emit('LOAD_CONST', None) 909 self.emit('IMPORT_NAME', name) 910 mod = name.split(".")[0] 911 if alias: 912 self._resolveDots(name) 913 self.storeName(alias) 914 else: 915 self.storeName(mod) 916 917 def visitFrom(self, node): 918 self.set_lineno(node) 919 level = node.level 920 if level == 0 and not self.graph.checkFlag(CO_FUTURE_ABSIMPORT): 921 level = -1 922 fromlist = tuple(name for (name, alias) in node.names) 923 if VERSION > 1: 924 self.emit('LOAD_CONST', level) 925 self.emit('LOAD_CONST', fromlist) 926 self.emit('IMPORT_NAME', node.modname) 927 for name, alias in node.names: 928 if VERSION > 1: 929 if name == '*': 930 self.namespace = 0 931 self.emit('IMPORT_STAR') 932 # There can only be one name w/ from ... import * 933 assert len(node.names) == 1 934 return 935 else: 936 self.emit('IMPORT_FROM', name) 937 self._resolveDots(name) 938 self.storeName(alias or name) 939 else: 940 self.emit('IMPORT_FROM', name) 941 self.emit('POP_TOP') 942 943 def _resolveDots(self, name): 944 elts = name.split(".") 945 if len(elts) == 1: 946 return 947 for elt in elts[1:]: 948 self.emit('LOAD_ATTR', elt) 949 950 def visitGetattr(self, node): 951 self.visit(node.expr) 952 self.emit('LOAD_ATTR', self.mangle(node.attrname)) 953 954 # next five implement assignments 955 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] 962 if i < dups: 963 self.emit('DUP_TOP') 964 if isinstance(elt, ast.Node): 965 self.visit(elt) 966 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) 973 else: 974 print "oops", node.flags 975 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)) 982 else: 983 print "warning: unexpected flags:", node.flags 984 print node 985 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: 990 self.visit(child) 991 992 if VERSION > 1: 993 visitAssTuple = _visitAssSequence 994 visitAssList = _visitAssSequence 995 else: 996 def visitAssTuple(self, node): 997 self._visitAssSequence(node, 'UNPACK_TUPLE') 998 999 def visitAssList(self, node): 1000 self._visitAssSequence(node, 'UNPACK_LIST') 1001 1002 # augmented assignment 1003 1004 def visitAugAssign(self, node): 1005 self.set_lineno(node) 1006 aug_node = wrap_aug(node.node) 1007 self.visit(aug_node, "load") 1008 self.visit(node.expr) 1009 self.emit(self._augmented_opcode[node.op]) 1010 self.visit(aug_node, "store") 1011 1012 _augmented_opcode = { 1013 '+=' : 'INPLACE_ADD', 1014 '-=' : 'INPLACE_SUBTRACT', 1015 '*=' : 'INPLACE_MULTIPLY', 1016 '/=' : 'INPLACE_DIVIDE', 1017 '//=': 'INPLACE_FLOOR_DIVIDE', 1018 '%=' : 'INPLACE_MODULO', 1019 '**=': 'INPLACE_POWER', 1020 '>>=': 'INPLACE_RSHIFT', 1021 '<<=': 'INPLACE_LSHIFT', 1022 '&=' : 'INPLACE_AND', 1023 '^=' : 'INPLACE_XOR', 1024 '|=' : 'INPLACE_OR', 1025 } 1026 1027 def visitAugName(self, node, mode): 1028 if mode == "load": 1029 self.loadName(node.name) 1030 elif mode == "store": 1031 self.storeName(node.name) 1032 1033 def visitAugGetattr(self, node, mode): 1034 if mode == "load": 1035 self.visit(node.expr) 1036 self.emit('DUP_TOP') 1037 self.emit('LOAD_ATTR', self.mangle(node.attrname)) 1038 elif mode == "store": 1039 self.emit('ROT_TWO') 1040 self.emit('STORE_ATTR', self.mangle(node.attrname)) 1041 1042 def visitAugSlice(self, node, mode): 1043 if mode == "load": 1044 self.visitSlice(node, 1) 1045 elif mode == "store": 1046 slice = 0 1047 if node.lower: 1048 slice = slice | 1 1049 if node.upper: 1050 slice = slice | 2 1051 if slice == 0: 1052 self.emit('ROT_TWO') 1053 elif slice == 3: 1054 self.emit('ROT_FOUR') 1055 else: 1056 self.emit('ROT_THREE') 1057 self.emit('STORE_SLICE+%d' % slice) 1058 1059 def visitAugSubscript(self, node, mode): 1060 if mode == "load": 1061 self.visitSubscript(node, 1) 1062 elif mode == "store": 1063 self.emit('ROT_THREE') 1064 self.emit('STORE_SUBSCR') 1065 1066 def visitExec(self, node): 1067 self.visit(node.expr) 1068 if node.locals is None: 1069 self.emit('LOAD_CONST', None) 1070 else: 1071 self.visit(node.locals) 1072 if node.globals is None: 1073 self.emit('DUP_TOP') 1074 else: 1075 self.visit(node.globals) 1076 self.emit('EXEC_STMT') 1077 1078 def visitCallFunc(self, node): 1079 pos = 0 1080 kw = 0 1081 self.set_lineno(node) 1082 self.visit(node.node) 1083 for arg in node.args: 1084 self.visit(arg) 1085 if isinstance(arg, ast.Keyword): 1086 kw = kw + 1 1087 else: 1088 pos = pos + 1 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 1095 opcode = callfunc_opcode_info[have_star, have_dstar] 1096 self.emit(opcode, kw << 8 | pos) 1097 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: 1104 self.emit('DUP_TOP') 1105 self.visit(child) 1106 if node.dest: 1107 self.emit('ROT_TWO') 1108 self.emit('PRINT_ITEM_TO') 1109 else: 1110 self.emit('PRINT_ITEM') 1111 if node.dest and not newline: 1112 self.emit('POP_TOP') 1113 1114 def visitPrintnl(self, node): 1115 self.visitPrint(node, newline=1) 1116 if node.dest: 1117 self.emit('PRINT_NEWLINE_TO') 1118 else: 1119 self.emit('PRINT_NEWLINE') 1120 1121 def visitReturn(self, node): 1122 self.set_lineno(node) 1123 self.visit(node.value) 1124 self.emit('RETURN_VALUE') 1125 1126 def visitYield(self, node): 1127 self.set_lineno(node) 1128 self.visit(node.value) 1129 self.emit('YIELD_VALUE') 1130 1131 # slice and subscript stuff 1132 1133 def visitSlice(self, node, aug_flag=None): 1134 # aug_flag is used by visitAugSlice 1135 self.visit(node.expr) 1136 slice = 0 1137 if node.lower: 1138 self.visit(node.lower) 1139 slice = slice | 1 1140 if node.upper: 1141 self.visit(node.upper) 1142 slice = slice | 2 1143 if aug_flag: 1144 if slice == 0: 1145 self.emit('DUP_TOP') 1146 elif slice == 3: 1147 self.emit('DUP_TOPX', 3) 1148 else: 1149 self.emit('DUP_TOPX', 2) 1150 if node.flags == 'OP_APPLY': 1151 self.emit('SLICE+%d' % slice) 1152 elif node.flags == 'OP_ASSIGN': 1153 self.emit('STORE_SLICE+%d' % slice) 1154 elif node.flags == 'OP_DELETE': 1155 self.emit('DELETE_SLICE+%d' % slice) 1156 else: 1157 print "weird slice", node.flags 1158 raise 1159 1160 def visitSubscript(self, node, aug_flag=None): 1161 self.visit(node.expr) 1162 for sub in node.subs: 1163 self.visit(sub) 1164 if len(node.subs) > 1: 1165 self.emit('BUILD_TUPLE', len(node.subs)) 1166 if aug_flag: 1167 self.emit('DUP_TOPX', 2) 1168 if node.flags == 'OP_APPLY': 1169 self.emit('BINARY_SUBSCR') 1170 elif node.flags == 'OP_ASSIGN': 1171 self.emit('STORE_SUBSCR') 1172 elif node.flags == 'OP_DELETE': 1173 self.emit('DELETE_SUBSCR') 1174 1175 # binary ops 1176 1177 def binaryOp(self, node, op): 1178 self.visit(node.left) 1179 self.visit(node.right) 1180 self.emit(op) 1181 1182 def visitAdd(self, node): 1183 return self.binaryOp(node, 'BINARY_ADD') 1184 1185 def visitSub(self, node): 1186 return self.binaryOp(node, 'BINARY_SUBTRACT') 1187 1188 def visitMul(self, node): 1189 return self.binaryOp(node, 'BINARY_MULTIPLY') 1190 1191 def visitDiv(self, node): 1192 return self.binaryOp(node, self._div_op) 1193 1194 def visitFloorDiv(self, node): 1195 return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE') 1196 1197 def visitMod(self, node): 1198 return self.binaryOp(node, 'BINARY_MODULO') 1199 1200 def visitPower(self, node): 1201 return self.binaryOp(node, 'BINARY_POWER') 1202 1203 def visitLeftShift(self, node): 1204 return self.binaryOp(node, 'BINARY_LSHIFT') 1205 1206 def visitRightShift(self, node): 1207 return self.binaryOp(node, 'BINARY_RSHIFT') 1208 1209 # unary ops 1210 1211 def unaryOp(self, node, op): 1212 self.visit(node.expr) 1213 self.emit(op) 1214 1215 def visitInvert(self, node): 1216 return self.unaryOp(node, 'UNARY_INVERT') 1217 1218 def visitUnarySub(self, node): 1219 return self.unaryOp(node, 'UNARY_NEGATIVE') 1220 1221 def visitUnaryAdd(self, node): 1222 return self.unaryOp(node, 'UNARY_POSITIVE') 1223 1224 def visitUnaryInvert(self, node): 1225 return self.unaryOp(node, 'UNARY_INVERT') 1226 1227 def visitNot(self, node): 1228 return self.unaryOp(node, 'UNARY_NOT') 1229 1230 def visitBackquote(self, node): 1231 return self.unaryOp(node, 'UNARY_CONVERT') 1232 1233 # bit ops 1234 1235 def bitOp(self, nodes, op): 1236 self.visit(nodes[0]) 1237 for node in nodes[1:]: 1238 self.visit(node) 1239 self.emit(op) 1240 1241 def visitBitand(self, node): 1242 return self.bitOp(node.nodes, 'BINARY_AND') 1243 1244 def visitBitor(self, node): 1245 return self.bitOp(node.nodes, 'BINARY_OR') 1246 1247 def visitBitxor(self, node): 1248 return self.bitOp(node.nodes, 'BINARY_XOR') 1249 1250 # object constructors 1251 1252 def visitEllipsis(self, node): 1253 self.emit('LOAD_CONST', Ellipsis) 1254 1255 def visitTuple(self, node): 1256 self.set_lineno(node) 1257 for elt in node.nodes: 1258 self.visit(elt) 1259 self.emit('BUILD_TUPLE', len(node.nodes)) 1260 1261 def visitList(self, node): 1262 self.set_lineno(node) 1263 for elt in node.nodes: 1264 self.visit(elt) 1265 self.emit('BUILD_LIST', len(node.nodes)) 1266 1267 def visitSet(self, node): 1268 self.set_lineno(node) 1269 for elt in node.nodes: 1270 self.visit(elt) 1271 self.emit('BUILD_SET', len(node.nodes)) 1272 1273 def visitSliceobj(self, node): 1274 for child in node.nodes: 1275 self.visit(child) 1276 self.emit('BUILD_SLICE', len(node.nodes)) 1277 1278 def visitDict(self, node): 1279 self.set_lineno(node) 1280 self.emit('BUILD_MAP', 0) 1281 for k, v in node.items: 1282 self.emit('DUP_TOP') 1283 self.visit(k) 1284 self.visit(v) 1285 self.emit('ROT_THREE') 1286 self.emit('STORE_SUBSCR') 1287 1288 class NestedScopeMixin: 1289 """Defines initClass() for nested scoping (Python 2.2-compatible)""" 1290 def initClass(self): 1291 self.__class__.NameFinder = LocalNameFinder 1292 self.__class__.FunctionGen = FunctionCodeGenerator 1293 self.__class__.ClassGen = ClassCodeGenerator 1294 1295 class ModuleCodeGenerator(NestedScopeMixin, CodeGenerator): 1296 __super_init = CodeGenerator.__init__ 1297 1298 scopes = None 1299 1300 def __init__(self, tree): 1301 self.graph = pyassem.PyFlowGraph("<module>", tree.filename) 1302 self.futures = future.find_futures(tree) 1303 self.__super_init() 1304 walk(tree, self) 1305 1306 def get_module(self): 1307 return self 1308 1309 class ExpressionCodeGenerator(NestedScopeMixin, CodeGenerator): 1310 __super_init = CodeGenerator.__init__ 1311 1312 scopes = None 1313 futures = () 1314 1315 def __init__(self, tree): 1316 self.graph = pyassem.PyFlowGraph("<expression>", tree.filename) 1317 self.__super_init() 1318 walk(tree, self) 1319 1320 def get_module(self): 1321 return self 1322 1323 class InteractiveCodeGenerator(NestedScopeMixin, CodeGenerator): 1324 1325 __super_init = CodeGenerator.__init__ 1326 1327 scopes = None 1328 futures = () 1329 1330 def __init__(self, tree): 1331 self.graph = pyassem.PyFlowGraph("<interactive>", tree.filename) 1332 self.__super_init() 1333 self.set_lineno(tree) 1334 walk(tree, self) 1335 self.emit('RETURN_VALUE') 1336 1337 def get_module(self): 1338 return self 1339 1340 def visitDiscard(self, node): 1341 # XXX Discard means it's an expression. Perhaps this is a bad 1342 # name. 1343 self.visit(node.expr) 1344 self.emit('PRINT_EXPR') 1345 1346 class AbstractFunctionCode: 1347 optimized = 1 1348 lambdaCount = 0 1349 1350 def __init__(self, func, scopes, isLambda, class_name, mod): 1351 self.class_name = class_name 1352 self.module = mod 1353 if isLambda: 1354 klass = FunctionCodeGenerator 1355 name = "<lambda.%d>" % klass.lambdaCount 1356 klass.lambdaCount = klass.lambdaCount + 1 1357 else: 1358 name = func.name 1359 1360 args, hasTupleArg = generateArgList(func.argnames) 1361 self.graph = pyassem.PyFlowGraph(name, func.filename, args, 1362 optimized=1) 1363 self.isLambda = isLambda 1364 self.super_init() 1365 1366 if not isLambda and func.doc: 1367 self.setDocstring(func.doc) 1368 1369 lnf = walk(func.code, self.NameFinder(args), verbose=0) 1370 self.locals.push(lnf.getLocals()) 1371 if func.varargs: 1372 self.graph.setFlag(CO_VARARGS) 1373 if func.kwargs: 1374 self.graph.setFlag(CO_VARKEYWORDS) 1375 self.set_lineno(func) 1376 if hasTupleArg: 1377 self.generateArgUnpack(func.argnames) 1378 1379 def get_module(self): 1380 return self.module 1381 1382 def finish(self): 1383 self.graph.startExitBlock() 1384 if not self.isLambda: 1385 self.emit('LOAD_CONST', None) 1386 self.emit('RETURN_VALUE') 1387 1388 def generateArgUnpack(self, args): 1389 for i in range(len(args)): 1390 arg = args[i] 1391 if isinstance(arg, tuple): 1392 self.emit('LOAD_FAST', '.%d' % (i * 2)) 1393 self.unpackSequence(arg) 1394 1395 def unpackSequence(self, tup): 1396 if VERSION > 1: 1397 self.emit('UNPACK_SEQUENCE', len(tup)) 1398 else: 1399 self.emit('UNPACK_TUPLE', len(tup)) 1400 for elt in tup: 1401 if isinstance(elt, tuple): 1402 self.unpackSequence(elt) 1403 else: 1404 self._nameOp('STORE', elt) 1405 1406 unpackTuple = unpackSequence 1407 1408 class FunctionCodeGenerator(NestedScopeMixin, AbstractFunctionCode, 1409 CodeGenerator): 1410 super_init = CodeGenerator.__init__ # call be other init 1411 scopes = None 1412 1413 __super_init = AbstractFunctionCode.__init__ 1414 1415 def __init__(self, func, scopes, isLambda, class_name, mod): 1416 self.scopes = scopes 1417 self.scope = scopes[func] 1418 self.__super_init(func, scopes, isLambda, class_name, mod) 1419 self.graph.setFreeVars(self.scope.get_free_vars()) 1420 self.graph.setCellVars(self.scope.get_cell_vars()) 1421 if self.scope.generator is not None: 1422 self.graph.setFlag(CO_GENERATOR) 1423 1424 class GenExprCodeGenerator(NestedScopeMixin, AbstractFunctionCode, 1425 CodeGenerator): 1426 super_init = CodeGenerator.__init__ # call be other init 1427 scopes = None 1428 1429 __super_init = AbstractFunctionCode.__init__ 1430 1431 def __init__(self, gexp, scopes, class_name, mod): 1432 self.scopes = scopes 1433 self.scope = scopes[gexp] 1434 self.__super_init(gexp, scopes, 1, class_name, mod) 1435 self.graph.setFreeVars(self.scope.get_free_vars()) 1436 self.graph.setCellVars(self.scope.get_cell_vars()) 1437 self.graph.setFlag(CO_GENERATOR) 1438 1439 class AbstractClassCode: 1440 1441 def __init__(self, klass, scopes, module): 1442 self.class_name = klass.name 1443 self.module = module 1444 self.graph = pyassem.PyFlowGraph(klass.name, klass.filename, 1445 optimized=0, klass=1) 1446 self.super_init() 1447 lnf = walk(klass.code, self.NameFinder(), verbose=0) 1448 self.locals.push(lnf.getLocals()) 1449 self.graph.setFlag(CO_NEWLOCALS) 1450 if klass.doc: 1451 self.setDocstring(klass.doc) 1452 1453 def get_module(self): 1454 return self.module 1455 1456 def finish(self): 1457 self.graph.startExitBlock() 1458 self.emit('LOAD_LOCALS') 1459 self.emit('RETURN_VALUE') 1460 1461 class ClassCodeGenerator(NestedScopeMixin, AbstractClassCode, CodeGenerator): 1462 super_init = CodeGenerator.__init__ 1463 scopes = None 1464 1465 __super_init = AbstractClassCode.__init__ 1466 1467 def __init__(self, klass, scopes, module): 1468 self.scopes = scopes 1469 self.scope = scopes[klass] 1470 self.__super_init(klass, scopes, module) 1471 self.graph.setFreeVars(self.scope.get_free_vars()) 1472 self.graph.setCellVars(self.scope.get_cell_vars()) 1473 self.set_lineno(klass) 1474 self.emit("LOAD_GLOBAL", "__name__") 1475 self.storeName("__module__") 1476 if klass.doc: 1477 self.emit("LOAD_CONST", klass.doc) 1478 self.storeName('__doc__') 1479 1480 def generateArgList(arglist): 1481 """Generate an arg list marking TupleArgs""" 1482 args = [] 1483 extra = [] 1484 count = 0 1485 for i in range(len(arglist)): 1486 elt = arglist[i] 1487 if isinstance(elt, str): 1488 args.append(elt) 1489 elif isinstance(elt, tuple): 1490 args.append(TupleArg(i * 2, elt)) 1491 extra.extend(misc.flatten(elt)) 1492 count = count + 1 1493 else: 1494 raise ValueError, "unexpect argument type:", elt 1495 return args + extra, count 1496 1497 def findOp(node): 1498 """Find the op (DELETE, LOAD, STORE) in an AssTuple tree""" 1499 v = OpFinder() 1500 walk(node, v, verbose=0) 1501 return v.op 1502 1503 class OpFinder: 1504 def __init__(self): 1505 self.op = None 1506 def visitAssName(self, node): 1507 if self.op is None: 1508 self.op = node.flags 1509 elif self.op != node.flags: 1510 raise ValueError, "mixed ops in stmt" 1511 visitAssAttr = visitAssName 1512 visitSubscript = visitAssName 1513 1514 class Delegator: 1515 """Base class to support delegation for augmented assignment nodes 1516 1517 To generator code for augmented assignments, we use the following 1518 wrapper classes. In visitAugAssign, the left-hand expression node 1519 is visited twice. The first time the visit uses the normal method 1520 for that node . The second time the visit uses a different method 1521 that generates the appropriate code to perform the assignment. 1522 These delegator classes wrap the original AST nodes in order to 1523 support the variant visit methods. 1524 """ 1525 def __init__(self, obj): 1526 self.obj = obj 1527 1528 def __getattr__(self, attr): 1529 return getattr(self.obj, attr) 1530 1531 class AugGetattr(Delegator): 1532 pass 1533 1534 class AugName(Delegator): 1535 pass 1536 1537 class AugSlice(Delegator): 1538 pass 1539 1540 class AugSubscript(Delegator): 1541 pass 1542 1543 wrapper = { 1544 ast.Getattr: AugGetattr, 1545 ast.Name: AugName, 1546 ast.Slice: AugSlice, 1547 ast.Subscript: AugSubscript, 1548 } 1549 1550 def wrap_aug(node): 1551 return wrapper[node.__class__](node) 1552 1553 if __name__ == "__main__": 1554 for file in sys.argv[1:]: 1555 compileFile(file) 1556
