def helper(self, target, id):
syms = st.gatherSymbols(target)
newtarget = du.genDPatTuple([dha.PatVar(s, dha.P_UNKNOWN) for s in syms])
# Generate wildcard comprehension.
elt = du.genDTuple([dha.Name(s) for s in syms])
enumtarget = dka.copy(target)
st.cleanPatterns(enumtarget)
WildcardFiller().run(enumtarget)
enum = dha.RelEnum(enumtarget, id)
comp = dha.RelSetComp(elt, [enum], [], dka.Symtab())
num = next(wildcard_uid)
repldict = {s: dha.VSymbol(s.name + '_W' + num)
for s in syms}
st.replaceSymbols(comp, repldict)
newid = dha.VSymbol(id.name + '_W' + num)
invdef = dha.InvDef(newid, comp)
### Need a more robust way to do this part.
oldccb = self.code_callback
newccb = \
(lambda ccb: oldccb(ccb) + [invdef]
if ccb is self.CCB_NORMAL or
ccb is self.CCB_LOOP_ENTRY
else [])
return newtarget, newid, newccb
def genDSetBlock(self, enumnum, upvalexpr):
compnode = self.compnode
enumvars = self.info.enumvars
enums = dka.copy(compnode.enums)
conds = dka.copy(compnode.conds)
st.cleanPatterns(enums)
suffix = '_up' + str(enumnum)
wittarget = dka.copy(enums[enumnum].target)
upval = dka.copy(upvalexpr)
upvalassign = dha.Assign(wittarget, upval)
elt = du.genDTuple([s for s in enumvars])
if len(enums) > 1:
maintenums = enums[:enumnum] + enums[enumnum+1:]
maintcomp = dha.RelSetComp(elt, maintenums, conds, dka.Symtab())
maintupdate = dha.SetUpdate(self.diffsym, dha.UpUnionNS(), maintcomp)
else:
maintupdate = dha.SetUpdate(self.diffsym, dha.UpAddNS(), elt)
code = [upvalassign, maintupdate]
repldict = {s: dha.VSymbol(s.name + suffix)
for s in enumvars}
st.replaceSymbols(code, repldict)
return code
def eliminatedecomp(decomp, code):
dka.assertnodetype(decomp, dha.Assign)
bindings = {}
if tuplematcher(decomp.target, decomp.value, bindings):
st.replaceSymbols(code, bindings)
return code
else:
return [decomp] + code
def visit_InvDef(self, node):
dka.assertnodetype(node.value, dha.RelSetComp)
self.generic_visit(node)
compnode = node.value
info = node.id.info
params = info.enumparams
repldict = {sym: dha.VSymbol(sym.name + '_local')
for sym in params}
if len(params) > 0:
paramtup = du.genDTuple([dha.Name(sym) for sym in params])
newelt = dha.Tuple([paramtup, dka.copy(compnode.elt)])
compnode.elt = newelt
else:
pass
st.cleanPatterns(compnode)
st.replaceSymbols(compnode, repldict)
def genTagInfo(comp):
info = comp.info
compnode = comp.getCompNode()
uset = info.uset
if uset is None:
return
enums = compnode.enums
assert(enums[0].iter is uset)
rootsyms = set(st.gatherSymbols(enums[0].target))
unconsparams = info.unconsparams
assert(rootsyms == set(unconsparams))
taginfo = TagInfo()
info.taginfo = taginfo
taginfo.compinfo = info
pairenums = enums[1:]
taginfo.As = As = []
taginfo.Bs = Bs = []
taginfo.Rs = Rs = []
taginfo.DRs = DRs = []
for i, enum in enumerate(pairenums):
dka.assertnodetype(enum.target, dha.PatTuple)
elts = enum.target.elts
assert(len(elts) == 2)
dka.assertnodetype(elts[0], dha.PatVar)
dka.assertnodetype(elts[1], dha.PatVar)
cont, elem = elts[0].id, elts[1].id
rel = enum.iter
As.append(cont)
Bs.append(elem)
Rs.append(rel)
demrel = TagSym('Dm_' + info.compsym.id + '_' + str(i+1))
DRs.append(demrel)
taginfo.tagcomps = tagcomps = []
# Generate auxiliary demand comprehensions.
for i, (a, b, r, dr) in enumerate(zip(As, Bs, Rs, DRs)):
tagenums = []
# Add U pred.
if a in unconsparams:
k = unconsparams.index(a)
ig1 = [dha.PatIgnore() for z in range(0, i)]
ig2 = [dha.PatIgnore() for z in range(i+1, len(unconsparams))]
tup = du.genDPatTuple(ig1 + [dha.genUnboundVar(a)] + ig2)
e = dha.Enum(tup, uset)
tagenums.append(e)
# Add other preds.
for a2, b2, r2, dr2 in list(zip(As, Bs, Rs, DRs))[:i]:
if b2 is a:
tup = dha.PatTuple([dha.PatIgnore(), dha.genUnboundVar(b2)])
e = dha.Enum(tup, dr2)
tagenums.append(e)
# Add orig relation.
assert(len(tagenums) > 0)
tup = dha.PatTuple([dha.genUnboundVar(a), dha.genUnboundVar(b)])
e = dha.Enum(tup, r)
tagenums.append(e)
comp = dha.SetComp(dha.Tuple([dha.Name(a), dha.Name(b)]), tagenums,
None, dka.Symtab())
instmapping = {s: dha.VSymbol(s.name + '_t' + str(i))
for s in set(As) | set(Bs)}
st.replaceSymbols(comp, instmapping)
compdef = dha.SetCompDef(dr, comp)
tagcomps.append(compdef)
return taginfo
