* Simplify the evaluator.

3 files changed, 49 insertions, 62 deletions

diff --git a/src/eval.cc b/src/eval.cc
index e6a3478a1551..ad6f5ae2a2a7 100644
--- a/src/eval.cc
+++ b/src/eval.cc
@@ -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);
 }
diff --git a/src/eval.hh b/src/eval.hh
index bddc9f5d9578..1a8edcfdea9e 100644
--- a/src/eval.hh
+++ b/src/eval.hh
@@ -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. */
+Expr evalValue(Expr e);
 
+/* Return a canonical textual representation of an expression. */
+string printExpr(Expr e);
 
-/* Evaluate an expression. */
-EvalResult evalValue(Expr e);
+/* Hash an expression. */
+Hash hashExpr(Expr e);
 
 
 #endif /* !__EVAL_H */
diff --git a/src/test.cc b/src/test.cc
index bf7ee191f0b7..56414956202c 100644
--- a/src/test.cc
+++ b/src/test.cc
@@ -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;
 }