""" globalize definition d """
if VarDefinitionP(d): #simple var definition
return d #nothing to do
fun, formals,es, rhs = FunDefinitionD(d)
grhs = Gterm(rhs,formals)
return FunDefinitionC(fun,formals,es,grhs)
def Gterm(t,formals):
""" apply globals to all nonformals in t"""
if LiteralP(t): return t
if VarP(t):
if pop.Occurs(Var(t),formals): return t
return Operation1C(GLOBALWord,t)
if OperationP(t):
o,opds = OperationD(t)
gopds = pop.ConsAll2(opds,Gterm,formals)
return OperationC(o,gopds)
if CallP(t):
fun, actuals = CallD(t)
gactuals = pop.ConsAll2(actuals,Gterm,formals)
return CallC(fun,gactuals)
print('Cannot globalize ')
pio.WriteItemln(t)
exit()
if __name__ == "__main__":
pg = prs.ParseFile("testprog.lu")
gpg = Gprogram(pg)
prp.Term(gpg)
print()
def Compile(f):
""" compile the program in file f to atomic equations """
pio.parsing = True
pg = prs.ParseFile(f)
print('Program is ')
#pio.WriteItemln(pg)
prp.Termln(pg)
print('Defs to import ', prs.defined)
defs = pop.Empty
for w in prs.defined: #read parse and add defs of defined operators like wvr
wname = WordName(w)
f = open("defs/" + wname + ".lu", "r")
sourcedef = f.read()
f.close()
ig = pio.ItemGenStringC(sourcedef)
df = prs.Definition(ig)
#print('Adding df')
#prp.Termln(df);exit()
defs = pop.AddElement(defs, df)
subj, wk, body = exp.WhereD(pg)
body = pop.Append(body, defs) #add imported definitions
pg = exp.WhereC(subj, wk, body)
print('Expanded program')
prp.Termln(pg)
#print("check locals")
pre.CheckLocals(pg)
print("check dups")
pre.CheckDups(pg)
print("check embeddings")
pre.ProgramEmbedded(pg)
print('renamed program ')
rpg = ren.Rename(pg, pop.EmptySet)
prp.Termln(rpg)
m = ari.Aritytab(rpg, map.EmptyMap)
ok, var, arity = ari.ArityCheck(rpg, m)
if ok:
k = 1
print('arities check out ')
else:
prp.printf("Variable ")
pio.WriteItem(var)
prp.printf(" should have arity ")
print(arity)
exit()
lpg = elp.Eloop(rpg, map.EmptyMap)
print('Delooped program ')
prp.Termln(lpg)
fpg = ewh.Eprogram(lpg)
print('flattened program')
pio.WriteItemln(fpg)
prp.Termln(fpg)
atab, ftab, ypg = ali.ActualTable(fpg, map.EmptyMap, map.EmptyMap)
print('alified program')
prp.Termln(ypg)
defs = ali.ActualDefs(atab, ftab)
subj, wk, body = exp.WhereD(ypg)
body = pop.Append(body, defs) #add ali defs
ypg = exp.WhereC(subj, wk, body)
#print('globalized program')
ypg = glb.Gprogram(ypg)
#prp.Termln(ypg)
print('reflattend program')
ypg = ewh.Eprogram(ypg)
prp.Termln(ypg)
print('atomized program')
apg, dfs = atz.Aexpr(ypg)
prp.Termln(apg)
return apg
if VarDefinitionP(t):
v, es, rhs = VarDefinitionD(t)
erhs = Eloop(rhs,am)
return VarDefinitionC(v,es,erhs)
if FunDefinitionP(t):
fun, formals,es,rhs = FunDefinitionD(t)
am1 = Update(am,MapC(Elements(formals),Zero))
erhs = Eloop(rhs,am1)
return FunDefinitionC(fun,formals,es,erhs)
print('Cannot Eloop ',pio.Items(t));exit()
def Activate(v,m):
"""apply appropriate number of actives """
t = v
ok,pn = Apply(m,Var(v))
assert ok, 'unmapped var '+str(v)
if not ok: print( str(v)+" not mapped");exit()
n = NumVal(pn)
for i in range(n):
t = Operation1C(ACTIVEWord,t)
return t
if __name__ == "__main__":
pg = prs.ParseFile("loopprog.lu")
epg = Eloop(pg,EmptyMap)
prp.Termln(epg)