--- a/src/pt-misc.cc
+++ b/src/pt-misc.cc
@@ -44,8 +44,8 @@
 #include "error.h"
 #include "input.h"
 #include "oct-obj.h"
-#include "oct-usr-fcn.h"
 #include "oct-var-ref.h"
+#include "ov-usr-fcn.h"
 #include "ov.h"
 #include "pager.h"
 #include "pt-cmd.h"
@@ -54,7 +54,6 @@
 #include "pt-id.h"
 #include "pt-indir.h"
 #include "pt-misc.h"
-#include "pt-mvr.h"
 #include "pt-pr-code.h"
 #include "pt-walk.h"
 #include "toplev.h"
@@ -106,10 +105,10 @@
     }
 }
 
-octave_value
-tree_statement::eval (bool silent, bool in_function_body)
+octave_value_list
+tree_statement::eval (bool silent, int nargout, bool in_function_body)
 {
-  octave_value retval;
+  octave_value_list retval;
 
   bool pf = silent ? false : print_flag;
 
@@ -120,37 +119,34 @@
       if (cmd)
 	cmd->eval ();
       else
-	retval = expr->eval (pf);
-    }
-
-  return retval;
-}
+	{
+	  expr->set_print_flag (pf);
 
-octave_value_list
-tree_statement::eval (bool silent, int nargout, bool in_function_body)
-{
-  bool pf = silent ? false : print_flag;
+	  // XXX FIXME XXX -- maybe all of this should be packaged in
+	  // one virtual function that returns a flag saying whether
+	  // or not the expression will take care of binding ans and
+	  // printing the result.
 
-  octave_value_list retval;
+	  bool do_bind_ans = false;
 
-  if (cmd || expr)
-    {
-      maybe_echo_code (in_function_body);
+	  if (expr->is_identifier ())
+	    {
+	      bool script_file_executed = false;
 
-      if (cmd)
-	cmd->eval ();
-      else
-	{
-	  if (expr->is_multi_val_ret_expression ())
-	    {
-	      octave_value_list args;
+	      tree_identifier *id = static_cast<tree_identifier *> (expr);
 
-	      tree_multi_val_ret *t = static_cast<tree_multi_val_ret *> (expr);
+	      id->do_lookup (script_file_executed, false);
 
-	      retval = t->eval (pf, nargout, args);
+	      do_bind_ans = id->is_function ();
 	    }
 	  else
-	    retval = expr->eval (pf);
+	    do_bind_ans = (! (expr->is_indirect_ref ()
+			      || expr->is_assignment_expression ()));
+
+	  retval = expr->rvalue (nargout);
+
+	  if (do_bind_ans && ! (error_state || retval.empty ()))
+	    bind_ans (retval(0), pf);
 	}
     }
 
@@ -163,10 +159,10 @@
   tw.visit_statement (*this);
 }
 
-octave_value
-tree_statement_list::eval (bool silent)
+octave_value_list
+tree_statement_list::eval (bool silent, int nargout)
 {
-  octave_value retval;
+  octave_value_list retval;
 
   if (error_state)
     return retval;
@@ -175,39 +171,12 @@
     {
       tree_statement *elt = this->operator () (p);
 
-      bool silent_flag =
-	silent ? true : (function_body ? Vsilent_functions : false);
-
-      retval = elt->eval (silent_flag, function_body);
-
-      if (error_state)
-	break;
-
-      if (breaking || continuing)
-	break;
-
-      if (returning)
-	break;
-    }
+      if (elt)
+	{
+	  bool silent_flag =
+	    silent ? true : (function_body ? Vsilent_functions : false);
 
-  return retval;
-}
-
-octave_value_list
-tree_statement_list::eval (bool no_print, int nargout)
-{
-  octave_value_list retval;
-
-  if (error_state)
-    return retval;
-
-  if (nargout > 1)
-    {
-      for (Pix p = first (); p != 0; next (p))
-	{
-	  tree_statement *elt = this->operator () (p);
-
-	  retval = elt->eval (no_print, nargout, function_body);
+	  retval = elt->eval (silent_flag, nargout, function_body);
 
 	  if (error_state)
 	    break;
@@ -218,9 +187,9 @@
 	  if (returning)
 	    break;
 	}
+      else
+	error ("invalid statement found in statement list!");
     }
-  else
-    retval = eval (no_print);
 
   return retval;
 }
@@ -240,6 +209,20 @@
     }
 }
 
+bool
+tree_argument_list::all_elements_are_constant (void) const
+{
+  for (Pix p = first (); p != 0; next (p))
+    {
+      tree_expression *elt = this->operator () (p);
+
+      if (! elt->is_constant ())
+	return false;
+    }
+
+  return true;
+}
+
 octave_value_list
 tree_argument_list::convert_to_const_vector (void)
 {
@@ -257,9 +240,11 @@
   for (int k = 0; k < len; k++)
     {
       tree_expression *elt = this->operator () (p);
+
       if (elt)
 	{
-	  octave_value tmp = elt->eval ();
+	  octave_value tmp = elt->rvalue ();
+
 	  if (error_state)
 	    {
 	      ::error ("evaluating argument list element number %d", k);
@@ -368,7 +353,11 @@
       tree_identifier *elt = this->operator () (p);
 
       if (! elt->is_defined ())
-	elt->reference () . assign (octave_value::asn_eq, val);
+	{
+	  octave_variable_reference tmp = elt->lvalue ();
+
+	  tmp.assign (octave_value::asn_eq, val);
+	}
     }
 }
 
@@ -388,7 +377,7 @@
     {
       tree_identifier *elt = this->operator () (p);
 
-      octave_variable_reference ref = elt->reference ();
+      octave_variable_reference ref = elt->lvalue ();
 
       if (i < nargin)
 	{
@@ -425,7 +414,7 @@
       tree_identifier *elt = this->operator () (p);
 
       if (elt->is_defined ())
-	retval(i) = elt->eval ();
+	retval(i) = elt->rvalue ();
 
       i++;
     }
@@ -489,7 +478,7 @@
 tree_decl_elt::~tree_decl_elt (void)
 {
   delete id;
-  delete ass_expr;
+  delete expr;
 }
 
 void
@@ -579,7 +568,7 @@
 {
   bool retval = false;
 
-  octave_value label_value = label->eval ();
+  octave_value label_value = label->rvalue ();
 
   if (! error_state)
     {