lix-project/lix-releng-staging
0
0
Fork 0
Code Packages Activity

* Simplify the evaluator.

Browse source
This commit is contained in:
Eelco Dolstra 2003-06-17 13:37:44 +00:00
parent c739e20585
commit a7ab242fb4
3 changed files with 50 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
src/eval.cc
View file

@ -186,30 +186,31 @@ static void checkPlatform(string platform)
}
string printExpr(Expr e)
{
char * s = ATwriteToString(e);
return s;
}
/* Throw an exception with an error message containing the given
aterm. */
static Error badTerm(const string & msg, Expr e)
{
char * s = ATwriteToString(e);
return Error(msg + ", in `" + s + "'");
return Error(msg + ", in `" + printExpr(e) + "'");
}
/* Hash an expression. Hopefully the representation used by
ATwriteToString() won't change, otherwise all hashes will
change. */
static Hash hashExpr(Expr e)
Hash hashExpr(Expr e)
{
char * s = ATwriteToString(e);
debug(s);
return hashString(s);
return hashString(printExpr(e));
}
/* Evaluate an expression; the result must be a string. */
static string evalString(Expr e)
{
e = evalValue(e).e;
e = evalValue(e);
char * s;
if (ATmatch(e, "Str(<str>)", &s)) return s;
else throw badTerm("string value expected", e);
@ -220,10 +221,10 @@ static string evalString(Expr e)
non-expression reference. */
static Hash evalExternal(Expr e)
{
EvalResult r = evalValue(e);
e = evalValue(e);
char * s;
if (ATmatch(r.e, "External(<str>)", &s)) return r.h;
else throw badTerm("external non-expression value expected", r.e);
if (ATmatch(e, "External(<str>)", &s)) return parseHash(s);
else throw badTerm("external non-expression value expected", e);
}
@ -238,7 +239,7 @@ void evalArgs(ATermList args, ATermList & argsNF, Environment & env)
throw badTerm("invalid argument", arg);
string name = evalString(eName);
eVal = evalValue(eVal).e;
eVal = evalValue(eVal);
char * s;
if (ATmatch(eVal, "Str(<str>)", &s)) {
@ -256,9 +257,8 @@ void evalArgs(ATermList args, ATermList & argsNF, Environment & env)
/* Evaluate an expression. */
EvalResult evalValue(Expr e)
Expr evalValue(Expr e)
{
EvalResult r;
char * s;
Expr eBuildPlatform, eProg;
ATermList args;
@ -267,21 +267,19 @@ EvalResult evalValue(Expr e)
if (ATmatch(e, "Str(<str>)", &s) ||
ATmatch(e, "Bool(True)") ||
ATmatch(e, "Bool(False)"))
{
r.e = e;
}
return e;
/* External expressions. */
/* External non-expressions. */
else if (ATmatch(e, "External(<str>)", &s)) {
r.e = e;
r.h = parseHash(s);
if (ATmatch(e, "External(<str>)", &s)) {
parseHash(s); /* i.e., throw exception if not valid */
return e;
}
/* Execution primitive. */
else if (ATmatch(e, "Exec(<term>, <term>, [<list>])",
if (ATmatch(e, "Exec(<term>, <term>, [<list>])",
&eBuildPlatform, &eProg, &args))
{
string buildPlatform = evalString(eBuildPlatform);
@ -312,12 +310,9 @@ EvalResult evalValue(Expr e)
(string) sourceHash + "-nf", buildPlatform, prog, env);
}
r.e = ATmake("External(<str>)", ((string) targetHash).c_str());
r.h = targetHash;
return ATmake("External(<str>)", ((string) targetHash).c_str());
}
/* Barf. */
else throw badTerm("invalid expression", e);
return r;
throw badTerm("invalid expression", e);
}

56
src/eval.hh
View file

@ -18,69 +18,63 @@ using namespace std;
| Bool(b) -- boolean constant
| App(e, e) -- application
| Lam(x, e) -- lambda abstraction
| Exec(platform, e, [(s, e)])
| Exec(platform, e, [Arg(e, e)])
-- primitive; execute e with args e* on platform
;
Semantics
Each rules given as eval(e) => (e', h'), i.e., expression e has a
normal form e' with hash code h'. evalE = fst . eval. evalH = snd
. eval.
Each rule given as eval(e) => e', i.e., expression e has a normal
form e'.
eval(Hash(h)) => eval(loadExpr(h))
eval(External(h)) => (External(h), h)
eval(Str(s)@e) => (e, 0) # idem for Bool
eval(External(h)) => External(h) # idem for Str, Bool
eval(App(e1, e2)) => eval(App(e1', e2))
where e1' = evalE(e1)
where e1' = eval(e1)
eval(App(Lam(var, body), arg)@in) =>
eval(subst(var, arg, body))@out
[AND write out to storage, and dbNFs[hash(in)] = hash(out) ???]
eval(App(Lam(var, body), arg)) =>
eval(subst(var, arg, body))
eval(Exec(platform, prog, args)@e) =>
eval(Exec(platform, prog, args)) =>
(External(h), h)
where
hIn = hashExpr(e)
fn = ... form name involving hIn ...
fn = ... name of the output (random or by hashing expr) ...
h =
if exec(evalE(platform) => Str(...)
, getFile(evalH(prog))
if exec( fn
, eval(platform) => Str(...)
, getFile(eval(prog))
, map(makeArg . eval, args)
) then
hashExternal(fn)
else
undef
... register ...
makeArg((argn, (External(h), h))) => (argn, getFile(h))
makeArg((argn, (Str(s), _))) => (argn, s)
makeArg((argn, (Bool(True), _))) => (argn, "1")
makeArg((argn, (Bool(False), _))) => (argn, undef)
makeArg(Arg(Str(nm), (External(h), h))) => (nm, getFile(h))
makeArg(Arg(Str(nm), (Str(s), _))) => (nm, s)
makeArg(Arg(Str(nm), (Bool(True), _))) => (nm, "1")
makeArg(Arg(Str(nm), (Bool(False), _))) => (nm, undef)
getFile :: Hash -> FileName
loadExpr :: Hash -> FileName
hashExpr :: Expr -> Hash
hashExternal :: FileName -> Hash
exec :: Platform -> FileName -> [(String, String)] -> Status
exec :: FileName -> Platform -> FileName -> [(String, String)] -> Status
*/
typedef ATerm Expr;
struct EvalResult
{
Expr e;
Hash h;
};
/* Evaluate an expression. */
EvalResult evalValue(Expr e);
Expr evalValue(Expr e);
/* Return a canonical textual representation of an expression. */
string printExpr(Expr e);
/* Hash an expression. */
Hash hashExpr(Expr e);
#endif /* !__EVAL_H */

6
src/test.cc
View file

@ -12,10 +12,8 @@
void evalTest(Expr e)
{
EvalResult r = evalValue(e);
char * s = ATwriteToString(r.e);
cout << (string) r.h << ": " << s << endl;
e = evalValue(e);
cout << (string) hashExpr(e) << ": " << printExpr(e) << endl;
}