2003-10-30 17:48:26 +01:00
|
|
|
#include "eval.hh"
|
|
|
|
#include "parser.hh"
|
2004-10-29 13:22:49 +02:00
|
|
|
#include "nixexpr-ast.hh"
|
2004-02-04 17:03:29 +01:00
|
|
|
|
|
|
|
|
2003-10-30 17:48:26 +01:00
|
|
|
EvalState::EvalState()
|
2004-02-04 17:03:29 +01:00
|
|
|
: normalForms(32768, 50)
|
2003-10-30 17:48:26 +01:00
|
|
|
{
|
2004-10-27 00:54:26 +02:00
|
|
|
blackHole = makeBlackHole();
|
2004-02-04 17:03:29 +01:00
|
|
|
|
2003-10-31 18:09:31 +01:00
|
|
|
nrEvaluated = nrCached = 0;
|
2004-02-04 17:03:29 +01:00
|
|
|
|
2004-10-29 13:22:49 +02:00
|
|
|
initNixExprHelpers();
|
2004-10-27 00:54:26 +02:00
|
|
|
|
2004-08-04 12:59:20 +02:00
|
|
|
addPrimOps();
|
2004-02-04 17:03:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-04 12:59:20 +02:00
|
|
|
void EvalState::addPrimOp(const string & name,
|
|
|
|
unsigned int arity, PrimOp primOp)
|
2004-02-04 17:03:29 +01:00
|
|
|
{
|
2004-10-27 00:54:26 +02:00
|
|
|
primOps.set(name, makePrimOpDef(arity, ATmakeBlob(0, (void *) primOp)));
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Substitute an argument set into the body of a function. */
|
|
|
|
static Expr substArgs(Expr body, ATermList formals, Expr arg)
|
|
|
|
{
|
2003-11-03 21:30:40 +01:00
|
|
|
ATermMap subs;
|
2004-10-27 00:54:26 +02:00
|
|
|
Expr undefined = makeUndefined();
|
2003-10-31 18:09:31 +01:00
|
|
|
|
|
|
|
/* Get the formal arguments. */
|
2003-11-16 19:31:29 +01:00
|
|
|
for (ATermIterator i(formals); i; ++i) {
|
2003-11-05 16:34:12 +01:00
|
|
|
Expr name, def;
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchNoDefFormal(*i, name))
|
2003-11-05 16:34:12 +01:00
|
|
|
subs.set(name, undefined);
|
2004-10-27 00:54:26 +02:00
|
|
|
else if (matchDefFormal(*i, name, def))
|
2003-11-05 16:34:12 +01:00
|
|
|
subs.set(name, def);
|
|
|
|
else abort(); /* can't happen */
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the actual arguments, and check that they match with the
|
|
|
|
formals. */
|
2003-11-03 21:30:40 +01:00
|
|
|
ATermMap args;
|
2003-10-31 18:09:31 +01:00
|
|
|
queryAllAttrs(arg, args);
|
2003-11-16 19:31:29 +01:00
|
|
|
for (ATermIterator i(args.keys()); i; ++i) {
|
|
|
|
Expr key = *i;
|
2003-11-03 21:30:40 +01:00
|
|
|
Expr cur = subs.get(key);
|
|
|
|
if (!cur)
|
2004-04-06 00:27:41 +02:00
|
|
|
throw Error(format("unexpected function argument `%1%'")
|
|
|
|
% aterm2String(key));
|
2003-11-03 21:30:40 +01:00
|
|
|
subs.set(key, args.get(key));
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check that all arguments are defined. */
|
2003-11-16 19:31:29 +01:00
|
|
|
for (ATermIterator i(subs.keys()); i; ++i)
|
|
|
|
if (subs.get(*i) == undefined)
|
2004-04-06 00:27:41 +02:00
|
|
|
throw Error(format("required function argument `%1%' missing")
|
|
|
|
% aterm2String(*i));
|
2003-10-31 18:09:31 +01:00
|
|
|
|
|
|
|
return substitute(subs, body);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Transform a mutually recursive set into a non-recursive set. Each
|
|
|
|
attribute is transformed into an expression that has all references
|
|
|
|
to attributes substituted with selection expressions on the
|
2004-02-02 22:39:33 +01:00
|
|
|
original set. E.g., e = `rec {x = f x y; y = x;}' becomes `{x = f
|
|
|
|
(e.x) (e.y); y = e.x;}'. */
|
|
|
|
ATerm expandRec(ATerm e, ATermList rbnds, ATermList nrbnds)
|
2003-10-31 18:09:31 +01:00
|
|
|
{
|
2004-02-16 10:18:35 +01:00
|
|
|
ATerm name;
|
|
|
|
Expr e2;
|
2004-10-27 00:54:26 +02:00
|
|
|
Pos pos;
|
2003-11-16 18:46:31 +01:00
|
|
|
|
2003-10-31 18:09:31 +01:00
|
|
|
/* Create the substitution list. */
|
2003-11-03 21:30:40 +01:00
|
|
|
ATermMap subs;
|
2004-02-02 22:39:33 +01:00
|
|
|
for (ATermIterator i(rbnds); i; ++i) {
|
2004-10-27 00:54:26 +02:00
|
|
|
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
|
|
|
|
subs.set(name, makeSelect(e, name));
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
2004-02-16 10:18:35 +01:00
|
|
|
for (ATermIterator i(nrbnds); i; ++i) {
|
2004-10-27 00:54:26 +02:00
|
|
|
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
|
2004-02-16 10:18:35 +01:00
|
|
|
subs.set(name, e2);
|
|
|
|
}
|
2003-10-31 18:09:31 +01:00
|
|
|
|
|
|
|
/* Create the non-recursive set. */
|
2003-11-03 21:30:40 +01:00
|
|
|
ATermMap as;
|
2004-02-02 22:39:33 +01:00
|
|
|
for (ATermIterator i(rbnds); i; ++i) {
|
2004-10-27 00:54:26 +02:00
|
|
|
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
|
|
|
|
as.set(name, makeAttrRHS(substitute(subs, e2), pos));
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
2004-02-02 22:39:33 +01:00
|
|
|
/* Copy the non-recursive bindings. !!! inefficient */
|
|
|
|
for (ATermIterator i(nrbnds); i; ++i) {
|
2004-10-27 00:54:26 +02:00
|
|
|
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
|
|
|
|
as.set(name, makeAttrRHS(e2, pos));
|
2004-02-02 22:39:33 +01:00
|
|
|
}
|
|
|
|
|
2003-10-31 18:09:31 +01:00
|
|
|
return makeAttrs(as);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-02-04 17:49:51 +01:00
|
|
|
static Expr updateAttrs(Expr e1, Expr e2)
|
|
|
|
{
|
|
|
|
/* Note: e1 and e2 should be in normal form. */
|
|
|
|
|
|
|
|
ATermMap attrs;
|
2004-04-06 00:27:41 +02:00
|
|
|
queryAllAttrs(e1, attrs, true);
|
|
|
|
queryAllAttrs(e2, attrs, true);
|
2004-02-04 17:49:51 +01:00
|
|
|
|
|
|
|
return makeAttrs(attrs);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-31 18:09:31 +01:00
|
|
|
string evalString(EvalState & state, Expr e)
|
|
|
|
{
|
|
|
|
e = evalExpr(state, e);
|
2004-10-27 00:54:26 +02:00
|
|
|
ATerm s;
|
|
|
|
if (!matchStr(e, s)) throw Error("string expected");
|
|
|
|
return aterm2String(s);
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Path evalPath(EvalState & state, Expr e)
|
|
|
|
{
|
|
|
|
e = evalExpr(state, e);
|
2004-10-27 00:54:26 +02:00
|
|
|
ATerm s;
|
|
|
|
if (!matchPath(e, s)) throw Error("path expected");
|
|
|
|
return aterm2String(s);
|
2003-10-30 17:48:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-11-01 20:15:08 +01:00
|
|
|
bool evalBool(EvalState & state, Expr e)
|
|
|
|
{
|
|
|
|
e = evalExpr(state, e);
|
2004-10-27 00:54:26 +02:00
|
|
|
if (e == eTrue) return true;
|
|
|
|
else if (e == eFalse) return false;
|
2004-04-06 00:27:41 +02:00
|
|
|
else throw Error("boolean expected");
|
2003-11-01 20:15:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-30 17:48:26 +01:00
|
|
|
Expr evalExpr2(EvalState & state, Expr e)
|
|
|
|
{
|
2003-10-31 18:09:31 +01:00
|
|
|
Expr e1, e2, e3, e4;
|
2004-04-06 00:27:41 +02:00
|
|
|
ATerm name, pos;
|
2004-10-27 00:54:26 +02:00
|
|
|
AFun sym = ATgetAFun(e);
|
2003-10-31 18:09:31 +01:00
|
|
|
|
|
|
|
/* Normal forms. */
|
2004-10-27 00:54:26 +02:00
|
|
|
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)
|
2003-10-31 18:09:31 +01:00
|
|
|
return e;
|
2004-10-27 00:54:26 +02:00
|
|
|
|
* The recent change in nixpkgs of calling `stdenv.mkDerivation'
instead of `derivation' triggered a huge slowdown in the Nix
expression evaluator. Total execution time of `nix-env -qa' went up
by a factor of 60 or so.
This scalability problem was caused by expressions such as
(x: y: ... x ...) a b
where `a' is a large term (say, the one in
`all-packages-generic.nix'). Then the first beta-reduction would
produce
(y: ... a ...) b
by substituting `a' for `x'. The second beta-reduction would then
substitute `b' for `y' into the body `... a ...', which is a large
term due to `a', and thus causes a large traversal to be performed
by substitute() in the second reduction. This is however entirely
redundant, since `a' cannot contain free variables (since we never
substitute below a weak head normal form).
The solution is to wrap substituted terms into a `Closed'
constructor, i.e.,
subst(subs, Var(x)) = Closed(e) iff subs[x] = e
have substitution not descent into closed terms,
subst(subs, Closed(x)) = Closed(x)
and otherwise ignore them for evaluation,
eval(Closed(x)) = eval(x).
* Fix a typo that caused incorrect substitutions to be performed in
simple lambdas, e.g., `(x: x: x) a' would reduce to `(x: a)'.
2004-03-30 17:05:35 +02:00
|
|
|
/* The `Closed' constructor is just a way to prevent substitutions
|
|
|
|
into expressions not containing free variables. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchClosed(e, e1))
|
* The recent change in nixpkgs of calling `stdenv.mkDerivation'
instead of `derivation' triggered a huge slowdown in the Nix
expression evaluator. Total execution time of `nix-env -qa' went up
by a factor of 60 or so.
This scalability problem was caused by expressions such as
(x: y: ... x ...) a b
where `a' is a large term (say, the one in
`all-packages-generic.nix'). Then the first beta-reduction would
produce
(y: ... a ...) b
by substituting `a' for `x'. The second beta-reduction would then
substitute `b' for `y' into the body `... a ...', which is a large
term due to `a', and thus causes a large traversal to be performed
by substitute() in the second reduction. This is however entirely
redundant, since `a' cannot contain free variables (since we never
substitute below a weak head normal form).
The solution is to wrap substituted terms into a `Closed'
constructor, i.e.,
subst(subs, Var(x)) = Closed(e) iff subs[x] = e
have substitution not descent into closed terms,
subst(subs, Closed(x)) = Closed(x)
and otherwise ignore them for evaluation,
eval(Closed(x)) = eval(x).
* Fix a typo that caused incorrect substitutions to be performed in
simple lambdas, e.g., `(x: x: x) a' would reduce to `(x: a)'.
2004-03-30 17:05:35 +02:00
|
|
|
return evalExpr(state, e1);
|
|
|
|
|
2004-08-04 12:59:20 +02:00
|
|
|
/* Any encountered variables must be primops (since undefined
|
|
|
|
variables are detected after parsing). */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchVar(e, name)) {
|
2004-08-04 12:59:20 +02:00
|
|
|
ATerm primOp = state.primOps.get(name);
|
|
|
|
if (!primOp)
|
|
|
|
throw Error(format("impossible: undefined variable `%1%'") % name);
|
|
|
|
int arity;
|
2004-10-27 00:54:26 +02:00
|
|
|
ATermBlob fun;
|
|
|
|
if (!matchPrimOpDef(primOp, arity, fun)) abort();
|
2004-08-04 12:59:20 +02:00
|
|
|
if (arity == 0)
|
2004-10-27 00:54:26 +02:00
|
|
|
return ((PrimOp) ATgetBlobData(fun)) (state, ATermVector());
|
2004-02-04 17:03:29 +01:00
|
|
|
else
|
2004-10-27 00:54:26 +02:00
|
|
|
return makePrimOp(arity, fun, ATempty);
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Function application. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchCall(e, e1, e2)) {
|
2003-11-16 18:46:31 +01:00
|
|
|
|
|
|
|
ATermList formals;
|
2004-04-06 00:27:41 +02:00
|
|
|
ATerm pos;
|
2003-10-31 18:09:31 +01:00
|
|
|
|
|
|
|
/* Evaluate the left-hand side. */
|
|
|
|
e1 = evalExpr(state, e1);
|
|
|
|
|
|
|
|
/* Is it a primop or a function? */
|
2004-08-04 12:59:20 +02:00
|
|
|
int arity;
|
2004-10-27 00:54:26 +02:00
|
|
|
ATermBlob fun;
|
2004-08-04 12:59:20 +02:00
|
|
|
ATermList args;
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchPrimOp(e1, arity, fun, args)) {
|
2004-08-04 12:59:20 +02:00
|
|
|
args = ATinsert(args, e2);
|
|
|
|
if (ATgetLength(args) == arity) {
|
|
|
|
/* Put the arguments in a vector in reverse (i.e.,
|
|
|
|
actual) order. */
|
|
|
|
ATermVector args2(arity);
|
|
|
|
for (ATermIterator i(args); i; ++i)
|
|
|
|
args2[--arity] = *i;
|
|
|
|
return ((PrimOp) ATgetBlobData((ATermBlob) fun))
|
|
|
|
(state, args2);
|
|
|
|
} else
|
|
|
|
/* Need more arguments, so propagate the primop. */
|
2004-10-27 00:54:26 +02:00
|
|
|
return makePrimOp(arity, fun, args);
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
2004-10-27 00:54:26 +02:00
|
|
|
else if (matchFunction(e1, formals, e4, pos)) {
|
2004-04-06 00:27:41 +02:00
|
|
|
e2 = evalExpr(state, e2);
|
|
|
|
try {
|
|
|
|
return evalExpr(state, substArgs(e4, formals, e2));
|
|
|
|
} catch (Error & e) {
|
2004-10-25 18:54:56 +02:00
|
|
|
throw Error(format("while evaluating the function at %1%:\n%2%")
|
2004-04-06 00:27:41 +02:00
|
|
|
% showPos(pos) % e.msg());
|
|
|
|
}
|
|
|
|
}
|
2003-10-31 18:09:31 +01:00
|
|
|
|
2004-10-27 00:54:26 +02:00
|
|
|
else if (matchFunction1(e1, name, e4, pos)) {
|
2004-04-06 00:27:41 +02:00
|
|
|
try {
|
|
|
|
ATermMap subs;
|
|
|
|
subs.set(name, e2);
|
|
|
|
return evalExpr(state, substitute(subs, e4));
|
|
|
|
} catch (Error & e) {
|
2004-10-25 18:54:56 +02:00
|
|
|
throw Error(format("while evaluating the function at %1%:\n%2%")
|
2004-04-06 00:27:41 +02:00
|
|
|
% showPos(pos) % e.msg());
|
|
|
|
}
|
2004-03-28 22:34:22 +02:00
|
|
|
}
|
|
|
|
|
2004-04-06 00:27:41 +02:00
|
|
|
else throw Error("function or primop expected in function call");
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Attribute selection. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchSelect(e, e1, name)) {
|
2004-04-06 00:27:41 +02:00
|
|
|
ATerm pos;
|
2004-10-27 00:54:26 +02:00
|
|
|
string s1 = aterm2String(name);
|
2004-04-06 00:27:41 +02:00
|
|
|
Expr a = queryAttr(evalExpr(state, e1), s1, pos);
|
|
|
|
if (!a) throw Error(format("attribute `%1%' missing") % s1);
|
|
|
|
try {
|
|
|
|
return evalExpr(state, a);
|
|
|
|
} catch (Error & e) {
|
2004-10-25 18:54:56 +02:00
|
|
|
throw Error(format("while evaluating the attribute `%1%' at %2%:\n%3%")
|
2004-04-06 00:27:41 +02:00
|
|
|
% s1 % showPos(pos) % e.msg());
|
|
|
|
}
|
2003-10-31 18:09:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Mutually recursive sets. */
|
2004-02-02 22:39:33 +01:00
|
|
|
ATermList rbnds, nrbnds;
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchRec(e, rbnds, nrbnds))
|
2004-02-02 22:39:33 +01:00
|
|
|
return expandRec(e, rbnds, nrbnds);
|
2003-11-01 20:10:41 +01:00
|
|
|
|
2003-11-01 20:15:08 +01:00
|
|
|
/* Conditionals. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchIf(e, e1, e2, e3)) {
|
2003-11-01 20:15:08 +01:00
|
|
|
if (evalBool(state, e1))
|
|
|
|
return evalExpr(state, e2);
|
|
|
|
else
|
|
|
|
return evalExpr(state, e3);
|
|
|
|
}
|
|
|
|
|
2003-11-05 17:27:40 +01:00
|
|
|
/* Assertions. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchAssert(e, e1, e2, pos)) {
|
2004-04-06 00:27:41 +02:00
|
|
|
if (!evalBool(state, e1))
|
|
|
|
throw Error(format("assertion failed at %1%") % showPos(pos));
|
2003-11-05 17:27:40 +01:00
|
|
|
return evalExpr(state, e2);
|
2003-11-01 20:15:08 +01:00
|
|
|
}
|
|
|
|
|
2004-10-25 18:54:56 +02:00
|
|
|
/* Withs. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchWith(e, e1, e2, pos)) {
|
2004-10-25 18:54:56 +02:00
|
|
|
ATermMap attrs;
|
|
|
|
try {
|
|
|
|
e1 = evalExpr(state, e1);
|
|
|
|
queryAllAttrs(e1, attrs);
|
|
|
|
} catch (Error & e) {
|
|
|
|
throw Error(format("while evaluating the `with' definitions at %1%:\n%2%")
|
|
|
|
% showPos(pos) % e.msg());
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
e2 = substitute(attrs, e2);
|
|
|
|
checkVarDefs(state.primOps, e2);
|
|
|
|
return evalExpr(state, e2);
|
|
|
|
} catch (Error & e) {
|
|
|
|
throw Error(format("while evaluating the `with' body at %1%:\n%2%")
|
|
|
|
% showPos(pos) % e.msg());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-05 17:27:40 +01:00
|
|
|
/* Generic equality. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpEq(e, e1, e2))
|
2003-11-05 17:27:40 +01:00
|
|
|
return makeBool(evalExpr(state, e1) == evalExpr(state, e2));
|
|
|
|
|
|
|
|
/* Generic inequality. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpNEq(e, e1, e2))
|
2003-11-05 17:27:40 +01:00
|
|
|
return makeBool(evalExpr(state, e1) != evalExpr(state, e2));
|
|
|
|
|
|
|
|
/* Negation. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpNot(e, e1))
|
2003-11-05 17:27:40 +01:00
|
|
|
return makeBool(!evalBool(state, e1));
|
|
|
|
|
|
|
|
/* Implication. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpImpl(e, e1, e2))
|
2003-11-05 17:27:40 +01:00
|
|
|
return makeBool(!evalBool(state, e1) || evalBool(state, e2));
|
|
|
|
|
|
|
|
/* Conjunction (logical AND). */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpAnd(e, e1, e2))
|
2003-11-05 17:27:40 +01:00
|
|
|
return makeBool(evalBool(state, e1) && evalBool(state, e2));
|
|
|
|
|
|
|
|
/* Disjunction (logical OR). */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpOr(e, e1, e2))
|
2003-11-05 17:27:40 +01:00
|
|
|
return makeBool(evalBool(state, e1) || evalBool(state, e2));
|
|
|
|
|
2004-03-28 23:15:01 +02:00
|
|
|
/* Attribute set update (//). */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpUpdate(e, e1, e2))
|
2004-02-04 17:49:51 +01:00
|
|
|
return updateAttrs(evalExpr(state, e1), evalExpr(state, e2));
|
|
|
|
|
2004-03-28 23:15:01 +02:00
|
|
|
/* Attribute existence test (?). */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpHasAttr(e, e1, name)) {
|
2004-03-28 23:15:01 +02:00
|
|
|
ATermMap attrs;
|
|
|
|
queryAllAttrs(evalExpr(state, e1), attrs);
|
|
|
|
return makeBool(attrs.get(name) != 0);
|
|
|
|
}
|
|
|
|
|
2004-10-26 19:01:35 +02:00
|
|
|
/* String or path concatenation. */
|
2004-10-27 00:54:26 +02:00
|
|
|
if (matchOpPlus(e, e1, e2)) {
|
2004-10-26 19:01:35 +02:00
|
|
|
e1 = evalExpr(state, e1);
|
|
|
|
e2 = evalExpr(state, e2);
|
2004-10-27 00:54:26 +02:00
|
|
|
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()));
|
2004-10-26 19:01:35 +02:00
|
|
|
else throw Error("wrong argument types in `+' operator");
|
|
|
|
}
|
|
|
|
|
2003-10-31 18:09:31 +01:00
|
|
|
/* Barf. */
|
|
|
|
throw badTerm("invalid expression", e);
|
2003-10-30 17:48:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Expr evalExpr(EvalState & state, Expr e)
|
|
|
|
{
|
2004-01-15 21:23:55 +01:00
|
|
|
checkInterrupt();
|
|
|
|
|
2003-11-09 11:35:45 +01:00
|
|
|
startNest(nest, lvlVomit,
|
2003-11-16 18:46:31 +01:00
|
|
|
format("evaluating expression: %1%") % e);
|
2003-10-30 17:48:26 +01:00
|
|
|
|
2003-10-31 18:09:31 +01:00
|
|
|
state.nrEvaluated++;
|
|
|
|
|
2003-10-30 17:48:26 +01:00
|
|
|
/* Consult the memo table to quickly get the normal form of
|
|
|
|
previously evaluated expressions. */
|
2003-11-03 21:30:40 +01:00
|
|
|
Expr nf = state.normalForms.get(e);
|
|
|
|
if (nf) {
|
|
|
|
if (nf == state.blackHole)
|
2004-04-06 00:27:41 +02:00
|
|
|
throw Error("infinite recursion encountered");
|
2003-10-31 18:09:31 +01:00
|
|
|
state.nrCached++;
|
2003-11-03 21:30:40 +01:00
|
|
|
return nf;
|
2003-10-30 17:48:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, evaluate and memoize. */
|
2003-11-03 21:30:40 +01:00
|
|
|
state.normalForms.set(e, state.blackHole);
|
|
|
|
nf = evalExpr2(state, e);
|
|
|
|
state.normalForms.set(e, nf);
|
2003-10-30 17:48:26 +01:00
|
|
|
return nf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Expr evalFile(EvalState & state, const Path & path)
|
|
|
|
{
|
2003-11-09 11:35:45 +01:00
|
|
|
startNest(nest, lvlTalkative, format("evaluating file `%1%'") % path);
|
2004-02-04 17:03:29 +01:00
|
|
|
Expr e = parseExprFromFile(state, path);
|
2004-04-06 00:27:41 +02:00
|
|
|
try {
|
|
|
|
return evalExpr(state, e);
|
|
|
|
} catch (Error & e) {
|
2004-10-25 18:54:56 +02:00
|
|
|
throw Error(format("while evaluating the file `%1%':\n%2%")
|
2004-04-06 00:27:41 +02:00
|
|
|
% path % e.msg());
|
|
|
|
}
|
2003-10-30 17:48:26 +01:00
|
|
|
}
|
2003-10-31 18:09:31 +01:00
|
|
|
|
|
|
|
|
|
|
|
void printEvalStats(EvalState & state)
|
|
|
|
{
|
|
|
|
debug(format("evaluated %1% expressions, %2% cache hits, %3%%% efficiency")
|
|
|
|
% state.nrEvaluated % state.nrCached
|
|
|
|
% ((float) state.nrCached / (float) state.nrEvaluated * 100));
|
|
|
|
}
|