maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* Don't use ATmake / ATmatch anymore, nor the ATMatcher class.

Browse source 
Instead we generate data bindings (build and match functions) for
  the constructors specified in `constructors.def'.  In particular
  this removes the conversions between AFuns and strings, and Nix
  expression evaluation now seems 3 to 4 times faster.
This commit is contained in:
Eelco Dolstra 2004-10-26 22:54:26 +00:00
parent eb8284ddaa
commit 5fe9222b36
11 changed files with 410 additions and 304 deletions
Download patch file Download diff file Expand all files Collapse all files

160
src/libexpr/eval.cc
View file

@ -1,15 +1,17 @@
#include "eval.hh"
#include "parser.hh"
#include "constructors.hh"
EvalState::EvalState()
: normalForms(32768, 50)
{
blackHole = ATmake("BlackHole()");
if (!blackHole) throw Error("cannot build black hole");
blackHole = makeBlackHole();
nrEvaluated = nrCached = 0;
initSyms();
addPrimOps();
}
@ -17,24 +19,22 @@ EvalState::EvalState()
void EvalState::addPrimOp(const string & name,
unsigned int arity, PrimOp primOp)
{
primOps.set(name, ATmake("(<int>, <term>)",
arity, ATmakeBlob(0, (void *) primOp)));
primOps.set(name, makePrimOpDef(arity, ATmakeBlob(0, (void *) primOp)));
}
/* Substitute an argument set into the body of a function. */
static Expr substArgs(Expr body, ATermList formals, Expr arg)
{
ATMatcher m;
ATermMap subs;
Expr undefined = ATmake("Undefined");
Expr undefined = makeUndefined();
/* Get the formal arguments. */
for (ATermIterator i(formals); i; ++i) {
Expr name, def;
if (atMatch(m, *i) >> "NoDefFormal" >> name)
if (matchNoDefFormal(*i, name))
subs.set(name, undefined);
else if (atMatch(m, *i) >> "DefFormal" >> name >> def)
else if (matchDefFormal(*i, name, def))
subs.set(name, def);
else abort(); /* can't happen */
}
@ -69,38 +69,32 @@ static Expr substArgs(Expr body, ATermList formals, Expr arg)
(e.x) (e.y); y = e.x;}'. */
ATerm expandRec(ATerm e, ATermList rbnds, ATermList nrbnds)
{
ATMatcher m;
ATerm name;
Expr e2;
Pos pos;
/* Create the substitution list. */
ATermMap subs;
for (ATermIterator i(rbnds); i; ++i) {
if (!(atMatch(m, *i) >> "Bind" >> name >> e2))
abort(); /* can't happen */
subs.set(name, ATmake("Select(<term>, <term>)", e, name));
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
subs.set(name, makeSelect(e, name));
}
for (ATermIterator i(nrbnds); i; ++i) {
if (!(atMatch(m, *i) >> "Bind" >> name >> e2))
abort(); /* can't happen */
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
subs.set(name, e2);
}
/* Create the non-recursive set. */
ATermMap as;
for (ATermIterator i(rbnds); i; ++i) {
ATerm pos;
if (!(atMatch(m, *i) >> "Bind" >> name >> e2 >> pos))
abort(); /* can't happen */
as.set(name, ATmake("(<term>, <term>)", substitute(subs, e2), pos));
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
as.set(name, makeAttrRHS(substitute(subs, e2), pos));
}
/* Copy the non-recursive bindings. !!! inefficient */
for (ATermIterator i(nrbnds); i; ++i) {
ATerm pos;
if (!(atMatch(m, *i) >> "Bind" >> name >> e2 >> pos))
abort(); /* can't happen */
as.set(name, ATmake("(<term>, <term>)", e2, pos));
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
as.set(name, makeAttrRHS(e2, pos));
}
return makeAttrs(as);
@ -122,82 +116,73 @@ static Expr updateAttrs(Expr e1, Expr e2)
string evalString(EvalState & state, Expr e)
{
e = evalExpr(state, e);
ATMatcher m;
string s;
if (!(atMatch(m, e) >> "Str" >> s))
throw Error("string expected");
return s;
ATerm s;
if (!matchStr(e, s)) throw Error("string expected");
return aterm2String(s);
}
Path evalPath(EvalState & state, Expr e)
{
e = evalExpr(state, e);
ATMatcher m;
string s;
if (!(atMatch(m, e) >> "Path" >> s))
throw Error("path expected");
return s;
ATerm s;
if (!matchPath(e, s)) throw Error("path expected");
return aterm2String(s);
}
bool evalBool(EvalState & state, Expr e)
{
e = evalExpr(state, e);
ATMatcher m;
if (atMatch(m, e) >> "Bool" >> "True") return true;
else if (atMatch(m, e) >> "Bool" >> "False") return false;
if (e == eTrue) return true;
else if (e == eFalse) return false;
else throw Error("boolean expected");
}
Expr evalExpr2(EvalState & state, Expr e)
{
ATMatcher m;
Expr e1, e2, e3, e4;
ATerm name, pos;
AFun sym = ATgetAFun(e);
/* Normal forms. */
string cons;
if (atMatch(m, e) >> cons &&
(cons == "Str" ||
cons == "Path" ||
cons == "SubPath" ||
cons == "Uri" ||
cons == "Null" ||
cons == "Int" ||
cons == "Bool" ||
cons == "Function" ||
cons == "Function1" ||
cons == "Attrs" ||
cons == "List" ||
cons == "PrimOp"))
if (sym == symStr ||
sym == symPath ||
sym == symSubPath ||
sym == symUri ||
sym == symNull ||
sym == symInt ||
sym == symBool ||
sym == symFunction ||
sym == symFunction1 ||
sym == symAttrs ||
sym == symList ||
sym == symPrimOp)
return e;
/* The `Closed' constructor is just a way to prevent substitutions
into expressions not containing free variables. */
if (atMatch(m, e) >> "Closed" >> e1)
if (matchClosed(e, e1))
return evalExpr(state, e1);
/* Any encountered variables must be primops (since undefined
variables are detected after parsing). */
if (atMatch(m, e) >> "Var" >> name) {
if (matchVar(e, name)) {
ATerm primOp = state.primOps.get(name);
if (!primOp)
throw Error(format("impossible: undefined variable `%1%'") % name);
int arity;
ATerm fun;
if (!(atMatch(m, primOp) >> "" >> arity >> fun)) abort();
ATermBlob fun;
if (!matchPrimOpDef(primOp, arity, fun)) abort();
if (arity == 0)
return ((PrimOp) ATgetBlobData((ATermBlob) fun))
(state, ATermVector());
return ((PrimOp) ATgetBlobData(fun)) (state, ATermVector());
else
return ATmake("PrimOp(<int>, <term>, <term>)",
arity, fun, ATempty);
return makePrimOp(arity, fun, ATempty);
}
/* Function application. */
if (atMatch(m, e) >> "Call" >> e1 >> e2) {
if (matchCall(e, e1, e2)) {
ATermList formals;
ATerm pos;
@ -207,9 +192,9 @@ Expr evalExpr2(EvalState & state, Expr e)
/* Is it a primop or a function? */
int arity;
ATerm fun;
ATermBlob fun;
ATermList args;
if (atMatch(m, e1) >> "PrimOp" >> arity >> fun >> args) {
if (matchPrimOp(e1, arity, fun, args)) {
args = ATinsert(args, e2);
if (ATgetLength(args) == arity) {
/* Put the arguments in a vector in reverse (i.e.,
@ -221,11 +206,10 @@ Expr evalExpr2(EvalState & state, Expr e)
(state, args2);
} else
/* Need more arguments, so propagate the primop. */
return ATmake("PrimOp(<int>, <term>, <term>)",
arity, fun, args);
return makePrimOp(arity, fun, args);
}
else if (atMatch(m, e1) >> "Function" >> formals >> e4 >> pos) {
else if (matchFunction(e1, formals, e4, pos)) {
e2 = evalExpr(state, e2);
try {
return evalExpr(state, substArgs(e4, formals, e2));
@ -235,7 +219,7 @@ Expr evalExpr2(EvalState & state, Expr e)
}
}
else if (atMatch(m, e1) >> "Function1" >> name >> e4 >> pos) {
else if (matchFunction1(e1, name, e4, pos)) {
try {
ATermMap subs;
subs.set(name, e2);
@ -250,9 +234,9 @@ Expr evalExpr2(EvalState & state, Expr e)
}
/* Attribute selection. */
string s1;
if (atMatch(m, e) >> "Select" >> e1 >> s1) {
if (matchSelect(e, e1, name)) {
ATerm pos;
string s1 = aterm2String(name);
Expr a = queryAttr(evalExpr(state, e1), s1, pos);
if (!a) throw Error(format("attribute `%1%' missing") % s1);
try {
@ -265,11 +249,11 @@ Expr evalExpr2(EvalState & state, Expr e)
/* Mutually recursive sets. */
ATermList rbnds, nrbnds;
if (atMatch(m, e) >> "Rec" >> rbnds >> nrbnds)
if (matchRec(e, rbnds, nrbnds))
return expandRec(e, rbnds, nrbnds);
/* Conditionals. */
if (atMatch(m, e) >> "If" >> e1 >> e2 >> e3) {
if (matchIf(e, e1, e2, e3)) {
if (evalBool(state, e1))
return evalExpr(state, e2);
else
@ -277,14 +261,14 @@ Expr evalExpr2(EvalState & state, Expr e)
}
/* Assertions. */
if (atMatch(m, e) >> "Assert" >> e1 >> e2 >> pos) {
if (matchAssert(e, e1, e2, pos)) {
if (!evalBool(state, e1))
throw Error(format("assertion failed at %1%") % showPos(pos));
return evalExpr(state, e2);
}
/* Withs. */
if (atMatch(m, e) >> "With" >> e1 >> e2 >> pos) {
if (matchWith(e, e1, e2, pos)) {
ATermMap attrs;
try {
e1 = evalExpr(state, e1);
@ -304,51 +288,51 @@ Expr evalExpr2(EvalState & state, Expr e)
}
/* Generic equality. */
if (atMatch(m, e) >> "OpEq" >> e1 >> e2)
if (matchOpEq(e, e1, e2))
return makeBool(evalExpr(state, e1) == evalExpr(state, e2));
/* Generic inequality. */
if (atMatch(m, e) >> "OpNEq" >> e1 >> e2)
if (matchOpNEq(e, e1, e2))
return makeBool(evalExpr(state, e1) != evalExpr(state, e2));
/* Negation. */
if (atMatch(m, e) >> "OpNot" >> e1)
if (matchOpNot(e, e1))
return makeBool(!evalBool(state, e1));
/* Implication. */
if (atMatch(m, e) >> "OpImpl" >> e1 >> e2)
if (matchOpImpl(e, e1, e2))
return makeBool(!evalBool(state, e1) || evalBool(state, e2));
/* Conjunction (logical AND). */
if (atMatch(m, e) >> "OpAnd" >> e1 >> e2)
if (matchOpAnd(e, e1, e2))
return makeBool(evalBool(state, e1) && evalBool(state, e2));
/* Disjunction (logical OR). */
if (atMatch(m, e) >> "OpOr" >> e1 >> e2)
if (matchOpOr(e, e1, e2))
return makeBool(evalBool(state, e1) || evalBool(state, e2));
/* Attribute set update (//). */
if (atMatch(m, e) >> "OpUpdate" >> e1 >> e2)
if (matchOpUpdate(e, e1, e2))
return updateAttrs(evalExpr(state, e1), evalExpr(state, e2));
/* Attribute existence test (?). */
if (atMatch(m, e) >> "OpHasAttr" >> e1 >> name) {
if (matchOpHasAttr(e, e1, name)) {
ATermMap attrs;
queryAllAttrs(evalExpr(state, e1), attrs);
return makeBool(attrs.get(name) != 0);
}
/* String or path concatenation. */
if (atMatch(m, e) >> "OpPlus" >> e1 >> e2) {
if (matchOpPlus(e, e1, e2)) {
e1 = evalExpr(state, e1);
e2 = evalExpr(state, e2);
string s1, s2;
if (atMatch(m, e1) >> "Str" >> s1 &&
atMatch(m, e2) >> "Str" >> s2)
return makeString(s1 + s2);
else if (atMatch(m, e1) >> "Path" >> s1 &&
atMatch(m, e2) >> "Path" >> s2)
return makePath(canonPath(s1 + "/" + s2));
ATerm s1, s2;
if (matchStr(e1, s1) && matchStr(e2, s2))
return makeStr(string2ATerm((
(string) aterm2String(s1) + (string) aterm2String(s2)).c_str()));
else if (matchPath(e1, s1) && matchPath(e2, s2))
return makePath(string2ATerm(canonPath(
(string) aterm2String(s1) + "/" + (string) aterm2String(s2)).c_str()));
else throw Error("wrong argument types in `+' operator");
}