def file_input(self, nodelist): # Add a "from IO_MODULE import IO_CLASS" statement to the # beginning of the module. doc = None # self.get_docstring(nodelist, symbol.file_input) if sys.hexversion >= 0x02050000: io_imp = ast.From(IO_MODULE, [(IO_CLASS, None)], 0) markup_imp = ast.From(MARKUP_MODULE, [(MARKUP_CLASS, None)], 0) else: io_imp = ast.From(IO_MODULE, [(IO_CLASS, None)]) markup_imp = ast.From(MARKUP_MODULE, [(MARKUP_CLASS, None)]) markup_assign = ast.Assign( [ast.AssName(MARKUP_MANGLED_CLASS, OP_ASSIGN)], ast.Name(MARKUP_CLASS)) # Add an IO_INSTANCE binding for module level expressions (like # doc strings). This instance will not be returned. io_instance = ast.CallFunc(ast.Name(IO_CLASS), []) io_assign_name = ast.AssName(IO_INSTANCE, OP_ASSIGN) io_assign = ast.Assign([io_assign_name], io_instance) stmts = [io_imp, io_assign, markup_imp, markup_assign] for node in nodelist: if node[0] != token.ENDMARKER and node[0] != token.NEWLINE: self.com_append_stmt(stmts, node) return ast.Module(doc, ast.Stmt(stmts))
def compileCodeObjects(filename, codeobjs): if len(codeobjs) == 0: stmts = [] else: stmts = [ast.For(ast.AssName('[--codeobj--]', 'OP_ASSIGN'), ast.Const(codeobjs), ast.Stmt([ast.Exec(ast.Name('[--codeobj--]'), None, None)]), None), ast.AssName('[--codeobj--]', 'OP_DELETE')] module = ast.Module(None, ast.Stmt(stmts)) compiler.misc.set_filename(filename, module) return pycodegen.ModuleCodeGenerator(module).getCode()
def Assign(left, right): names = [] if isinstance(left, ast.Name): # Single assignment on left return ast.Assign([ast.AssName(left.name, 'OP_ASSIGN')], right) elif isinstance(left, ast.Tuple): # List of things - make sure they are Name nodes names = [] for child in left.getChildren(): if not isinstance(child, ast.Name): raise SyntaxError("that assignment not supported") names.append(child.name) ass_list = [ast.AssName(name, 'OP_ASSIGN') for name in names] return ast.Assign([ast.AssTuple(ass_list)], right) else: raise SyntaxError("Can't do that yet")
def compileDeflang(self, name, parentx, body): assert isinstance(name, Symbol) if parentx: assertResult(parentx, "derive language from") parent = topy(parentx) else: parent = logixglobal('langlang') funcname = "#lang:%s" % name body = len(body) > 0 and block(body, False).nodes or [] funcbody = ast.Stmt( body + [ast.CallFunc(ast.Getattr(ast.Getattr(ast.Name(str(name)), '__impl__'), 'addDeflangLocals'), [ast.CallFunc(ast.Name('locals'), [])])]) res = ast.Stmt([ ast.Assign([compilePlace(Symbol(name))], ast.CallFunc(logixglobal('defLanguage'), [ast.Const(str(name)), parent, ast.CallFunc(GlobalName("globals"), [])])), astFunction(funcname, tuple(), tuple(), 0, None, funcbody), ast.CallFunc(ast.Name(funcname), []), ast.AssName(funcname, 'OP_DELETE')]) lineno = getmeta(self, 'lineno') for n in res.nodes: n.lineno = lineno res.lineno = lineno return res
def function(self, name, expr): """ Create a function of one argument with the given name returning the given expr. @param name: The function name. @param expr: The AST to insert into the function. """ fexpr = ast.Stmt([ast.Assign([ast.AssName('__locals', 'OP_ASSIGN')], ast.Dict([(ast.Const('self'), ast.Name('self'))])), ast.Assign([ast.Subscript(ast.Getattr( ast.Name('self'), 'locals'), 'OP_ASSIGN', [ast.Const( name.split('_',1)[1])])], ast.Name('__locals')), expr]) f = ast.Lambda(['self'], [], 0, fexpr) f.filename = self.name return f
def compilePlace(place, opname='OP_ASSIGN'): if isinstance(place, Symbol): return ast.AssName(str(place), opname) elif isinstance(place, rootops.PyOp): token = place.__syntax__.token if token == ".": # {{{ assign to field expr = topy(place[0]) field = place[1] if isinstance(field, Symbol): return ast.AssAttr(expr, str(field), opname) else: raise CompileError("Cannot assign to %s" % place) # }}} elif token == "__continue__": # {{{ assign to slice or subscript last = place[1][-1] # expr = the continuationOp not including the last part if len(place[1]) == 1: expr = place[0] else: expr = basel.getContinuationOp()(place[0], place[1][:-1]) kind = last[-1] if kind == 'subscript': # {{{ assign to subscript assertResult(expr, "subscript") keys = last[:-1] for key in keys: assertResult(key, "subscript with") return ast.Subscript(topy(expr), opname, map(topy, keys)) # }}} elif kind == "slice": # {{{ assign to slice assertResult(expr, "slice") start,end,step = last[:-1] assertResult(start, "slice from ") assertResult(end, "slice to") assertResult(step, "slice with step") return ast.Subscript(topy(expr), opname, [ast.Sliceobj(map(topy, (start,end,step)))]) # }}} else: raise CompileError("Cannot asign to %s " % place) # }}} elif token == ",": return ast.AssTuple([compilePlace(p, opname) for p in list(place)]) elif token == "[" and place[1] == 'list': return ast.AssList([compilePlace(p, opname) for p in place.elems]) elif token == "(": return compilePlace(place[1], opname) else: raise CompileError("Cannot asign to %s " % place) else: raise CompileError("Cannot assign to %s" % place)
def compilePlace(place, opname='OP_ASSIGN'): # {{{ def compileSubscriptPlace(objx, keyxs): def compileSubscriptPlace(objx, keyxs): assertResult(objx, "subscript") for key in keyxs: assertResult(key, "subscript with") return ast.Subscript(topy(objx), opname, map(topy, keyxs)) # }}} # {{{ def compileSlicePlace(objx, fromx, tox, stepx): def compileSlicePlace(objx, fromx, tox, stepx): assertResult(objx, "slice") assertResult(fromx, "slice from ") assertResult(tox, "slice to") assertResult(stepx, "slice with step") return ast.Subscript(topy(objx), opname, [ast.Sliceobj(map(topy, (fromx, tox, stepx)))]) # }}} if isinstance(place, Symbol): if place.namespace != "": raise CompileError, "cannot assign to symbol with namespace: %s" % place return ast.AssName(place.name, opname) elif isDoc(place, rootops.sliceOp): return compileSlicePlace(place[0], place[1], place[2], place[3]) elif isDoc(place, rootops.subscriptOp): return compileSubscriptPlace(place[0], place[1:]) elif isPyOp(place): token = place.tag.name if token == ".": # {{{ assign to field expr = topy(place[0]) field = place[1] if isinstance(field, Symbol) and field.namespace == "": return ast.AssAttr(expr, field.name, opname) else: raise CompileError("Cannot assign to %s" % place) # }}} elif token == "": # continuation op # {{{ assign to slice or subscript last = place[-1] # expr = the continuationOp not including the last part if len(place) == 2: expr = place[0] else: expr = Doc(Symbol(rootops.base_ns, ""), place[:-1]) kind = last[-1] if kind == 'subscript': return compileSubscriptPlace(expr, last[:-1]) elif kind == "slice": start,end,step = last[:-1] return compileSlicePlace(expr, start, end, step) else: raise CompileError("Cannot asign to %s " % place) # }}} elif token == ",": return ast.AssTuple([compilePlace(p, opname) for p in list(place)]) elif token == "[" and place[1] == 'list': return ast.AssList([compilePlace(p, opname) for p in place]) elif token == "(": return compilePlace(place[1], opname) else: raise CompileError("Cannot asign to %s " % place) else: raise CompileError("Cannot assign to %s" % place)
def funcdef(self, nodelist): if len(nodelist) == 6: assert nodelist[0][0] == symbol.decorators decorators = self.decorators(nodelist[0][1:]) else: assert len(nodelist) == 5 decorators = None lineno = nodelist[-4][2] name = nodelist[-4][1] args = nodelist[-3][2] if not re.match('_q_((html|plain)_)?template_', name): # just a normal function, let base class handle it self.__template_type.append(None) n = transformer.Transformer.funcdef(self, nodelist) else: if name.startswith(PLAIN_TEMPLATE_PREFIX): name = name[len(PLAIN_TEMPLATE_PREFIX):] template_type = "plain" elif name.startswith(HTML_TEMPLATE_PREFIX): name = name[len(HTML_TEMPLATE_PREFIX):] template_type = "html" elif name.startswith(TEMPLATE_PREFIX): name = name[len(TEMPLATE_PREFIX):] template_type = "plain" else: raise RuntimeError, 'unknown prefix on %s' % name self.__template_type.append(template_type) # Add "IO_INSTANCE = IO_CLASS()" statement at the beginning of # the function and a "return IO_INSTANCE" at the end. if args[0] == symbol.varargslist: names, defaults, flags = self.com_arglist(args[1:]) else: names = defaults = () flags = 0 doc = None # self.get_docstring(nodelist[-1]) # code for function code = self.com_node(nodelist[-1]) # create an instance, assign to IO_INSTANCE klass = ast.Name(IO_CLASS) args = [ast.Const(template_type == "html")] instance = ast.CallFunc(klass, args) assign_name = ast.AssName(IO_INSTANCE, OP_ASSIGN) assign = ast.Assign([assign_name], instance) # return the IO_INSTANCE.getvalue(...) func = ast.Getattr(ast.Name(IO_INSTANCE), "getvalue") ret = ast.Return(ast.CallFunc(func, [])) # wrap original function code code = ast.Stmt([assign, code, ret]) if sys.hexversion >= 0x20400a2: n = ast.Function(decorators, name, names, defaults, flags, doc, code) else: n = ast.Function(name, names, defaults, flags, doc, code) n.lineno = lineno self.__template_type.pop() return n
def _do_NameExpression(self, node, context): name = str(node.Name) if context == OP_APPLY: return ast.Name(name) else: return ast.AssName(name, context)
def STORE_FAST(decompiler, varname): if varname.startswith('_['): throw(InvalidQuery('Use generator expression (... for ... in ...) instead of list comprehension [... for ... in ...] inside query')) decompiler.assnames.add(varname) decompiler.store(ast.AssName(varname, 'OP_ASSIGN'))
def STORE_DEREF(decompiler, freevar): decompiler.assnames.add(freevar) decompiler.store(ast.AssName(freevar, 'OP_ASSIGN'))