def process(self, node, vparamLen): # TODO rewrite local references. p = node.codeparameters self.code = node self.vparam = p.vparam self.newParams = [ast.Local(None) for i in range(vparamLen)] self.newNames = [None for i in range(vparamLen)] if vparamLen > 0: # Defaults are never used defaults = () else: # Number of arguments unchanged, defaults may be used, do nothing defaults = p.defaults for i, lcl in enumerate(self.newParams): field = self.storeGraph.canonical.fieldName('Array', self.storeGraph.extractor.getObject(i)) self.transferReferences(self.vparam, field, lcl) selfparam = p.selfparam parameters = self.extend(p.params, self.newParams) parameternames = self.extend(p.paramnames, self.newNames) vparam = None kparam = p.kparam returnparams = p.returnparams node.codeparameters = ast.CodeParameters(selfparam, parameters, parameternames, defaults, vparam, kparam, returnparams) node.ast = self(node.ast)
def __init__(self, compiler, graph, opPathLength, clone): self.decompileTime = 0 self.console = compiler.console self.extractor = compiler.extractor self.clone = clone # Should we copy the code before annotating it? # Has the context been constructed? self.liveContexts = set() self.liveCode = set() # Constraint information, for debugging self.constraints = [] # The worklist self.dirty = collections.deque() self.canonical = graph.canonical self._canonicalContext = util.canonical.CanonicalCache( base.AnalysisContext) # Controls how many previous ops are remembered by a context. # TODO remember prior CPA signatures? self.opPathLength = opPathLength self.cache = {} # Information for contextual operations. self.opAllocates = collections.defaultdict(set) self.opReads = collections.defaultdict(set) self.opModifies = collections.defaultdict(set) self.opInvokes = collections.defaultdict(set) self.codeContexts = collections.defaultdict(set) self.storeGraph = graph # Setup the "external" context, used for creaing bogus slots. self.externalOp = util.canonical.Sentinel('<externalOp>') self.externalFunction = ast.Code( 'external', ast.CodeParameters(None, [], [], [], None, None, [ast.Local('internal_return')]), ast.Suite([])) externalSignature = self._signature(self.externalFunction, None, ()) opPath = self.initialOpPath() self.externalFunctionContext = self._canonicalContext( externalSignature, opPath, self.storeGraph) self.codeContexts[self.externalFunction].add( self.externalFunctionContext) # For vargs self.tupleClass = self.extractor.getObject(tuple) self.ensureLoaded(self.tupleClass) # For kargs self.dictionaryClass = self.extractor.getObject(dict) self.ensureLoaded(self.dictionaryClass) self.entryPointOp = {}
def setNumReturns(self, num): if self.numReturns is None: self.numReturns = num p = self.code.codeparameters if num != len(p.returnparams): returnparams = [ast.Local('internal_return_%d' % i) for i in range(num)] self.code.codeparameters = ast.CodeParameters(p.selfparam, p.params, p.paramnames, p.defaults, p.vparam, p.kparam, returnparams) else: assert num == self.numReturns
def processParameters(self, code): params = code.codeparameters for param in params.params[2:]: if isinstance(param, ast.Local): ioname = ast.IOName(None) self.header.append(ast.Input(ioname, param)) self.fields[param] = ioname code.codeparameters = ast.CodeParameters(params.selfparam, params.params[:2], params.paramnames[:2], [], params.vparam, params.kparam, params.returnparams)
def visitCodeParameters(self, node): # Insert don't care for unused parameters. # selfparam is a special case, it's OK if it disappears in descriptive stubs. selfparam = self.filterParam(node.selfparam) if self.descriptive(): params = node.params vparam = node.vparam kparam = node.kparam else: params = [self.filterParam(p) for p in node.params] vparam = self.filterParam(node.vparam) kparam = self.filterParam(node.kparam) return ast.CodeParameters(selfparam, params, node.paramnames, node.defaults, vparam, kparam, node.returnparams)
def visitCFGEntry(self, node): frame = {} cparam = self.g.code.codeparameters # Set the parameters selfparam = self.clone(cparam.selfparam, frame) params = [self.clone(p, frame) for p in cparam.params] vparam = self.clone(cparam.vparam, frame) kparam = self.clone(cparam.kparam, frame) # Construct the parameters self.g.code.codeparameters = ast.CodeParameters( selfparam, params, cparam.paramnames, cparam.defaults, vparam, kparam, cparam.returnparams) self.currentFrame = frame self.frames[node] = frame
target = ast.Local('bogus') # Load the field assign = get.rewrite(cls=cls, attr=attr, root=root, target=target) statements.append(assign) # Recurse statements.extend(serializeUniformNode(compiler, translator, self, field, field, target)) return statements uniformCodeTemplate = ast.Code( '_bindUniforms', ast.CodeParameters( None, symbols.Symbol('args'), ['self', 'shader'], [], None, None, []), symbols.Symbol('body') ) def bindUniforms(compiler, translator, uniformSlot): code = symbols.SymbolRewriter(compiler.extractor, uniformCodeTemplate) self = ast.Local('self') shader = ast.Local('shader') if uniformSlot.annotation.references: uniformRefs = uniformSlot.annotation.references.merged body = ast.Suite(serializeUniformNode(compiler, translator, self, uniformSlot, uniformRefs, shader)) else: # No uniforms are used.
def noself(code): p = code.codeparameters code.codeparameters = ast.CodeParameters(None, p.params, p.paramnames, p.defaults, p.vparam, p.kparam, p.returnparams) return code