| import imp |
| import os |
| import marshal |
| import struct |
| import sys |
| from cStringIO import StringIO |
| |
| from compiler import ast, parse, walk, syntax |
| from compiler import pyassem, misc, future, symbols |
| from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL |
| from compiler.consts import (CO_VARARGS, CO_VARKEYWORDS, CO_NEWLOCALS, |
| CO_NESTED, CO_GENERATOR, CO_FUTURE_DIVISION, |
| CO_FUTURE_ABSIMPORT, CO_FUTURE_WITH_STATEMENT, CO_FUTURE_PRINT_FUNCTION) |
| from compiler.pyassem import TupleArg |
| |
| # XXX The version-specific code can go, since this code only works with 2.x. |
| # Do we have Python 1.x or Python 2.x? |
| try: |
| VERSION = sys.version_info[0] |
| except AttributeError: |
| VERSION = 1 |
| |
| callfunc_opcode_info = { |
| # (Have *args, Have **args) : opcode |
| (0,0) : "CALL_FUNCTION", |
| (1,0) : "CALL_FUNCTION_VAR", |
| (0,1) : "CALL_FUNCTION_KW", |
| (1,1) : "CALL_FUNCTION_VAR_KW", |
| } |
| |
| LOOP = 1 |
| EXCEPT = 2 |
| TRY_FINALLY = 3 |
| END_FINALLY = 4 |
| |
| def compileFile(filename, display=0): |
| f = open(filename, 'U') |
| buf = f.read() |
| f.close() |
| mod = Module(buf, filename) |
| try: |
| mod.compile(display) |
| except SyntaxError: |
| raise |
| else: |
| f = open(filename + "c", "wb") |
| mod.dump(f) |
| f.close() |
| |
| def compile(source, filename, mode, flags=None, dont_inherit=None): |
| """Replacement for builtin compile() function""" |
| if flags is not None or dont_inherit is not None: |
| raise RuntimeError, "not implemented yet" |
| |
| if mode == "single": |
| gen = Interactive(source, filename) |
| elif mode == "exec": |
| gen = Module(source, filename) |
| elif mode == "eval": |
| gen = Expression(source, filename) |
| else: |
| raise ValueError("compile() 3rd arg must be 'exec' or " |
| "'eval' or 'single'") |
| gen.compile() |
| return gen.code |
| |
| class AbstractCompileMode: |
| |
| mode = None # defined by subclass |
| |
| def __init__(self, source, filename): |
| self.source = source |
| self.filename = filename |
| self.code = None |
| |
| def _get_tree(self): |
| tree = parse(self.source, self.mode) |
| misc.set_filename(self.filename, tree) |
| syntax.check(tree) |
| return tree |
| |
| def compile(self): |
| pass # implemented by subclass |
| |
| def getCode(self): |
| return self.code |
| |
| class Expression(AbstractCompileMode): |
| |
| mode = "eval" |
| |
| def compile(self): |
| tree = self._get_tree() |
| gen = ExpressionCodeGenerator(tree) |
| self.code = gen.getCode() |
| |
| class Interactive(AbstractCompileMode): |
| |
| mode = "single" |
| |
| def compile(self): |
| tree = self._get_tree() |
| gen = InteractiveCodeGenerator(tree) |
| self.code = gen.getCode() |
| |
| class Module(AbstractCompileMode): |
| |
| mode = "exec" |
| |
| def compile(self, display=0): |
| tree = self._get_tree() |
| gen = ModuleCodeGenerator(tree) |
| if display: |
| import pprint |
| print pprint.pprint(tree) |
| self.code = gen.getCode() |
| |
| def dump(self, f): |
| f.write(self.getPycHeader()) |
| marshal.dump(self.code, f) |
| |
| MAGIC = imp.get_magic() |
| |
| def getPycHeader(self): |
| # compile.c uses marshal to write a long directly, with |
| # calling the interface that would also generate a 1-byte code |
| # to indicate the type of the value. simplest way to get the |
| # same effect is to call marshal and then skip the code. |
| mtime = os.path.getmtime(self.filename) |
| mtime = struct.pack('<i', mtime) |
| return self.MAGIC + mtime |
| |
| class LocalNameFinder: |
| """Find local names in scope""" |
| def __init__(self, names=()): |
| self.names = misc.Set() |
| self.globals = misc.Set() |
| for name in names: |
| self.names.add(name) |
| |
| # XXX list comprehensions and for loops |
| |
| def getLocals(self): |
| for elt in self.globals.elements(): |
| if self.names.has_elt(elt): |
| self.names.remove(elt) |
| return self.names |
| |
| def visitDict(self, node): |
| pass |
| |
| def visitGlobal(self, node): |
| for name in node.names: |
| self.globals.add(name) |
| |
| def visitFunction(self, node): |
| self.names.add(node.name) |
| |
| def visitLambda(self, node): |
| pass |
| |
| def visitImport(self, node): |
| for name, alias in node.names: |
| self.names.add(alias or name) |
| |
| def visitFrom(self, node): |
| for name, alias in node.names: |
| self.names.add(alias or name) |
| |
| def visitClass(self, node): |
| self.names.add(node.name) |
| |
| def visitAssName(self, node): |
| self.names.add(node.name) |
| |
| def is_constant_false(node): |
| if isinstance(node, ast.Const): |
| if not node.value: |
| return 1 |
| return 0 |
| |
| class CodeGenerator: |
| """Defines basic code generator for Python bytecode |
| |
| This class is an abstract base class. Concrete subclasses must |
| define an __init__() that defines self.graph and then calls the |
| __init__() defined in this class. |
| |
| The concrete class must also define the class attributes |
| NameFinder, FunctionGen, and ClassGen. These attributes can be |
| defined in the initClass() method, which is a hook for |
| initializing these methods after all the classes have been |
| defined. |
| """ |
| |
| optimized = 0 # is namespace access optimized? |
| __initialized = None |
| class_name = None # provide default for instance variable |
| |
| def __init__(self): |
| if self.__initialized is None: |
| self.initClass() |
| self.__class__.__initialized = 1 |
| self.checkClass() |
| self.locals = misc.Stack() |
| self.setups = misc.Stack() |
| self.last_lineno = None |
| self._setupGraphDelegation() |
| self._div_op = "BINARY_DIVIDE" |
| |
| # XXX set flags based on future features |
| futures = self.get_module().futures |
| for feature in futures: |
| if feature == "division": |
| self.graph.setFlag(CO_FUTURE_DIVISION) |
| self._div_op = "BINARY_TRUE_DIVIDE" |
| elif feature == "absolute_import": |
| self.graph.setFlag(CO_FUTURE_ABSIMPORT) |
| elif feature == "with_statement": |
| self.graph.setFlag(CO_FUTURE_WITH_STATEMENT) |
| elif feature == "print_function": |
| self.graph.setFlag(CO_FUTURE_PRINT_FUNCTION) |
| |
| def initClass(self): |
| """This method is called once for each class""" |
| |
| def checkClass(self): |
| """Verify that class is constructed correctly""" |
| try: |
| assert hasattr(self, 'graph') |
| assert getattr(self, 'NameFinder') |
| assert getattr(self, 'FunctionGen') |
| assert getattr(self, 'ClassGen') |
| except AssertionError, msg: |
| intro = "Bad class construction for %s" % self.__class__.__name__ |
| raise AssertionError, intro |
| |
| def _setupGraphDelegation(self): |
| self.emit = self.graph.emit |
| self.newBlock = self.graph.newBlock |
| self.startBlock = self.graph.startBlock |
| self.nextBlock = self.graph.nextBlock |
| self.setDocstring = self.graph.setDocstring |
| |
| def getCode(self): |
| """Return a code object""" |
| return self.graph.getCode() |
| |
| def mangle(self, name): |
| if self.class_name is not None: |
| return misc.mangle(name, self.class_name) |
| else: |
| return name |
| |
| def parseSymbols(self, tree): |
| s = symbols.SymbolVisitor() |
| walk(tree, s) |
| return s.scopes |
| |
| def get_module(self): |
| raise RuntimeError, "should be implemented by subclasses" |
| |
| # Next five methods handle name access |
| |
| def isLocalName(self, name): |
| return self.locals.top().has_elt(name) |
| |
| def storeName(self, name): |
| self._nameOp('STORE', name) |
| |
| def loadName(self, name): |
| self._nameOp('LOAD', name) |
| |
| def delName(self, name): |
| self._nameOp('DELETE', name) |
| |
| def _nameOp(self, prefix, name): |
| name = self.mangle(name) |
| scope = self.scope.check_name(name) |
| if scope == SC_LOCAL: |
| if not self.optimized: |
| self.emit(prefix + '_NAME', name) |
| else: |
| self.emit(prefix + '_FAST', name) |
| elif scope == SC_GLOBAL: |
| if not self.optimized: |
| self.emit(prefix + '_NAME', name) |
| else: |
| self.emit(prefix + '_GLOBAL', name) |
| elif scope == SC_FREE or scope == SC_CELL: |
| self.emit(prefix + '_DEREF', name) |
| else: |
| raise RuntimeError, "unsupported scope for var %s: %d" % \ |
| (name, scope) |
| |
| def _implicitNameOp(self, prefix, name): |
| """Emit name ops for names generated implicitly by for loops |
| |
| The interpreter generates names that start with a period or |
| dollar sign. The symbol table ignores these names because |
| they aren't present in the program text. |
| """ |
| if self.optimized: |
| self.emit(prefix + '_FAST', name) |
| else: |
| self.emit(prefix + '_NAME', name) |
| |
| # The set_lineno() function and the explicit emit() calls for |
| # SET_LINENO below are only used to generate the line number table. |
| # As of Python 2.3, the interpreter does not have a SET_LINENO |
| # instruction. pyassem treats SET_LINENO opcodes as a special case. |
| |
| def set_lineno(self, node, force=False): |
| """Emit SET_LINENO if necessary. |
| |
| The instruction is considered necessary if the node has a |
| lineno attribute and it is different than the last lineno |
| emitted. |
| |
| Returns true if SET_LINENO was emitted. |
| |
| There are no rules for when an AST node should have a lineno |
| attribute. The transformer and AST code need to be reviewed |
| and a consistent policy implemented and documented. Until |
| then, this method works around missing line numbers. |
| """ |
| lineno = getattr(node, 'lineno', None) |
| if lineno is not None and (lineno != self.last_lineno |
| or force): |
| self.emit('SET_LINENO', lineno) |
| self.last_lineno = lineno |
| return True |
| return False |
| |
| # The first few visitor methods handle nodes that generator new |
| # code objects. They use class attributes to determine what |
| # specialized code generators to use. |
| |
| NameFinder = LocalNameFinder |
| FunctionGen = None |
| ClassGen = None |
| |
| def visitModule(self, node): |
| self.scopes = self.parseSymbols(node) |
| self.scope = self.scopes[node] |
| self.emit('SET_LINENO', 0) |
| if node.doc: |
| self.emit('LOAD_CONST', node.doc) |
| self.storeName('__doc__') |
| lnf = walk(node.node, self.NameFinder(), verbose=0) |
| self.locals.push(lnf.getLocals()) |
| self.visit(node.node) |
| self.emit('LOAD_CONST', None) |
| self.emit('RETURN_VALUE') |
| |
| def visitExpression(self, node): |
| self.set_lineno(node) |
| self.scopes = self.parseSymbols(node) |
| self.scope = self.scopes[node] |
| self.visit(node.node) |
| self.emit('RETURN_VALUE') |
| |
| def visitFunction(self, node): |
| self._visitFuncOrLambda(node, isLambda=0) |
| if node.doc: |
| self.setDocstring(node.doc) |
| self.storeName(node.name) |
| |
| def visitLambda(self, node): |
| self._visitFuncOrLambda(node, isLambda=1) |
| |
| def _visitFuncOrLambda(self, node, isLambda=0): |
| if not isLambda and node.decorators: |
| for decorator in node.decorators.nodes: |
| self.visit(decorator) |
| ndecorators = len(node.decorators.nodes) |
| else: |
| ndecorators = 0 |
| |
| gen = self.FunctionGen(node, self.scopes, isLambda, |
| self.class_name, self.get_module()) |
| walk(node.code, gen) |
| gen.finish() |
| self.set_lineno(node) |
| for default in node.defaults: |
| self.visit(default) |
| self._makeClosure(gen, len(node.defaults)) |
| for i in range(ndecorators): |
| self.emit('CALL_FUNCTION', 1) |
| |
| def visitClass(self, node): |
| gen = self.ClassGen(node, self.scopes, |
| self.get_module()) |
| walk(node.code, gen) |
| gen.finish() |
| self.set_lineno(node) |
| self.emit('LOAD_CONST', node.name) |
| for base in node.bases: |
| self.visit(base) |
| self.emit('BUILD_TUPLE', len(node.bases)) |
| self._makeClosure(gen, 0) |
| self.emit('CALL_FUNCTION', 0) |
| self.emit('BUILD_CLASS') |
| self.storeName(node.name) |
| |
| # The rest are standard visitor methods |
| |
| # The next few implement control-flow statements |
| |
| def visitIf(self, node): |
| end = self.newBlock() |
| numtests = len(node.tests) |
| for i in range(numtests): |
| test, suite = node.tests[i] |
| if is_constant_false(test): |
| # XXX will need to check generator stuff here |
| continue |
| self.set_lineno(test) |
| self.visit(test) |
| nextTest = self.newBlock() |
| self.emit('JUMP_IF_FALSE', nextTest) |
| self.nextBlock() |
| self.emit('POP_TOP') |
| self.visit(suite) |
| self.emit('JUMP_FORWARD', end) |
| self.startBlock(nextTest) |
| self.emit('POP_TOP') |
| if node.else_: |
| self.visit(node.else_) |
| self.nextBlock(end) |
| |
| def visitWhile(self, node): |
| self.set_lineno(node) |
| |
| loop = self.newBlock() |
| else_ = self.newBlock() |
| |
| after = self.newBlock() |
| self.emit('SETUP_LOOP', after) |
| |
| self.nextBlock(loop) |
| self.setups.push((LOOP, loop)) |
| |
| self.set_lineno(node, force=True) |
| self.visit(node.test) |
| self.emit('JUMP_IF_FALSE', else_ or after) |
| |
| self.nextBlock() |
| self.emit('POP_TOP') |
| self.visit(node.body) |
| self.emit('JUMP_ABSOLUTE', loop) |
| |
| self.startBlock(else_) # or just the POPs if not else clause |
| self.emit('POP_TOP') |
| self.emit('POP_BLOCK') |
| self.setups.pop() |
| if node.else_: |
| self.visit(node.else_) |
| self.nextBlock(after) |
| |
| def visitFor(self, node): |
| start = self.newBlock() |
| anchor = self.newBlock() |
| after = self.newBlock() |
| self.setups.push((LOOP, start)) |
| |
| self.set_lineno(node) |
| self.emit('SETUP_LOOP', after) |
| self.visit(node.list) |
| self.emit('GET_ITER') |
| |
| self.nextBlock(start) |
| self.set_lineno(node, force=1) |
| self.emit('FOR_ITER', anchor) |
| self.visit(node.assign) |
| self.visit(node.body) |
| self.emit('JUMP_ABSOLUTE', start) |
| self.nextBlock(anchor) |
| self.emit('POP_BLOCK') |
| self.setups.pop() |
| if node.else_: |
| self.visit(node.else_) |
| self.nextBlock(after) |
| |
| def visitBreak(self, node): |
| if not self.setups: |
| raise SyntaxError, "'break' outside loop (%s, %d)" % \ |
| (node.filename, node.lineno) |
| self.set_lineno(node) |
| self.emit('BREAK_LOOP') |
| |
| def visitContinue(self, node): |
| if not self.setups: |
| raise SyntaxError, "'continue' outside loop (%s, %d)" % \ |
| (node.filename, node.lineno) |
| kind, block = self.setups.top() |
| if kind == LOOP: |
| self.set_lineno(node) |
| self.emit('JUMP_ABSOLUTE', block) |
| self.nextBlock() |
| elif kind == EXCEPT or kind == TRY_FINALLY: |
| self.set_lineno(node) |
| # find the block that starts the loop |
| top = len(self.setups) |
| while top > 0: |
| top = top - 1 |
| kind, loop_block = self.setups[top] |
| if kind == LOOP: |
| break |
| if kind != LOOP: |
| raise SyntaxError, "'continue' outside loop (%s, %d)" % \ |
| (node.filename, node.lineno) |
| self.emit('CONTINUE_LOOP', loop_block) |
| self.nextBlock() |
| elif kind == END_FINALLY: |
| msg = "'continue' not allowed inside 'finally' clause (%s, %d)" |
| raise SyntaxError, msg % (node.filename, node.lineno) |
| |
| def visitTest(self, node, jump): |
| end = self.newBlock() |
| for child in node.nodes[:-1]: |
| self.visit(child) |
| self.emit(jump, end) |
| self.nextBlock() |
| self.emit('POP_TOP') |
| self.visit(node.nodes[-1]) |
| self.nextBlock(end) |
| |
| def visitAnd(self, node): |
| self.visitTest(node, 'JUMP_IF_FALSE') |
| |
| def visitOr(self, node): |
| self.visitTest(node, 'JUMP_IF_TRUE') |
| |
| def visitIfExp(self, node): |
| endblock = self.newBlock() |
| elseblock = self.newBlock() |
| self.visit(node.test) |
| self.emit('JUMP_IF_FALSE', elseblock) |
| self.emit('POP_TOP') |
| self.visit(node.then) |
| self.emit('JUMP_FORWARD', endblock) |
| self.nextBlock(elseblock) |
| self.emit('POP_TOP') |
| self.visit(node.else_) |
| self.nextBlock(endblock) |
| |
| def visitCompare(self, node): |
| self.visit(node.expr) |
| cleanup = self.newBlock() |
| for op, code in node.ops[:-1]: |
| self.visit(code) |
| self.emit('DUP_TOP') |
| self.emit('ROT_THREE') |
| self.emit('COMPARE_OP', op) |
| self.emit('JUMP_IF_FALSE', cleanup) |
| self.nextBlock() |
| self.emit('POP_TOP') |
| # now do the last comparison |
| if node.ops: |
| op, code = node.ops[-1] |
| self.visit(code) |
| self.emit('COMPARE_OP', op) |
| if len(node.ops) > 1: |
| end = self.newBlock() |
| self.emit('JUMP_FORWARD', end) |
| self.startBlock(cleanup) |
| self.emit('ROT_TWO') |
| self.emit('POP_TOP') |
| self.nextBlock(end) |
| |
| # list comprehensions |
| __list_count = 0 |
| |
| def visitListComp(self, node): |
| self.set_lineno(node) |
| # setup list |
| tmpname = "$list%d" % self.__list_count |
| self.__list_count = self.__list_count + 1 |
| self.emit('BUILD_LIST', 0) |
| self.emit('DUP_TOP') |
| self._implicitNameOp('STORE', tmpname) |
| |
| stack = [] |
| for i, for_ in zip(range(len(node.quals)), node.quals): |
| start, anchor = self.visit(for_) |
| cont = None |
| for if_ in for_.ifs: |
| if cont is None: |
| cont = self.newBlock() |
| self.visit(if_, cont) |
| stack.insert(0, (start, cont, anchor)) |
| |
| self._implicitNameOp('LOAD', tmpname) |
| self.visit(node.expr) |
| self.emit('LIST_APPEND') |
| |
| for start, cont, anchor in stack: |
| if cont: |
| skip_one = self.newBlock() |
| self.emit('JUMP_FORWARD', skip_one) |
| self.startBlock(cont) |
| self.emit('POP_TOP') |
| self.nextBlock(skip_one) |
| self.emit('JUMP_ABSOLUTE', start) |
| self.startBlock(anchor) |
| self._implicitNameOp('DELETE', tmpname) |
| |
| self.__list_count = self.__list_count - 1 |
| |
| def visitListCompFor(self, node): |
| start = self.newBlock() |
| anchor = self.newBlock() |
| |
| self.visit(node.list) |
| self.emit('GET_ITER') |
| self.nextBlock(start) |
| self.set_lineno(node, force=True) |
| self.emit('FOR_ITER', anchor) |
| self.nextBlock() |
| self.visit(node.assign) |
| return start, anchor |
| |
| def visitListCompIf(self, node, branch): |
| self.set_lineno(node, force=True) |
| self.visit(node.test) |
| self.emit('JUMP_IF_FALSE', branch) |
| self.newBlock() |
| self.emit('POP_TOP') |
| |
| def _makeClosure(self, gen, args): |
| frees = gen.scope.get_free_vars() |
| if frees: |
| for name in frees: |
| self.emit('LOAD_CLOSURE', name) |
| self.emit('BUILD_TUPLE', len(frees)) |
| self.emit('LOAD_CONST', gen) |
| self.emit('MAKE_CLOSURE', args) |
| else: |
| self.emit('LOAD_CONST', gen) |
| self.emit('MAKE_FUNCTION', args) |
| |
| def visitGenExpr(self, node): |
| gen = GenExprCodeGenerator(node, self.scopes, self.class_name, |
| self.get_module()) |
| walk(node.code, gen) |
| gen.finish() |
| self.set_lineno(node) |
| self._makeClosure(gen, 0) |
| # precomputation of outmost iterable |
| self.visit(node.code.quals[0].iter) |
| self.emit('GET_ITER') |
| self.emit('CALL_FUNCTION', 1) |
| |
| def visitGenExprInner(self, node): |
| self.set_lineno(node) |
| # setup list |
| |
| stack = [] |
| for i, for_ in zip(range(len(node.quals)), node.quals): |
| start, anchor, end = self.visit(for_) |
| cont = None |
| for if_ in for_.ifs: |
| if cont is None: |
| cont = self.newBlock() |
| self.visit(if_, cont) |
| stack.insert(0, (start, cont, anchor, end)) |
| |
| self.visit(node.expr) |
| self.emit('YIELD_VALUE') |
| self.emit('POP_TOP') |
| |
| for start, cont, anchor, end in stack: |
| if cont: |
| skip_one = self.newBlock() |
| self.emit('JUMP_FORWARD', skip_one) |
| self.startBlock(cont) |
| self.emit('POP_TOP') |
| self.nextBlock(skip_one) |
| self.emit('JUMP_ABSOLUTE', start) |
| self.startBlock(anchor) |
| self.emit('POP_BLOCK') |
| self.setups.pop() |
| self.startBlock(end) |
| |
| self.emit('LOAD_CONST', None) |
| |
| def visitGenExprFor(self, node): |
| start = self.newBlock() |
| anchor = self.newBlock() |
| end = self.newBlock() |
| |
| self.setups.push((LOOP, start)) |
| self.emit('SETUP_LOOP', end) |
| |
| if node.is_outmost: |
| self.loadName('.0') |
| else: |
| self.visit(node.iter) |
| self.emit('GET_ITER') |
| |
| self.nextBlock(start) |
| self.set_lineno(node, force=True) |
| self.emit('FOR_ITER', anchor) |
| self.nextBlock() |
| self.visit(node.assign) |
| return start, anchor, end |
| |
| def visitGenExprIf(self, node, branch): |
| self.set_lineno(node, force=True) |
| self.visit(node.test) |
| self.emit('JUMP_IF_FALSE', branch) |
| self.newBlock() |
| self.emit('POP_TOP') |
| |
| # exception related |
| |
| def visitAssert(self, node): |
| # XXX would be interesting to implement this via a |
| # transformation of the AST before this stage |
| if __debug__: |
| end = self.newBlock() |
| self.set_lineno(node) |
| # XXX AssertionError appears to be special case -- it is always |
| # loaded as a global even if there is a local name. I guess this |
| # is a sort of renaming op. |
| self.nextBlock() |
| self.visit(node.test) |
| self.emit('JUMP_IF_TRUE', end) |
| self.nextBlock() |
| self.emit('POP_TOP') |
| self.emit('LOAD_GLOBAL', 'AssertionError') |
| if node.fail: |
| self.visit(node.fail) |
| self.emit('RAISE_VARARGS', 2) |
| else: |
| self.emit('RAISE_VARARGS', 1) |
| self.nextBlock(end) |
| self.emit('POP_TOP') |
| |
| def visitRaise(self, node): |
| self.set_lineno(node) |
| n = 0 |
| if node.expr1: |
| self.visit(node.expr1) |
| n = n + 1 |
| if node.expr2: |
| self.visit(node.expr2) |
| n = n + 1 |
| if node.expr3: |
| self.visit(node.expr3) |
| n = n + 1 |
| self.emit('RAISE_VARARGS', n) |
| |
| def visitTryExcept(self, node): |
| body = self.newBlock() |
| handlers = self.newBlock() |
| end = self.newBlock() |
| if node.else_: |
| lElse = self.newBlock() |
| else: |
| lElse = end |
| self.set_lineno(node) |
| self.emit('SETUP_EXCEPT', handlers) |
| self.nextBlock(body) |
| self.setups.push((EXCEPT, body)) |
| self.visit(node.body) |
| self.emit('POP_BLOCK') |
| self.setups.pop() |
| self.emit('JUMP_FORWARD', lElse) |
| self.startBlock(handlers) |
| |
| last = len(node.handlers) - 1 |
| for i in range(len(node.handlers)): |
| expr, target, body = node.handlers[i] |
| self.set_lineno(expr) |
| if expr: |
| self.emit('DUP_TOP') |
| self.visit(expr) |
| self.emit('COMPARE_OP', 'exception match') |
| next = self.newBlock() |
| self.emit('JUMP_IF_FALSE', next) |
| self.nextBlock() |
| self.emit('POP_TOP') |
| self.emit('POP_TOP') |
| if target: |
| self.visit(target) |
| else: |
| self.emit('POP_TOP') |
| self.emit('POP_TOP') |
| self.visit(body) |
| self.emit('JUMP_FORWARD', end) |
| if expr: |
| self.nextBlock(next) |
| else: |
| self.nextBlock() |
| if expr: # XXX |
| self.emit('POP_TOP') |
| self.emit('END_FINALLY') |
| if node.else_: |
| self.nextBlock(lElse) |
| self.visit(node.else_) |
| self.nextBlock(end) |
| |
| def visitTryFinally(self, node): |
| body = self.newBlock() |
| final = self.newBlock() |
| self.set_lineno(node) |
| self.emit('SETUP_FINALLY', final) |
| self.nextBlock(body) |
| self.setups.push((TRY_FINALLY, body)) |
| self.visit(node.body) |
| self.emit('POP_BLOCK') |
| self.setups.pop() |
| self.emit('LOAD_CONST', None) |
| self.nextBlock(final) |
| self.setups.push((END_FINALLY, final)) |
| self.visit(node.final) |
| self.emit('END_FINALLY') |
| self.setups.pop() |
| |
| __with_count = 0 |
| |
| def visitWith(self, node): |
| body = self.newBlock() |
| final = self.newBlock() |
| valuevar = "$value%d" % self.__with_count |
| self.__with_count += 1 |
| self.set_lineno(node) |
| self.visit(node.expr) |
| self.emit('DUP_TOP') |
| self.emit('LOAD_ATTR', '__exit__') |
| self.emit('ROT_TWO') |
| self.emit('LOAD_ATTR', '__enter__') |
| self.emit('CALL_FUNCTION', 0) |
| if node.vars is None: |
| self.emit('POP_TOP') |
| else: |
| self._implicitNameOp('STORE', valuevar) |
| self.emit('SETUP_FINALLY', final) |
| self.nextBlock(body) |
| self.setups.push((TRY_FINALLY, body)) |
| if node.vars is not None: |
| self._implicitNameOp('LOAD', valuevar) |
| self._implicitNameOp('DELETE', valuevar) |
| self.visit(node.vars) |
| self.visit(node.body) |
| self.emit('POP_BLOCK') |
| self.setups.pop() |
| self.emit('LOAD_CONST', None) |
| self.nextBlock(final) |
| self.setups.push((END_FINALLY, final)) |
| self.emit('WITH_CLEANUP') |
| self.emit('END_FINALLY') |
| self.setups.pop() |
| self.__with_count -= 1 |
| |
| # misc |
| |
| def visitDiscard(self, node): |
| self.set_lineno(node) |
| self.visit(node.expr) |
| self.emit('POP_TOP') |
| |
| def visitConst(self, node): |
| self.emit('LOAD_CONST', node.value) |
| |
| def visitKeyword(self, node): |
| self.emit('LOAD_CONST', node.name) |
| self.visit(node.expr) |
| |
| def visitGlobal(self, node): |
| # no code to generate |
| pass |
| |
| def visitName(self, node): |
| self.set_lineno(node) |
| self.loadName(node.name) |
| |
| def visitPass(self, node): |
| self.set_lineno(node) |
| |
| def visitImport(self, node): |
| self.set_lineno(node) |
| level = 0 if self.graph.checkFlag(CO_FUTURE_ABSIMPORT) else -1 |
| for name, alias in node.names: |
| if VERSION > 1: |
| self.emit('LOAD_CONST', level) |
| self.emit('LOAD_CONST', None) |
| self.emit('IMPORT_NAME', name) |
| mod = name.split(".")[0] |
| if alias: |
| self._resolveDots(name) |
| self.storeName(alias) |
| else: |
| self.storeName(mod) |
| |
| def visitFrom(self, node): |
| self.set_lineno(node) |
| level = node.level |
| if level == 0 and not self.graph.checkFlag(CO_FUTURE_ABSIMPORT): |
| level = -1 |
| fromlist = map(lambda (name, alias): name, node.names) |
| if VERSION > 1: |
| self.emit('LOAD_CONST', level) |
| self.emit('LOAD_CONST', tuple(fromlist)) |
| self.emit('IMPORT_NAME', node.modname) |
| for name, alias in node.names: |
| if VERSION > 1: |
| if name == '*': |
| self.namespace = 0 |
| self.emit('IMPORT_STAR') |
| # There can only be one name w/ from ... import * |
| assert len(node.names) == 1 |
| return |
| else: |
| self.emit('IMPORT_FROM', name) |
| self._resolveDots(name) |
| self.storeName(alias or name) |
| else: |
| self.emit('IMPORT_FROM', name) |
| self.emit('POP_TOP') |
| |
| def _resolveDots(self, name): |
| elts = name.split(".") |
| if len(elts) == 1: |
| return |
| for elt in elts[1:]: |
| self.emit('LOAD_ATTR', elt) |
| |
| def visitGetattr(self, node): |
| self.visit(node.expr) |
| self.emit('LOAD_ATTR', self.mangle(node.attrname)) |
| |
| # next five implement assignments |
| |
| def visitAssign(self, node): |
| self.set_lineno(node) |
| self.visit(node.expr) |
| dups = len(node.nodes) - 1 |
| for i in range(len(node.nodes)): |
| elt = node.nodes[i] |
| if i < dups: |
| self.emit('DUP_TOP') |
| if isinstance(elt, ast.Node): |
| self.visit(elt) |
| |
| def visitAssName(self, node): |
| if node.flags == 'OP_ASSIGN': |
| self.storeName(node.name) |
| elif node.flags == 'OP_DELETE': |
| self.set_lineno(node) |
| self.delName(node.name) |
| else: |
| print "oops", node.flags |
| |
| def visitAssAttr(self, node): |
| self.visit(node.expr) |
| if node.flags == 'OP_ASSIGN': |
| self.emit('STORE_ATTR', self.mangle(node.attrname)) |
| elif node.flags == 'OP_DELETE': |
| self.emit('DELETE_ATTR', self.mangle(node.attrname)) |
| else: |
| print "warning: unexpected flags:", node.flags |
| print node |
| |
| def _visitAssSequence(self, node, op='UNPACK_SEQUENCE'): |
| if findOp(node) != 'OP_DELETE': |
| self.emit(op, len(node.nodes)) |
| for child in node.nodes: |
| self.visit(child) |
| |
| if VERSION > 1: |
| visitAssTuple = _visitAssSequence |
| visitAssList = _visitAssSequence |
| else: |
| def visitAssTuple(self, node): |
| self._visitAssSequence(node, 'UNPACK_TUPLE') |
| |
| def visitAssList(self, node): |
| self._visitAssSequence(node, 'UNPACK_LIST') |
| |
| # augmented assignment |
| |
| def visitAugAssign(self, node): |
| self.set_lineno(node) |
| aug_node = wrap_aug(node.node) |
| self.visit(aug_node, "load") |
| self.visit(node.expr) |
| self.emit(self._augmented_opcode[node.op]) |
| self.visit(aug_node, "store") |
| |
| _augmented_opcode = { |
| '+=' : 'INPLACE_ADD', |
| '-=' : 'INPLACE_SUBTRACT', |
| '*=' : 'INPLACE_MULTIPLY', |
| '/=' : 'INPLACE_DIVIDE', |
| '//=': 'INPLACE_FLOOR_DIVIDE', |
| '%=' : 'INPLACE_MODULO', |
| '**=': 'INPLACE_POWER', |
| '>>=': 'INPLACE_RSHIFT', |
| '<<=': 'INPLACE_LSHIFT', |
| '&=' : 'INPLACE_AND', |
| '^=' : 'INPLACE_XOR', |
| '|=' : 'INPLACE_OR', |
| } |
| |
| def visitAugName(self, node, mode): |
| if mode == "load": |
| self.loadName(node.name) |
| elif mode == "store": |
| self.storeName(node.name) |
| |
| def visitAugGetattr(self, node, mode): |
| if mode == "load": |
| self.visit(node.expr) |
| self.emit('DUP_TOP') |
| self.emit('LOAD_ATTR', self.mangle(node.attrname)) |
| elif mode == "store": |
| self.emit('ROT_TWO') |
| self.emit('STORE_ATTR', self.mangle(node.attrname)) |
| |
| def visitAugSlice(self, node, mode): |
| if mode == "load": |
| self.visitSlice(node, 1) |
| elif mode == "store": |
| slice = 0 |
| if node.lower: |
| slice = slice | 1 |
| if node.upper: |
| slice = slice | 2 |
| if slice == 0: |
| self.emit('ROT_TWO') |
| elif slice == 3: |
| self.emit('ROT_FOUR') |
| else: |
| self.emit('ROT_THREE') |
| self.emit('STORE_SLICE+%d' % slice) |
| |
| def visitAugSubscript(self, node, mode): |
| if mode == "load": |
| self.visitSubscript(node, 1) |
| elif mode == "store": |
| self.emit('ROT_THREE') |
| self.emit('STORE_SUBSCR') |
| |
| def visitExec(self, node): |
| self.visit(node.expr) |
| if node.locals is None: |
| self.emit('LOAD_CONST', None) |
| else: |
| self.visit(node.locals) |
| if node.globals is None: |
| self.emit('DUP_TOP') |
| else: |
| self.visit(node.globals) |
| self.emit('EXEC_STMT') |
| |
| def visitCallFunc(self, node): |
| pos = 0 |
| kw = 0 |
| self.set_lineno(node) |
| self.visit(node.node) |
| for arg in node.args: |
| self.visit(arg) |
| if isinstance(arg, ast.Keyword): |
| kw = kw + 1 |
| else: |
| pos = pos + 1 |
| if node.star_args is not None: |
| self.visit(node.star_args) |
| if node.dstar_args is not None: |
| self.visit(node.dstar_args) |
| have_star = node.star_args is not None |
| have_dstar = node.dstar_args is not None |
| opcode = callfunc_opcode_info[have_star, have_dstar] |
| self.emit(opcode, kw << 8 | pos) |
| |
| def visitPrint(self, node, newline=0): |
| self.set_lineno(node) |
| if node.dest: |
| self.visit(node.dest) |
| for child in node.nodes: |
| if node.dest: |
| self.emit('DUP_TOP') |
| self.visit(child) |
| if node.dest: |
| self.emit('ROT_TWO') |
| self.emit('PRINT_ITEM_TO') |
| else: |
| self.emit('PRINT_ITEM') |
| if node.dest and not newline: |
| self.emit('POP_TOP') |
| |
| def visitPrintnl(self, node): |
| self.visitPrint(node, newline=1) |
| if node.dest: |
| self.emit('PRINT_NEWLINE_TO') |
| else: |
| self.emit('PRINT_NEWLINE') |
| |
| def visitReturn(self, node): |
| self.set_lineno(node) |
| self.visit(node.value) |
| self.emit('RETURN_VALUE') |
| |
| def visitYield(self, node): |
| self.set_lineno(node) |
| self.visit(node.value) |
| self.emit('YIELD_VALUE') |
| |
| # slice and subscript stuff |
| |
| def visitSlice(self, node, aug_flag=None): |
| # aug_flag is used by visitAugSlice |
| self.visit(node.expr) |
| slice = 0 |
| if node.lower: |
| self.visit(node.lower) |
| slice = slice | 1 |
| if node.upper: |
| self.visit(node.upper) |
| slice = slice | 2 |
| if aug_flag: |
| if slice == 0: |
| self.emit('DUP_TOP') |
| elif slice == 3: |
| self.emit('DUP_TOPX', 3) |
| else: |
| self.emit('DUP_TOPX', 2) |
| if node.flags == 'OP_APPLY': |
| self.emit('SLICE+%d' % slice) |
| elif node.flags == 'OP_ASSIGN': |
| self.emit('STORE_SLICE+%d' % slice) |
| elif node.flags == 'OP_DELETE': |
| self.emit('DELETE_SLICE+%d' % slice) |
| else: |
| print "weird slice", node.flags |
| raise |
| |
| def visitSubscript(self, node, aug_flag=None): |
| self.visit(node.expr) |
| for sub in node.subs: |
| self.visit(sub) |
| if len(node.subs) > 1: |
| self.emit('BUILD_TUPLE', len(node.subs)) |
| if aug_flag: |
| self.emit('DUP_TOPX', 2) |
| if node.flags == 'OP_APPLY': |
| self.emit('BINARY_SUBSCR') |
| elif node.flags == 'OP_ASSIGN': |
| self.emit('STORE_SUBSCR') |
| elif node.flags == 'OP_DELETE': |
| self.emit('DELETE_SUBSCR') |
| |
| # binary ops |
| |
| def binaryOp(self, node, op): |
| self.visit(node.left) |
| self.visit(node.right) |
| self.emit(op) |
| |
| def visitAdd(self, node): |
| return self.binaryOp(node, 'BINARY_ADD') |
| |
| def visitSub(self, node): |
| return self.binaryOp(node, 'BINARY_SUBTRACT') |
| |
| def visitMul(self, node): |
| return self.binaryOp(node, 'BINARY_MULTIPLY') |
| |
| def visitDiv(self, node): |
| return self.binaryOp(node, self._div_op) |
| |
| def visitFloorDiv(self, node): |
| return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE') |
| |
| def visitMod(self, node): |
| return self.binaryOp(node, 'BINARY_MODULO') |
| |
| def visitPower(self, node): |
| return self.binaryOp(node, 'BINARY_POWER') |
| |
| def visitLeftShift(self, node): |
| return self.binaryOp(node, 'BINARY_LSHIFT') |
| |
| def visitRightShift(self, node): |
| return self.binaryOp(node, 'BINARY_RSHIFT') |
| |
| # unary ops |
| |
| def unaryOp(self, node, op): |
| self.visit(node.expr) |
| self.emit(op) |
| |
| def visitInvert(self, node): |
| return self.unaryOp(node, 'UNARY_INVERT') |
| |
| def visitUnarySub(self, node): |
| return self.unaryOp(node, 'UNARY_NEGATIVE') |
| |
| def visitUnaryAdd(self, node): |
| return self.unaryOp(node, 'UNARY_POSITIVE') |
| |
| def visitUnaryInvert(self, node): |
| return self.unaryOp(node, 'UNARY_INVERT') |
| |
| def visitNot(self, node): |
| return self.unaryOp(node, 'UNARY_NOT') |
| |
| def visitBackquote(self, node): |
| return self.unaryOp(node, 'UNARY_CONVERT') |
| |
| # bit ops |
| |
| def bitOp(self, nodes, op): |
| self.visit(nodes[0]) |
| for node in nodes[1:]: |
| self.visit(node) |
| self.emit(op) |
| |
| def visitBitand(self, node): |
| return self.bitOp(node.nodes, 'BINARY_AND') |
| |
| def visitBitor(self, node): |
| return self.bitOp(node.nodes, 'BINARY_OR') |
| |
| def visitBitxor(self, node): |
| return self.bitOp(node.nodes, 'BINARY_XOR') |
| |
| # object constructors |
| |
| def visitEllipsis(self, node): |
| self.emit('LOAD_CONST', Ellipsis) |
| |
| def visitTuple(self, node): |
| self.set_lineno(node) |
| for elt in node.nodes: |
| self.visit(elt) |
| self.emit('BUILD_TUPLE', len(node.nodes)) |
| |
| def visitList(self, node): |
| self.set_lineno(node) |
| for elt in node.nodes: |
| self.visit(elt) |
| self.emit('BUILD_LIST', len(node.nodes)) |
| |
| def visitSliceobj(self, node): |
| for child in node.nodes: |
| self.visit(child) |
| self.emit('BUILD_SLICE', len(node.nodes)) |
| |
| def visitDict(self, node): |
| self.set_lineno(node) |
| self.emit('BUILD_MAP', 0) |
| for k, v in node.items: |
| self.emit('DUP_TOP') |
| self.visit(k) |
| self.visit(v) |
| self.emit('ROT_THREE') |
| self.emit('STORE_SUBSCR') |
| |
| class NestedScopeMixin: |
| """Defines initClass() for nested scoping (Python 2.2-compatible)""" |
| def initClass(self): |
| self.__class__.NameFinder = LocalNameFinder |
| self.__class__.FunctionGen = FunctionCodeGenerator |
| self.__class__.ClassGen = ClassCodeGenerator |
| |
| class ModuleCodeGenerator(NestedScopeMixin, CodeGenerator): |
| __super_init = CodeGenerator.__init__ |
| |
| scopes = None |
| |
| def __init__(self, tree): |
| self.graph = pyassem.PyFlowGraph("<module>", tree.filename) |
| self.futures = future.find_futures(tree) |
| self.__super_init() |
| walk(tree, self) |
| |
| def get_module(self): |
| return self |
| |
| class ExpressionCodeGenerator(NestedScopeMixin, CodeGenerator): |
| __super_init = CodeGenerator.__init__ |
| |
| scopes = None |
| futures = () |
| |
| def __init__(self, tree): |
| self.graph = pyassem.PyFlowGraph("<expression>", tree.filename) |
| self.__super_init() |
| walk(tree, self) |
| |
| def get_module(self): |
| return self |
| |
| class InteractiveCodeGenerator(NestedScopeMixin, CodeGenerator): |
| |
| __super_init = CodeGenerator.__init__ |
| |
| scopes = None |
| futures = () |
| |
| def __init__(self, tree): |
| self.graph = pyassem.PyFlowGraph("<interactive>", tree.filename) |
| self.__super_init() |
| self.set_lineno(tree) |
| walk(tree, self) |
| self.emit('RETURN_VALUE') |
| |
| def get_module(self): |
| return self |
| |
| def visitDiscard(self, node): |
| # XXX Discard means it's an expression. Perhaps this is a bad |
| # name. |
| self.visit(node.expr) |
| self.emit('PRINT_EXPR') |
| |
| class AbstractFunctionCode: |
| optimized = 1 |
| lambdaCount = 0 |
| |
| def __init__(self, func, scopes, isLambda, class_name, mod): |
| self.class_name = class_name |
| self.module = mod |
| if isLambda: |
| klass = FunctionCodeGenerator |
| name = "<lambda.%d>" % klass.lambdaCount |
| klass.lambdaCount = klass.lambdaCount + 1 |
| else: |
| name = func.name |
| |
| args, hasTupleArg = generateArgList(func.argnames) |
| self.graph = pyassem.PyFlowGraph(name, func.filename, args, |
| optimized=1) |
| self.isLambda = isLambda |
| self.super_init() |
| |
| if not isLambda and func.doc: |
| self.setDocstring(func.doc) |
| |
| lnf = walk(func.code, self.NameFinder(args), verbose=0) |
| self.locals.push(lnf.getLocals()) |
| if func.varargs: |
| self.graph.setFlag(CO_VARARGS) |
| if func.kwargs: |
| self.graph.setFlag(CO_VARKEYWORDS) |
| self.set_lineno(func) |
| if hasTupleArg: |
| self.generateArgUnpack(func.argnames) |
| |
| def get_module(self): |
| return self.module |
| |
| def finish(self): |
| self.graph.startExitBlock() |
| if not self.isLambda: |
| self.emit('LOAD_CONST', None) |
| self.emit('RETURN_VALUE') |
| |
| def generateArgUnpack(self, args): |
| for i in range(len(args)): |
| arg = args[i] |
| if isinstance(arg, tuple): |
| self.emit('LOAD_FAST', '.%d' % (i * 2)) |
| self.unpackSequence(arg) |
| |
| def unpackSequence(self, tup): |
| if VERSION > 1: |
| self.emit('UNPACK_SEQUENCE', len(tup)) |
| else: |
| self.emit('UNPACK_TUPLE', len(tup)) |
| for elt in tup: |
| if isinstance(elt, tuple): |
| self.unpackSequence(elt) |
| else: |
| self._nameOp('STORE', elt) |
| |
| unpackTuple = unpackSequence |
| |
| class FunctionCodeGenerator(NestedScopeMixin, AbstractFunctionCode, |
| CodeGenerator): |
| super_init = CodeGenerator.__init__ # call be other init |
| scopes = None |
| |
| __super_init = AbstractFunctionCode.__init__ |
| |
| def __init__(self, func, scopes, isLambda, class_name, mod): |
| self.scopes = scopes |
| self.scope = scopes[func] |
| self.__super_init(func, scopes, isLambda, class_name, mod) |
| self.graph.setFreeVars(self.scope.get_free_vars()) |
| self.graph.setCellVars(self.scope.get_cell_vars()) |
| if self.scope.generator is not None: |
| self.graph.setFlag(CO_GENERATOR) |
| |
| class GenExprCodeGenerator(NestedScopeMixin, AbstractFunctionCode, |
| CodeGenerator): |
| super_init = CodeGenerator.__init__ # call be other init |
| scopes = None |
| |
| __super_init = AbstractFunctionCode.__init__ |
| |
| def __init__(self, gexp, scopes, class_name, mod): |
| self.scopes = scopes |
| self.scope = scopes[gexp] |
| self.__super_init(gexp, scopes, 1, class_name, mod) |
| self.graph.setFreeVars(self.scope.get_free_vars()) |
| self.graph.setCellVars(self.scope.get_cell_vars()) |
| self.graph.setFlag(CO_GENERATOR) |
| |
| class AbstractClassCode: |
| |
| def __init__(self, klass, scopes, module): |
| self.class_name = klass.name |
| self.module = module |
| self.graph = pyassem.PyFlowGraph(klass.name, klass.filename, |
| optimized=0, klass=1) |
| self.super_init() |
| lnf = walk(klass.code, self.NameFinder(), verbose=0) |
| self.locals.push(lnf.getLocals()) |
| self.graph.setFlag(CO_NEWLOCALS) |
| if klass.doc: |
| self.setDocstring(klass.doc) |
| |
| def get_module(self): |
| return self.module |
| |
| def finish(self): |
| self.graph.startExitBlock() |
| self.emit('LOAD_LOCALS') |
| self.emit('RETURN_VALUE') |
| |
| class ClassCodeGenerator(NestedScopeMixin, AbstractClassCode, CodeGenerator): |
| super_init = CodeGenerator.__init__ |
| scopes = None |
| |
| __super_init = AbstractClassCode.__init__ |
| |
| def __init__(self, klass, scopes, module): |
| self.scopes = scopes |
| self.scope = scopes[klass] |
| self.__super_init(klass, scopes, module) |
| self.graph.setFreeVars(self.scope.get_free_vars()) |
| self.graph.setCellVars(self.scope.get_cell_vars()) |
| self.set_lineno(klass) |
| self.emit("LOAD_GLOBAL", "__name__") |
| self.storeName("__module__") |
| if klass.doc: |
| self.emit("LOAD_CONST", klass.doc) |
| self.storeName('__doc__') |
| |
| def generateArgList(arglist): |
| """Generate an arg list marking TupleArgs""" |
| args = [] |
| extra = [] |
| count = 0 |
| for i in range(len(arglist)): |
| elt = arglist[i] |
| if isinstance(elt, str): |
| args.append(elt) |
| elif isinstance(elt, tuple): |
| args.append(TupleArg(i * 2, elt)) |
| extra.extend(misc.flatten(elt)) |
| count = count + 1 |
| else: |
| raise ValueError, "unexpect argument type:", elt |
| return args + extra, count |
| |
| def findOp(node): |
| """Find the op (DELETE, LOAD, STORE) in an AssTuple tree""" |
| v = OpFinder() |
| walk(node, v, verbose=0) |
| return v.op |
| |
| class OpFinder: |
| def __init__(self): |
| self.op = None |
| def visitAssName(self, node): |
| if self.op is None: |
| self.op = node.flags |
| elif self.op != node.flags: |
| raise ValueError, "mixed ops in stmt" |
| visitAssAttr = visitAssName |
| visitSubscript = visitAssName |
| |
| class Delegator: |
| """Base class to support delegation for augmented assignment nodes |
| |
| To generator code for augmented assignments, we use the following |
| wrapper classes. In visitAugAssign, the left-hand expression node |
| is visited twice. The first time the visit uses the normal method |
| for that node . The second time the visit uses a different method |
| that generates the appropriate code to perform the assignment. |
| These delegator classes wrap the original AST nodes in order to |
| support the variant visit methods. |
| """ |
| def __init__(self, obj): |
| self.obj = obj |
| |
| def __getattr__(self, attr): |
| return getattr(self.obj, attr) |
| |
| class AugGetattr(Delegator): |
| pass |
| |
| class AugName(Delegator): |
| pass |
| |
| class AugSlice(Delegator): |
| pass |
| |
| class AugSubscript(Delegator): |
| pass |
| |
| wrapper = { |
| ast.Getattr: AugGetattr, |
| ast.Name: AugName, |
| ast.Slice: AugSlice, |
| ast.Subscript: AugSubscript, |
| } |
| |
| def wrap_aug(node): |
| return wrapper[node.__class__](node) |
| |
| if __name__ == "__main__": |
| for file in sys.argv[1:]: |
| compileFile(file) |
