forked from lix-project/lix
140 lines
3.5 KiB
C++
140 lines
3.5 KiB
C++
#include "fix-expr.hh"
|
|
#include "expr.hh"
|
|
|
|
|
|
ATerm bottomupRewrite(TermFun & f, ATerm e)
|
|
{
|
|
e = f(e);
|
|
|
|
if (ATgetType(e) == AT_APPL) {
|
|
AFun fun = ATgetAFun(e);
|
|
int arity = ATgetArity(fun);
|
|
ATermList args = ATempty;
|
|
|
|
for (int i = arity - 1; i >= 0; i--)
|
|
args = ATinsert(args, bottomupRewrite(f, ATgetArgument(e, i)));
|
|
|
|
return (ATerm) ATmakeApplList(fun, args);
|
|
}
|
|
|
|
if (ATgetType(e) == AT_LIST) {
|
|
ATermList in = (ATermList) e;
|
|
ATermList out = ATempty;
|
|
|
|
while (!ATisEmpty(in)) {
|
|
out = ATinsert(out, bottomupRewrite(f, ATgetFirst(in)));
|
|
in = ATgetNext(in);
|
|
}
|
|
|
|
return (ATerm) ATreverse(out);
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
|
|
void queryAllAttrs(Expr e, Attrs & attrs)
|
|
{
|
|
ATermList bnds;
|
|
if (!ATmatch(e, "Attrs([<list>])", &bnds))
|
|
throw badTerm("expected attribute set", e);
|
|
|
|
while (!ATisEmpty(bnds)) {
|
|
char * s;
|
|
Expr e;
|
|
if (!ATmatch(ATgetFirst(bnds), "Bind(<str>, <term>)", &s, &e))
|
|
abort(); /* can't happen */
|
|
attrs[s] = e;
|
|
bnds = ATgetNext(bnds);
|
|
}
|
|
}
|
|
|
|
|
|
Expr queryAttr(Expr e, const string & name)
|
|
{
|
|
Attrs attrs;
|
|
queryAllAttrs(e, attrs);
|
|
Attrs::iterator i = attrs.find(name);
|
|
return i == attrs.end() ? 0 : i->second;
|
|
}
|
|
|
|
|
|
Expr makeAttrs(const Attrs & attrs)
|
|
{
|
|
ATermList bnds = ATempty;
|
|
for (Attrs::const_iterator i = attrs.begin(); i != attrs.end(); i++)
|
|
bnds = ATinsert(bnds,
|
|
ATmake("Bind(<str>, <term>)", i->first.c_str(), i->second));
|
|
return ATmake("Attrs(<term>)", ATreverse(bnds));
|
|
}
|
|
|
|
|
|
ATerm substitute(Subs & subs, ATerm e)
|
|
{
|
|
char * s;
|
|
|
|
if (ATmatch(e, "Var(<str>)", &s)) {
|
|
Subs::iterator i = subs.find(s);
|
|
if (i == subs.end())
|
|
return e;
|
|
else
|
|
return i->second;
|
|
}
|
|
|
|
/* In case of a function, filter out all variables bound by this
|
|
function. */
|
|
ATermList formals;
|
|
ATerm body;
|
|
if (ATmatch(e, "Function([<list>], <term>)", &formals, &body)) {
|
|
Subs subs2(subs);
|
|
ATermList fs = formals;
|
|
while (!ATisEmpty(fs)) {
|
|
if (!ATmatch(ATgetFirst(fs), "<str>", &s)) abort();
|
|
subs2.erase(s);
|
|
fs = ATgetNext(fs);
|
|
}
|
|
return ATmake("Function(<term>, <term>)", formals,
|
|
substitute(subs2, body));
|
|
}
|
|
|
|
/* Idem for a mutually recursive attribute set. */
|
|
ATermList bindings;
|
|
if (ATmatch(e, "Rec([<list>])", &bindings)) {
|
|
Subs subs2(subs);
|
|
ATermList bnds = bindings;
|
|
while (!ATisEmpty(bnds)) {
|
|
Expr e;
|
|
if (!ATmatch(ATgetFirst(bnds), "Bind(<str>, <term>)", &s, &e))
|
|
abort(); /* can't happen */
|
|
subs2.erase(s);
|
|
bnds = ATgetNext(bnds);
|
|
}
|
|
return ATmake("Rec(<term>)", substitute(subs2, (ATerm) bindings));
|
|
}
|
|
|
|
if (ATgetType(e) == AT_APPL) {
|
|
AFun fun = ATgetAFun(e);
|
|
int arity = ATgetArity(fun);
|
|
ATermList args = ATempty;
|
|
|
|
for (int i = arity - 1; i >= 0; i--)
|
|
args = ATinsert(args, substitute(subs, ATgetArgument(e, i)));
|
|
|
|
return (ATerm) ATmakeApplList(fun, args);
|
|
}
|
|
|
|
if (ATgetType(e) == AT_LIST) {
|
|
ATermList in = (ATermList) e;
|
|
ATermList out = ATempty;
|
|
|
|
while (!ATisEmpty(in)) {
|
|
out = ATinsert(out, substitute(subs, ATgetFirst(in)));
|
|
in = ATgetNext(in);
|
|
}
|
|
|
|
return (ATerm) ATreverse(out);
|
|
}
|
|
|
|
return e;
|
|
}
|