tvl-depot/src/libexpr/eval-test.cc

619 lines
16 KiB
C++
Raw Normal View History

#include "nixexpr.hh"
#include "parser.hh"
#include "hash.hh"
#include "util.hh"
#include "nixexpr-ast.hh"
#include <cstdlib>
using namespace nix;
2010-03-24 13:41:08 +01:00
struct Env;
struct Value;
typedef ATerm Sym;
typedef std::map<Sym, Value> Bindings;
2010-03-24 13:41:08 +01:00
struct Env
{
2010-03-24 13:41:08 +01:00
Env * up;
Bindings bindings;
};
typedef enum {
tInt = 1,
tBool,
tAttrs,
2010-03-25 16:38:37 +01:00
tList,
2010-03-24 12:06:05 +01:00
tThunk,
tLambda,
2010-03-25 13:51:14 +01:00
tCopy,
2010-03-26 16:45:53 +01:00
tBlackhole,
tPrimOp,
tPrimOpApp,
} ValueType;
2010-03-26 16:45:53 +01:00
typedef void (* PrimOp_) (Value * * args, Value & v);
2010-03-24 13:41:08 +01:00
struct Value
{
ValueType type;
union
{
int integer;
bool boolean;
Bindings * attrs;
2010-03-25 16:38:37 +01:00
struct {
unsigned int length;
Value * elems;
} list;
struct {
2010-03-24 13:41:08 +01:00
Env * env;
Expr expr;
} thunk;
2010-03-24 12:06:05 +01:00
struct {
2010-03-24 13:41:08 +01:00
Env * env;
2010-03-24 12:06:05 +01:00
Pattern pat;
Expr body;
} lambda;
Value * val;
2010-03-26 16:45:53 +01:00
struct {
PrimOp_ fun;
unsigned int arity;
} primOp;
struct {
Value * left, * right;
unsigned int argsLeft;
} primOpApp;
};
};
2010-03-24 13:41:08 +01:00
std::ostream & operator << (std::ostream & str, Value & v)
{
switch (v.type) {
case tInt:
str << v.integer;
break;
case tBool:
str << (v.boolean ? "true" : "false");
break;
case tAttrs:
str << "{ ";
2010-03-24 13:41:08 +01:00
foreach (Bindings::iterator, i, *v.attrs)
2010-03-25 16:38:37 +01:00
str << aterm2String(i->first) << " = " << i->second << "; ";
str << "}";
break;
2010-03-25 16:38:37 +01:00
case tList:
str << "[ ";
for (unsigned int n = 0; n < v.list.length; ++n)
str << v.list.elems[n] << " ";
str << "]";
break;
case tThunk:
str << "<CODE>";
break;
case tLambda:
str << "<LAMBDA>";
break;
2010-03-26 16:45:53 +01:00
case tPrimOp:
str << "<PRIMOP>";
break;
case tPrimOpApp:
str << "<PRIMOP-APP>";
break;
default:
abort();
}
return str;
}
2010-03-26 16:45:53 +01:00
static void eval(Env & env, Expr e, Value & v);
static void forceValue(Value & v)
{
2010-03-25 13:51:14 +01:00
if (v.type == tThunk) {
v.type = tBlackhole;
2010-03-26 16:45:53 +01:00
eval(*v.thunk.env, v.thunk.expr, v);
2010-03-25 13:51:14 +01:00
}
else if (v.type == tCopy) {
forceValue(*v.val);
v = *v.val;
}
2010-03-25 13:51:14 +01:00
else if (v.type == tBlackhole)
throw EvalError("infinite recursion encountered");
}
static Value * lookupWith(Env * env, Sym name)
{
if (!env) return 0;
Value * v = lookupWith(env->up, name);
if (v) return v;
Bindings::iterator i = env->bindings.find(sWith);
if (i == env->bindings.end()) return 0;
Bindings::iterator j = i->second.attrs->find(name);
if (j != i->second.attrs->end()) return &j->second;
return 0;
}
static Value * lookupVar(Env * env, Sym name)
{
/* First look for a regular variable binding for `name'. */
for (Env * env2 = env; env2; env2 = env2->up) {
Bindings::iterator i = env2->bindings.find(name);
if (i != env2->bindings.end()) return &i->second;
}
/* Otherwise, look for a `with' attribute set containing `name'.
Outer `withs' take precedence (i.e. `with {x=1;}; with {x=2;};
x' evaluates to 1). */
Value * v = lookupWith(env, name);
if (v) return v;
/* Alternative implementation where the inner `withs' take
precedence (i.e. `with {x=1;}; with {x=2;}; x' evaluates to
2). */
#if 0
for (Env * env2 = env; env2; env2 = env2->up) {
Bindings::iterator i = env2->bindings.find(sWith);
if (i == env2->bindings.end()) continue;
Bindings::iterator j = i->second.attrs->find(name);
if (j != i->second.attrs->end()) return &j->second;
}
#endif
throw Error("undefined variable");
}
static void setBoolValue(Value & v, bool b)
{
v.type = tBool;
v.boolean = b;
}
static bool eqValues(Value & v1, Value & v2)
{
forceValue(v1);
forceValue(v2);
switch (v1.type) {
case tInt:
return v2.type == tInt && v1.integer == v2.integer;
case tBool:
return v2.type == tBool && v1.boolean == v2.boolean;
case tList:
if (v2.type != tList || v1.list.length != v2.list.length) return false;
for (unsigned int n = 0; n < v1.list.length; ++n)
if (!eqValues(v1.list.elems[n], v2.list.elems[n])) return false;
return true;
case tAttrs: {
if (v2.type != tAttrs || v1.attrs->size() != v2.attrs->size()) return false;
Bindings::iterator i, j;
for (i = v1.attrs->begin(), j = v2.attrs->begin(); i != v1.attrs->end(); ++i, ++j)
if (!eqValues(i->second, j->second)) return false;
return true;
}
default:
throw Error("cannot compare given values");
}
}
2010-03-25 16:38:37 +01:00
unsigned long nrValues = 0, nrEnvs = 0;
2010-03-24 13:41:08 +01:00
2010-03-28 18:37:39 +02:00
static Value * allocValues(unsigned int count)
{
nrValues += count;
return new Value[count];// !!! check destructor
}
static Env * allocEnv()
{
2010-03-24 13:41:08 +01:00
nrEnvs++;
return new Env;
}
2010-03-25 17:35:24 +01:00
char * p1 = 0, * p2 = 0;
2010-03-26 16:45:53 +01:00
static void eval(Env & env, Expr e, Value & v)
{
2010-03-25 17:35:24 +01:00
char c;
if (!p1) p1 = &c; else if (!p2) p2 = &c;
printMsg(lvlError, format("eval: %1%") % e);
Sym name;
if (matchVar(e, name)) {
2010-03-26 16:45:53 +01:00
Value * v2 = lookupVar(&env, name);
2010-03-24 13:41:08 +01:00
forceValue(*v2);
v = *v2;
return;
}
int n;
if (matchInt(e, n)) {
2010-03-24 13:41:08 +01:00
v.type = tInt;
v.integer = n;
return;
}
ATermList es;
if (matchAttrs(e, es)) {
2010-03-24 13:41:08 +01:00
v.type = tAttrs;
v.attrs = new Bindings;
ATerm e2, pos;
for (ATermIterator i(es); i; ++i) {
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
Value & v2 = (*v.attrs)[name];
2010-03-24 13:41:08 +01:00
nrValues++;
v2.type = tThunk;
2010-03-26 16:45:53 +01:00
v2.thunk.env = &env;
2010-03-24 13:41:08 +01:00
v2.thunk.expr = e2;
}
return;
}
ATermList rbnds, nrbnds;
if (matchRec(e, rbnds, nrbnds)) {
2010-03-24 13:41:08 +01:00
Env * env2 = allocEnv();
2010-03-26 16:45:53 +01:00
env2->up = &env;
2010-03-24 13:41:08 +01:00
v.type = tAttrs;
v.attrs = &env2->bindings;
ATerm name, e2, pos;
for (ATermIterator i(rbnds); i; ++i) {
if (!matchBind(*i, name, e2, pos)) abort(); /* can't happen */
Value & v2 = env2->bindings[name];
2010-03-24 13:41:08 +01:00
nrValues++;
v2.type = tThunk;
v2.thunk.env = env2;
v2.thunk.expr = e2;
}
return;
}
2010-03-25 16:38:37 +01:00
Expr e1, e2;
if (matchSelect(e, e2, name)) {
eval(env, e2, v);
2010-03-24 13:41:08 +01:00
if (v.type != tAttrs) throw TypeError("expected attribute set");
Bindings::iterator i = v.attrs->find(name);
2010-03-24 13:41:08 +01:00
if (i == v.attrs->end()) throw TypeError("attribute not found");
forceValue(i->second);
v = i->second;
return;
}
2010-03-24 12:06:05 +01:00
Pattern pat; Expr body; Pos pos;
if (matchFunction(e, pat, body, pos)) {
2010-03-24 13:41:08 +01:00
v.type = tLambda;
2010-03-26 16:45:53 +01:00
v.lambda.env = &env;
2010-03-24 13:41:08 +01:00
v.lambda.pat = pat;
v.lambda.body = body;
return;
2010-03-24 12:06:05 +01:00
}
Expr fun, arg;
if (matchCall(e, fun, arg)) {
eval(env, fun, v);
2010-03-26 16:45:53 +01:00
if (v.type == tPrimOp || v.type == tPrimOpApp) {
2010-03-28 18:37:39 +02:00
unsigned int argsLeft =
v.type == tPrimOp ? v.primOp.arity : v.primOpApp.argsLeft;
if (argsLeft == 1) {
2010-03-26 16:45:53 +01:00
/* We have all the arguments, so call the primop.
First find the primop. */
Value * primOp = &v;
while (primOp->type == tPrimOpApp) primOp = primOp->primOpApp.left;
assert(primOp->type == tPrimOp);
unsigned int arity = primOp->primOp.arity;
Value vLastArg;
vLastArg.type = tThunk;
vLastArg.thunk.env = &env;
vLastArg.thunk.expr = arg;
2010-03-28 18:37:39 +02:00
/* Put all the arguments in an array. */
2010-03-26 16:45:53 +01:00
Value * vArgs[arity];
unsigned int n = arity - 1;
vArgs[n--] = &vLastArg;
for (Value * arg = &v; arg->type == tPrimOpApp; arg = arg->primOpApp.left)
vArgs[n--] = arg->primOpApp.right;
2010-03-28 18:37:39 +02:00
/* And call the primop. */
2010-03-26 16:45:53 +01:00
primOp->primOp.fun(vArgs, v);
} else {
2010-03-28 18:37:39 +02:00
Value * v2 = allocValues(2);
v2[0] = v;
v2[1].type = tThunk;
v2[1].thunk.env = &env;
v2[1].thunk.expr = arg;
v.type = tPrimOpApp;
v.primOpApp.left = &v2[0];
v.primOpApp.right = &v2[1];
v.primOpApp.argsLeft = argsLeft - 1;
2010-03-26 16:45:53 +01:00
}
return;
}
2010-03-24 13:41:08 +01:00
if (v.type != tLambda) throw TypeError("expected function");
2010-03-24 12:06:05 +01:00
2010-03-24 13:41:08 +01:00
Env * env2 = allocEnv();
2010-03-26 16:45:53 +01:00
env2->up = &env;
2010-03-24 12:06:05 +01:00
ATermList formals; ATerm ellipsis;
if (matchVarPat(v.lambda.pat, name)) {
Value & vArg = env2->bindings[name];
2010-03-28 18:37:39 +02:00
nrValues++;
vArg.type = tThunk;
2010-03-26 16:45:53 +01:00
vArg.thunk.env = &env;
vArg.thunk.expr = arg;
}
else if (matchAttrsPat(v.lambda.pat, formals, ellipsis, name)) {
Value * vArg;
Value vArg_;
if (name == sNoAlias)
vArg = &vArg_;
2010-03-28 18:37:39 +02:00
else {
vArg = &env2->bindings[name];
2010-03-28 18:37:39 +02:00
nrValues++;
}
eval(env, arg, *vArg);
if (vArg->type != tAttrs) throw TypeError("expected attribute set");
/* For each formal argument, get the actual argument. If
there is no matching actual argument but the formal
argument has a default, use the default. */
unsigned int attrsUsed = 0;
for (ATermIterator i(formals); i; ++i) {
Expr def; Sym name;
DefaultValue def2;
if (!matchFormal(*i, name, def2)) abort(); /* can't happen */
Bindings::iterator j = vArg->attrs->find(name);
Value & v = env2->bindings[name];
2010-03-28 18:37:39 +02:00
nrValues++;
if (j == vArg->attrs->end()) {
if (!matchDefaultValue(def2, def)) def = 0;
if (def == 0) throw TypeError(format("the argument named `%1%' required by the function is missing")
% aterm2String(name));
v.type = tThunk;
v.thunk.env = env2;
v.thunk.expr = def;
} else {
attrsUsed++;
v.type = tCopy;
v.val = &j->second;
}
}
/* Check that each actual argument is listed as a formal
argument (unless the attribute match specifies a
`...'). TODO: show the names of the
expected/unexpected arguments. */
if (ellipsis == eFalse && attrsUsed != vArg->attrs->size())
throw TypeError("function called with unexpected argument");
}
else abort();
2010-03-26 16:45:53 +01:00
eval(*env2, v.lambda.body, v);
return;
2010-03-24 12:06:05 +01:00
}
Expr attrs;
if (matchWith(e, attrs, body, pos)) {
Env * env2 = allocEnv();
2010-03-26 16:45:53 +01:00
env2->up = &env;
Value & vAttrs = env2->bindings[sWith];
2010-03-28 18:37:39 +02:00
nrValues++;
eval(env, attrs, vAttrs);
if (vAttrs.type != tAttrs) throw TypeError("`with' should evaluate to an attribute set");
2010-03-26 16:45:53 +01:00
eval(*env2, body, v);
return;
}
2010-03-25 16:38:37 +01:00
if (matchList(e, es)) {
v.type = tList;
v.list.length = ATgetLength(es);
2010-03-28 18:37:39 +02:00
v.list.elems = allocValues(v.list.length);
2010-03-25 16:38:37 +01:00
for (unsigned int n = 0; n < v.list.length; ++n, es = ATgetNext(es)) {
v.list.elems[n].type = tThunk;
2010-03-26 16:45:53 +01:00
v.list.elems[n].thunk.env = &env;
2010-03-25 16:38:37 +01:00
v.list.elems[n].thunk.expr = ATgetFirst(es);
}
return;
}
if (matchOpEq(e, e1, e2)) {
Value v1; eval(env, e1, v1);
Value v2; eval(env, e2, v2);
setBoolValue(v, eqValues(v1, v2));
return;
}
if (matchOpNEq(e, e1, e2)) {
Value v1; eval(env, e1, v1);
Value v2; eval(env, e2, v2);
setBoolValue(v, !eqValues(v1, v2));
return;
}
2010-03-25 16:38:37 +01:00
if (matchOpConcat(e, e1, e2)) {
Value v1; eval(env, e1, v1);
2010-03-25 17:35:24 +01:00
if (v1.type != tList) throw TypeError("list expected");
2010-03-25 16:38:37 +01:00
Value v2; eval(env, e2, v2);
2010-03-25 17:35:24 +01:00
if (v2.type != tList) throw TypeError("list expected");
2010-03-25 16:38:37 +01:00
v.type = tList;
v.list.length = v1.list.length + v2.list.length;
2010-03-28 18:37:39 +02:00
v.list.elems = allocValues(v.list.length);
2010-03-25 16:38:37 +01:00
/* !!! This loses sharing with the original lists. We could
use a tCopy node, but that would use more memory. */
for (unsigned int n = 0; n < v1.list.length; ++n)
v.list.elems[n] = v1.list.elems[n];
for (unsigned int n = 0; n < v2.list.length; ++n)
v.list.elems[n + v1.list.length] = v2.list.elems[n];
return;
}
2010-03-25 17:35:24 +01:00
2010-03-25 16:38:37 +01:00
throw Error("unsupported term");
}
2010-03-26 16:45:53 +01:00
static void strictEval(Env & env, Expr e, Value & v)
2010-03-25 16:38:37 +01:00
{
eval(env, e, v);
if (v.type == tAttrs) {
foreach (Bindings::iterator, i, *v.attrs)
forceValue(i->second);
}
else if (v.type == tList) {
for (unsigned int n = 0; n < v.list.length; ++n)
forceValue(v.list.elems[n]);
}
}
2010-03-26 16:45:53 +01:00
static void prim_head(Value * * args, Value & v)
{
forceValue(*args[0]);
if (args[0]->type != tList) throw TypeError("list expected");
if (args[0]->list.length == 0)
throw Error("`head' called on an empty list");
forceValue(args[0]->list.elems[0]);
v = args[0]->list.elems[0];
}
static void prim_add(Value * * args, Value & v)
{
2010-03-28 18:37:39 +02:00
forceValue(*args[0]);
if (args[0]->type != tInt) throw TypeError("integer expected");
forceValue(*args[1]);
if (args[1]->type != tInt) throw TypeError("integer expected");
v.type = tInt;
v.integer = args[0]->integer + args[1]->integer;
2010-03-26 16:45:53 +01:00
}
static void addPrimOp(Env & env, const string & name, unsigned int arity, PrimOp_ fun)
{
Value & v = env.bindings[toATerm(name)];
2010-03-28 18:37:39 +02:00
nrValues++;
2010-03-26 16:45:53 +01:00
v.type = tPrimOp;
v.primOp.arity = arity;
v.primOp.fun = fun;
}
void doTest(string s)
{
2010-03-26 16:45:53 +01:00
Env baseEnv;
baseEnv.up = 0;
/* Add global constants such as `true' to the base environment. */
{
Value & v = baseEnv.bindings[toATerm("true")];
v.type = tBool;
v.boolean = true;
}
{
Value & v = baseEnv.bindings[toATerm("false")];
v.type = tBool;
v.boolean = false;
}
/* Add primops to the base environment. */
addPrimOp(baseEnv, "__head", 1, prim_head);
addPrimOp(baseEnv, "__add", 2, prim_add);
2010-03-25 17:35:24 +01:00
p1 = p2 = 0;
EvalState state;
Expr e = parseExprFromString(state, s, "/");
printMsg(lvlError, format(">>>>> %1%") % e);
2010-03-24 13:41:08 +01:00
Value v;
2010-03-26 16:45:53 +01:00
strictEval(baseEnv, e, v);
printMsg(lvlError, format("result: %1%") % v);
}
void run(Strings args)
{
2010-03-24 13:41:08 +01:00
printMsg(lvlError, format("size of value: %1% bytes") % sizeof(Value));
doTest("123");
doTest("{ x = 1; y = 2; }");
doTest("{ x = 1; y = 2; }.y");
doTest("rec { x = 1; y = x; }.y");
2010-03-24 12:06:05 +01:00
doTest("(x: x) 1");
doTest("(x: y: y) 1 2");
doTest("x: x");
doTest("({x, y}: x) { x = 1; y = 2; }");
doTest("({x, y}@args: args.x) { x = 1; y = 2; }");
doTest("(args@{x, y}: args.x) { x = 1; y = 2; }");
doTest("({x ? 1}: x) { }");
doTest("({x ? 1, y ? x}: y) { x = 2; }");
doTest("({x, y, ...}: x) { x = 1; y = 2; z = 3; }");
doTest("({x, y, ...}@args: args.z) { x = 1; y = 2; z = 3; }");
2010-03-25 13:51:14 +01:00
//doTest("({x ? y, y ? x}: y) { }");
doTest("let x = 1; in x");
doTest("with { x = 1; }; x");
doTest("let x = 2; in with { x = 1; }; x"); // => 2
doTest("with { x = 1; }; with { x = 2; }; x"); // => 1
2010-03-25 16:38:37 +01:00
doTest("[ 1 2 3 ]");
doTest("[ 1 2 ] ++ [ 3 4 5 ]");
doTest("123 == 123");
doTest("123 == 456");
doTest("let id = x: x; in [1 2] == [(id 1) (id 2)]");
doTest("let id = x: x; in [1 2] == [(id 1) (id 3)]");
doTest("[1 2] == [3 (let x = x; in x)]");
doTest("{ x = 1; y.z = 2; } == { y = { z = 2; }; x = 1; }");
doTest("{ x = 1; y = 2; } == { x = 2; }");
doTest("{ x = [ 1 2 ]; } == { x = [ 1 ] ++ [ 2 ]; }");
doTest("1 != 1");
2010-03-26 16:45:53 +01:00
doTest("true");
doTest("true == false");
doTest("__head [ 1 2 3 ]");
doTest("__add 1 2");
printMsg(lvlError, format("alloced %1% values") % nrValues);
2010-03-24 13:41:08 +01:00
printMsg(lvlError, format("alloced %1% environments") % nrEnvs);
2010-03-25 17:35:24 +01:00
printMsg(lvlError, format("each eval() uses %1% bytes of stack space") % (p1 - p2));
}
void printHelp()
{
}
string programId = "eval-test";