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
