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 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 quote(obj, depth=1): assert depth > 0 if isinstance(obj, rootops.quote): depth += 1 elif isinstance(obj, rootops.escape): extra = obj.__operands__.get('extra', []) escapelevel = 1 + len(extra) if escapelevel > depth: raise CompileError("invalid quote escape") elif escapelevel == depth: if obj.__operands__.hasField('splice'): raise CompileError("Can't splice here") elif obj.__operands__.hasField("localmodule"): return topy(localModuleQuote()) else: assertResult(obj[0], "insert into quote") return topy(obj[0]) if isinstance(type(obj), OperatorType): # {{{ generate code to build the operator cls = obj.__class__ if cls.__module__ == '%s.rootops' % logixModuleName: classx = ast.Getattr(logixglobal('rootops'), cls.__name__) else: optoken = obj.__class__.__syntax__.token classx = compileGetOp(obj) operands = macros.gensym("operands") return ast.Stmt([ast.Assign([compilePlace(operands)], quotedArgs(obj.__operands__, depth)), ast.CallFunc(classx, [], ast.Getattr(topy(operands), "elems"), ast.Getattr(topy(operands), "fields"))]) # }}} elif isinstance(obj, flist): # {{{ generate code to build the flist return quotedArgs(obj, depth) # }}} elif isinstance(obj, Symbol): # {{{ generate code to build the symbol return ast.CallFunc(logixglobal('Symbol'), [ast.Const(obj.asStr())]) # }}} elif isinstance(obj, (tuple, list, dict)): # Q: Is this ok? assert 0, "didn't expect one of those to be quoted" else: return topy(obj)
def bind(self, expr, name): """ Generates code for binding a name to a value in the rule's locals dict. """ return ast.Stmt([ ast.Assign([ast.Subscript(ast.Name('__locals'), 'OP_ASSIGN', [ast.Const(name)])], expr), ast.Subscript(ast.Name('__locals'), 'OP_APPLY', [ast.Const(name)])])
def assign(self, place, val): "=" if isinstance(val, self.__class__): # chained assign (a = b = blah) res = topy(val) res.nodes.append(compilePlace(place)) return res else: assertResult(val, "assign from") res = ast.Assign([compilePlace(place)], topy(val)) 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 compileCodeObjects(filename, codeobjs): if len(codeobjs) == 0: stmts = [] else: stmts = [ast.Assign([ast.AssName('__reload__', 'OP_ASSIGN')], ast.List(())), 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 run(self, frame): expr = Interpretable(self.expr) expr.eval(frame) self.result = expr.result self.explanation = '... = ' + expr.explanation # fall-back-run the rest of the assignment ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr')) mod = ast.Module(None, ast.Stmt([ass])) mod.filename = '<run>' co = pycodegen.ModuleCodeGenerator(mod).getCode() try: frame.exec_(co, __exprinfo_expr=expr.result) except passthroughex: raise except: raise Failure(self)
def expr_stmt(self, nodelist): if not self.__template_type or not self.__template_type[-1]: return transformer.Transformer.expr_stmt(self, nodelist) # Instead of discarding objects on the stack, call # "IO_INSTANCE += obj". exprNode = self.com_node(nodelist[-1]) if len(nodelist) == 1: lval = ast.Name(IO_INSTANCE) n = ast.AugAssign(lval, '+=', exprNode) if hasattr(exprNode, 'lineno'): n.lineno = exprNode.lineno elif nodelist[1][0] == token.EQUAL: nodes = [] for i in range(0, len(nodelist) - 2, 2): nodes.append(self.com_assign(nodelist[i], OP_ASSIGN)) n = ast.Assign(nodes, exprNode) n.lineno = nodelist[1][2] else: lval = self.com_augassign(nodelist[0]) op = self.com_augassign_op(nodelist[1]) n = ast.AugAssign(lval, op[1], exprNode) n.lineno = op[2] return n
def quotedArgs(operands, depth): """ Generate code from an flist of operand expressions, possibly containing splices. Returns an expression that constructs an flist. """ parts = [] for x in operands.elems: if isinstance(x, rootops.escape): extra = x.__operands__.get('extra', []) escapelevel = 1 + len(extra) if escapelevel > depth: raise CompileError("invalid quote escape") escape = escapelevel == depth else: escape = False if escape: if x.__operands__.hasField("splice"): assertResult(x[0], "insert into quote") parts.append( ('s', topy(x[0])) ) # 's' == splice elif x.__operands__.hasField("localmodule"): parts.append( ('v',topy(localModuleQuote())) ) else: assertResult(x[0], "insert into quote") parts.append( ('v', topy(x[0])) ) # 'v' == plain value else: parts.append( ('v', quote(x, depth)) ) # 'v' == plain value # {{{ expr = reduce parts to a single expression # If there is just a single splice, then that is the expression # otherwise generate: val = ??; val.extend(??); val.extend(??)... def frontSection(parts): vals = list(itools.takewhile(lambda (tag, exp): tag == 'v', parts)) if len(vals) == 0: return parts[0][1], parts[1:] else: return ast.List([v[1] for v in vals]), parts[len(vals):] if len(parts) == 0: expr = ast.List([]) else: first, rest = frontSection(parts) if len(rest) == 0: expr = first else: # Generate: # val = ...; if not hasattr(val, 'extend'): val = list(val) val = macros.gensym("val") statements = [ ast.Assign([compilePlace(val)], first), ast.If([(ast.CallFunc(GlobalName('isinstance'), [topy(val), logixglobal("flist")]), ast.Assign([compilePlace(val)], ast.CallFunc(ast.Getattr(topy(val), "copy"), [])))], #else ast.Assign([compilePlace(val)], ast.CallFunc(GlobalName('list'), [topy(val)])))] while len(rest) > 0: ex, rest = frontSection(rest) statements.append(ast.Discard(ast.CallFunc(ast.Getattr(topy(val), "extend"), [ex]))) statements.append(topy(val)) expr = ast.Stmt(statements) # }}} for v in operands.fields.values(): assertResult(v, "use as operand") keywords = ast.Dict([(ast.Const(n), quote(v, depth)) for n, v in operands.items()]) if isinstance(expr, ast.List): return ast.CallFunc(ast.Getattr(logixglobal("flist"), 'new'), [expr, keywords]) else: return ast.Add([expr, ast.CallFunc(ast.Getattr(logixglobal("flist"), 'new'), [ast.List([]), keywords])])
def quotedDoc(doc, depth): """ Generate code to build a Doc like `doc` with quote-escapes replaced by runtime values. """ # Each element of contentParts is either: # an AST - meaning a spliced value - the resulting content # should be `extend`ed by that value # a list of ASTs - a list of regular elements, the resulting # content should be `extend`ed by an ast.List # with these elements # {{{ contentParts = contentParts = [[]] for x in doc.content(): if isDoc(x, rootops.escape): escapelevel = 1 + len(x.get('extra', [])) if escapelevel > depth: raise CompileError("more quote escapes than quotes") escape = escapelevel == depth else: escape = False if escape: if x.hasProperty("splice"): assertResult(x[0], "insert into quote") contentParts.append(topy(x[0])) contentParts.append([]) elif x.hasProperty("localmodule"): contentParts[-1].append(topy(localModuleQuote())) else: assertResult(x[0], "insert into quote") contentParts[-1].append(topy(x[0])) else: contentParts[-1].append(quote(x, depth)) # }}} # These properties are added to the result doc *after* # any spliced in docs, so they overwrite any spliced properties for v in doc.propertyValues(): assertResult(v, "use as operand") properties = ast.Dict([(compileSymbol(n), quote(v, depth)) for n, v in doc.properties()]) # assert isinstance(contentParts[0], list) if contentParts == [[]]: return ast.CallFunc(logixglobal("Doc"), [compileSymbol(doc.tag), properties]) else: if len(contentParts[0]) > 0: docArg = ast.List(contentParts[0]) rest = contentParts[1:] elif len(contentParts) > 0: docArg = contentParts[1] rest = contentParts[2:] if len(rest) == 0: return ast.CallFunc(logixglobal("Doc"), [compileSymbol(doc.tag), docArg, properties]) else: val = macros.gensym("val") stmts = [ast.Assign([compilePlace(val)], ast.CallFunc(logixglobal("Doc"), [compileSymbol(doc.tag), docArg]))] for part in rest: if isinstance(part, list): if len(part) == 0: continue ext = ast.List(part) else: ext = part stmts.append(ast.Discard(ast.CallFunc(ast.Getattr(topy(val), "extend"), [ext]))) stmts.append(ast.Discard(ast.CallFunc(ast.Getattr(topy(val), "extend"), [properties]))) stmts.append(topy(val)) return ast.Stmt(stmts)
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_AssignStatement(self, node): nodes = map(self.transform_assign, node.Left) expr = self.transform(node.Right) return ast.Assign(nodes, expr)
def visit_For(self, node): name, expr, code, else_part = node.asList() assign = ast.Assign([name], ast.Name("py.loopvalue")) yield "for (var __i in py.iter(%s)) { %s %s } " % ( self(expr), self(assign), self(code))