[pure-lang-svn] SF.net SVN: pure-lang: [327] pure/trunk

[<ag...@us...>]

Revision: 327
          http://pure-lang.svn.sourceforge.net/pure-lang/?rev=327&view=rev
Author:   agraef
Date:     2008-06-28 10:01:14 -0700 (Sat, 28 Jun 2008)

Log Message:
-----------
Bugfixes: Perform substitutions on the rhs of variable and constant definitions.

Modified Paths:
--------------
    pure/trunk/ChangeLog
    pure/trunk/interpreter.cc
    pure/trunk/interpreter.hh

Modified: pure/trunk/ChangeLog
===================================================================
--- pure/trunk/ChangeLog	2008-06-28 12:20:43 UTC (rev 326)
+++ pure/trunk/ChangeLog	2008-06-28 17:01:14 UTC (rev 327)
@@ -1,5 +1,8 @@
 2008-06-28  Albert Graef  <Dr....@t-...>
 
+	* interpreter.cc: Promote type tags and substitute constants on
+	the rhs of variable and constant definitions.
+
 	* lib/prelude.pure: Using xs!ns for slicing conflicts with more
 	general indexing of containers with arbitrary keys. Use !! for
 	slicing instead. Restrict the definition to lists and tuples, and

Modified: pure/trunk/interpreter.cc
===================================================================
--- pure/trunk/interpreter.cc	2008-06-28 12:20:43 UTC (rev 326)
+++ pure/trunk/interpreter.cc	2008-06-28 17:01:14 UTC (rev 327)
@@ -490,7 +490,7 @@
 
 // Evaluate an expression.
 
-pure_expr *interpreter::eval(expr x)
+pure_expr *interpreter::eval(expr& x)
 {
   globals g;
   save_globals(g);
@@ -500,14 +500,15 @@
   return res;
 }
 
-pure_expr *interpreter::eval(expr x, pure_expr*& e)
+pure_expr *interpreter::eval(expr& x, pure_expr*& e)
 {
   globals g;
   save_globals(g);
   compile();
-  // promote type tags:
+  // promote type tags and substitute constants:
   env vars; expr u = subst(vars, x);
   compile(u);
+  x = u;
   pure_expr *res = doeval(u, e);
   restore_globals(g);
   return res;
@@ -515,7 +516,7 @@
 
 // Define global variables.
 
-pure_expr *interpreter::defn(expr pat, expr x)
+pure_expr *interpreter::defn(expr pat, expr& x)
 {
   globals g;
   save_globals(g);
@@ -525,13 +526,15 @@
   return res;
 }
 
-pure_expr *interpreter::defn(expr pat, expr x, pure_expr*& e)
+pure_expr *interpreter::defn(expr pat, expr& x, pure_expr*& e)
 {
   globals g;
   save_globals(g);
   compile();
   env vars;
-  expr lhs = bind(vars, pat), rhs = x;
+  // promote type tags and substitute constants:
+  expr rhs = subst(vars, x);
+  expr lhs = bind(vars, pat);
   build_env(vars, lhs);
   for (env::const_iterator it = vars.begin(); it != vars.end(); ++it) {
     int32_t f = it->first;
@@ -550,6 +553,7 @@
     }
   }
   compile(rhs);
+  x = rhs;
   pure_expr *res = dodefn(vars, lhs, rhs, e);
   if (!res) return 0;
   for (env::const_iterator it = vars.begin(); it != vars.end(); ++it) {
@@ -564,7 +568,7 @@
 
 // Define global constants (macro definitions).
 
-pure_expr *interpreter::const_defn(expr pat, expr x)
+pure_expr *interpreter::const_defn(expr pat, expr& x)
 {
   globals g;
   save_globals(g);
@@ -617,13 +621,15 @@
   return x;
 }
 
-pure_expr *interpreter::const_defn(expr pat, expr x, pure_expr*& e)
+pure_expr *interpreter::const_defn(expr pat, expr& x, pure_expr*& e)
 {
   globals g;
   save_globals(g);
   compile();
   env vars;
-  expr lhs = bind(vars, pat), rhs = x;
+  // promote type tags and substitute constants:
+  expr rhs = subst(vars, x);
+  expr lhs = bind(vars, pat);
   build_env(vars, lhs);
   for (env::const_iterator it = vars.begin(); it != vars.end(); ++it) {
     int32_t f = it->first;
@@ -645,6 +651,7 @@
     }
   }
   compile(rhs);
+  x = rhs;
   pure_expr *res = doeval(rhs, e);
   if (!res) return 0;
   // convert the result back to a compile time expression

Modified: pure/trunk/interpreter.hh
===================================================================
--- pure/trunk/interpreter.hh	2008-06-28 12:20:43 UTC (rev 326)
+++ pure/trunk/interpreter.hh	2008-06-28 17:01:14 UTC (rev 327)
@@ -304,8 +304,8 @@
      evaluation. In such a case, the variant with the extra e parameter
      returns the runtime expression thrown by the exception, if any. Both the
      result and the exception value (if any) are to be freed by the caller. */
-  pure_expr *eval(expr x);
-  pure_expr *eval(expr x, pure_expr*& e);
+  pure_expr *eval(expr& x);
+  pure_expr *eval(expr& x, pure_expr*& e);
 
   /* Evaluate an expression and define global variables. This works like
      eval() above, but also binds the variables in pat to the corresponding
@@ -315,8 +315,8 @@
      matched. Returns a null pointer if an exception occurred during the
      evaluation or if the pattern failed to match. Both the result and the
      exception value (if any) are to be freed by the caller. */
-  pure_expr *defn(expr pat, expr x);
-  pure_expr *defn(expr pat, expr x, pure_expr*& e);
+  pure_expr *defn(expr pat, expr& x);
+  pure_expr *defn(expr pat, expr& x, pure_expr*& e);
 
   /* Bind a global variable to a given value. This binds the given variable
      symbol directly to the given value, without matching and evaluating
@@ -334,8 +334,8 @@
      the left-hand side pattern as usual. Unlike variables, existing constant
      symbols cannot be redefined, so they have to be cleared before you can
      give them new values. */
-  pure_expr *const_defn(expr pat, expr x);
-  pure_expr *const_defn(expr pat, expr x, pure_expr*& e);
+  pure_expr *const_defn(expr pat, expr& x);
+  pure_expr *const_defn(expr pat, expr& x, pure_expr*& e);
 
   /* Directly bind a given constant symbol to a given value. */
   void const_defn(int32_t tag, pure_expr *x);


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.