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

286 lines
6.4 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 std::map<string, 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,
tAttrs,
2010-03-24 12:06:05 +01:00
tThunk,
tLambda,
tCopy
} ValueType;
2010-03-24 13:41:08 +01:00
struct Value
{
ValueType type;
union
{
int integer;
Bindings * attrs;
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-24 13:41:08 +01:00
std::ostream & operator << (std::ostream & str, Value & v)
{
switch (v.type) {
case tInt:
str << v.integer;
break;
case tAttrs:
str << "{ ";
2010-03-24 13:41:08 +01:00
foreach (Bindings::iterator, i, *v.attrs)
str << i->first << " = " << i->second << "; ";
str << "}";
break;
case tThunk:
str << "<CODE>";
break;
case tLambda:
str << "<LAMBDA>";
break;
default:
abort();
}
return str;
}
static void eval(Env * env, Expr e, Value & v);
2010-03-24 13:41:08 +01:00
void forceValue(Value & v)
{
if (v.type == tThunk) eval(v.thunk.env, v.thunk.expr, v);
else if (v.type == tCopy) {
forceValue(*v.val);
v = *v.val;
}
}
2010-03-24 13:41:08 +01:00
Value * lookupVar(Env * env, const string & name)
{
for ( ; env; env = env->up) {
2010-03-24 13:41:08 +01:00
Bindings::iterator i = env->bindings.find(name);
if (i != env->bindings.end()) return &i->second;
}
throw Error("undefined variable");
}
unsigned long nrValues = 0;
2010-03-24 13:41:08 +01:00
unsigned long nrEnvs = 0;
Env * allocEnv()
{
2010-03-24 13:41:08 +01:00
nrEnvs++;
return new Env;
}
static void eval(Env * env, Expr e, Value & v)
{
printMsg(lvlError, format("eval: %1%") % e);
ATerm name;
if (matchVar(e, name)) {
2010-03-24 13:41:08 +01:00
Value * v2 = lookupVar(env, aterm2String(name));
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 */
2010-03-24 13:41:08 +01:00
Value & v2 = (*v.attrs)[aterm2String(name)];
nrValues++;
v2.type = tThunk;
v2.thunk.env = env;
v2.thunk.expr = e2;
}
return;
}
ATermList rbnds, nrbnds;
if (matchRec(e, rbnds, nrbnds)) {
2010-03-24 13:41:08 +01:00
Env * env2 = allocEnv();
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 */
2010-03-24 13:41:08 +01:00
Value & v2 = env2->bindings[aterm2String(name)];
nrValues++;
v2.type = tThunk;
v2.thunk.env = env2;
v2.thunk.expr = e2;
}
return;
}
2010-03-24 12:06:05 +01:00
Expr 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(aterm2String(name));
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;
v.lambda.env = env;
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-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-24 12:06:05 +01:00
env2->up = env;
ATermList formals; ATerm ellipsis;
if (matchVarPat(v.lambda.pat, name)) {
Value & vArg = env2->bindings[aterm2String(name)];
vArg.type = tThunk;
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_;
else
vArg = &env2->bindings[aterm2String(name)];
eval(env, arg, *vArg);
if (vArg->type != tAttrs) throw TypeError("expected attribute set");
for (ATermIterator i(formals); i; ++i) {
Expr name, def;
DefaultValue def2;
if (!matchFormal(*i, name, def2)) abort(); /* can't happen */
Bindings::iterator j = vArg->attrs->find(aterm2String(name));
if (j == vArg->attrs->end())
throw TypeError(format("the argument named `%1%' required by the function is missing")
% aterm2String(name));
Value & v = env2->bindings[aterm2String(name)];
v.type = tCopy;
v.val = &j->second;
}
}
else abort();
2010-03-24 13:41:08 +01:00
eval(env2, v.lambda.body, v);
return;
2010-03-24 12:06:05 +01:00
}
abort();
}
void doTest(string s)
{
EvalState state;
Expr e = parseExprFromString(state, s, "/");
printMsg(lvlError, format(">>>>> %1%") % e);
2010-03-24 13:41:08 +01:00
Value v;
eval(0, 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; }");
//Expr e = parseExprFromString(state, "let x = \"a\"; in x + \"b\"", "/");
//Expr e = parseExprFromString(state, "(x: x + \"b\") \"a\"", "/");
//Expr e = parseExprFromString(state, "\"a\" + \"b\"", "/");
//Expr e = parseExprFromString(state, "\"a\" + \"b\"", "/");
printMsg(lvlError, format("alloced %1% values") % nrValues);
2010-03-24 13:41:08 +01:00
printMsg(lvlError, format("alloced %1% environments") % nrEnvs);
}
void printHelp()
{
}
string programId = "eval-test";