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
