def generateCode(func, trace): compiler = application.context.CompilerContext(None) extractor = Extractor(compiler) compiler.extractor = extractor f = extractor.decompileFunction(func, trace) # f = decompile(func, trace) sio = StringIO() scg = SimpleCodeGen(sio) scg.process(f) return sio.getvalue()
def generateCode(func, trace): compiler = application.context.CompilerContext(None) extractor = Extractor(compiler) compiler.extractor = extractor f = extractor.decompileFunction(func, trace) #f = decompile(func, trace) sio = StringIO() scg = SimpleCodeGen(sio) scg.process(f) return sio.getvalue()
def decompile(compiler, func, trace=False, ssa=True, descriptive=False): # HACK can't find modules for "fake" globals. try: mname, module = moduleForGlobalDict(func.func_globals) except: mname = 'unknown_module' code = decompileCode(compiler, func.func_code, mname, trace=trace, ssa=ssa) # Flow sensitive, works without a ssa or ssi transform. code.rewriteAnnotation(descriptive=descriptive) optimization.simplify.evaluateCode(compiler, None, code) if trace: SimpleCodeGen(sys.stdout).process(code) # HACK turn function defaults into code defaults # Really, we should check for immutability / consistency across all functions using this code if func.func_defaults is not None: defaults = [ ast.Existing(compiler.extractor.getObject(obj)) for obj in func.func_defaults ] else: defaults = [] # HACK mutate the AST node code.codeparameters.defaults = defaults return code
def evaluateCode(compiler, prgm, node, outputAnchors=None): assert node.isCode(), type(node) try: fold.evaluateCode(compiler, prgm, node) # Can't process arbitrary abstract code nodes. if node.isStandardCode(): dce.evaluateCode(compiler, node, outputAnchors) except InternalError: print print "#######################################" print "Function generated an internal error..." print "#######################################" sio = StringIO() scg = SimpleCodeGen(sio) scg.process(node) print sio.getvalue() raise
def runFunction(self, func, trace=False): code = self.decompile(func) if trace: #pprint(code) SimpleCodeGen(None).process(code) g = transform.evaluate(self.compiler, code) ssa.evaluate(self.compiler, g) expandphi.evaluate(self.compiler, g) simplify.evaluate(self.compiler, g) structuralanalysis.evaluate(self.compiler, g) if trace: dump.evaluate(self.compiler, g) if trace: #pprint(code) SimpleCodeGen(None).process(code)
def generateBindingClass(compiler, prgm, shaderprgm, translator): className = "Compiled%s" % shaderprgm.name # TODO original as the actual class object? original = shaderprgm.name uniformSlot = shaderprgm.vscontext.originalParams.params[0] if not uniformSlot.annotation.references: # May be unused in vs. uniformSlot = shaderprgm.fscontext.originalParams.params[0] uniformCode = bindUniforms(compiler, translator, uniformSlot) streamCode = bindStreams(compiler, translator, shaderprgm.vscontext) vsCode = shaderprgm.vscontext.shaderCode fsCode = shaderprgm.fscontext.shaderCode code = symbols.SymbolRewriter(compiler.extractor, classTemplate) cdef = code.rewrite(className=className, original=original, vsCode=vsCode, fsCode=fsCode, bindUniforms=uniformCode, bindStreams=streamCode) cdef = existingtransform.evaluateAST(compiler, cdef) register = symbols.SymbolRewriter(compiler.extractor, registerTemplate) rdef = register.rewrite(className=className) buffer = cStringIO.StringIO() SimpleCodeGen(buffer).process(cdef) SimpleCodeGen(buffer).process(rdef) s = buffer.getvalue() # HACK for imports s = "import pystreamruntime\nimport tests.full.physics\n\n" + s # print # print s # print filesystem.writeData('summaries/shaders', shaderprgm.name, 'py', s) return cdef