# HG changeset patch
# User jwe
# Date 830411719 0
# Node ID bfb775fb6fe8fca11a6fbdb501c01fb1658567e3
# Parent  7603b37325dbfa6d0097d7b91a6c6ba5b20a7e35
[project @ 1996-04-25 05:55:19 by jwe]

diff --git a/src/Array-tc.cc b/src/Array-tc.cc
--- a/src/Array-tc.cc
+++ b/src/Array-tc.cc
@@ -24,7 +24,7 @@
 #include <config.h>
 #endif
 
-// Instantiate Arrays of tree_constants.
+// Instantiate Arrays of octave_values.
 
 #include "Array.h"
 #include "Array.cc"
@@ -43,7 +43,7 @@
 extern template class Array2<Complex>;
 extern template class DiagArray2<Complex>;
 
-template class Array<tree_constant>;
+template class Array<octave_value>;
 
 /*
 ;;; Local Variables: ***
diff --git a/src/Map-i.cc b/src/Map-i.cc
--- a/src/Map-i.cc
+++ b/src/Map-i.cc
@@ -20,7 +20,7 @@
 
 */
 
-// Instantiate Maps of tree_constants.
+// Instantiate Maps of octave_values.
 
 #include "Map.h"
 #include "Map.cc"
diff --git a/src/Map-tc.cc b/src/Map-tc.cc
--- a/src/Map-tc.cc
+++ b/src/Map-tc.cc
@@ -20,19 +20,19 @@
 
 */
 
-// Instantiate Maps of tree_constants.
+// Instantiate Maps of octave_values.
 
 #include "Map.h"
 #include "Map.cc"
 
 #include "pt-const.h"
 
-template class Map<tree_constant>;
-template class CHNode<tree_constant>;
-template class CHMap<tree_constant>;
+template class Map<octave_value>;
+template class CHNode<octave_value>;
+template class CHMap<octave_value>;
 
-template static int goodCHptr (CHNode<tree_constant> *t);
-template static int CHptr_to_index (CHNode<tree_constant> *t);
+template static int goodCHptr (CHNode<octave_value> *t);
+template static int CHptr_to_index (CHNode<octave_value> *t);
 
 /*
 ;;; Local Variables: ***
diff --git a/src/SLList-tc.cc b/src/SLList-tc.cc
--- a/src/SLList-tc.cc
+++ b/src/SLList-tc.cc
@@ -30,8 +30,8 @@
 
 #include "pt-const.h"
 
-template class SLNode<tree_constant>;
-template class SLList<tree_constant>;
+template class SLNode<octave_value>;
+template class SLList<octave_value>;
 
 /*
 ;;; Local Variables: ***
diff --git a/src/arith-ops.cc b/src/arith-ops.cc
--- a/src/arith-ops.cc
+++ b/src/arith-ops.cc
@@ -974,7 +974,7 @@
 //   matrix
 //   complex_matrix
 
-tree_constant
+octave_value
 do_unary_op (double d, tree_expression::type t)
 {
   double result = 0.0;
@@ -999,10 +999,10 @@
       break;
     }
 
-  return tree_constant (result);
+  return octave_value (result);
 }
 
-tree_constant
+octave_value
 do_unary_op (const Matrix& a, tree_expression::type t)
 {
   Matrix result;
@@ -1027,10 +1027,10 @@
       break;
     }
 
-  return tree_constant (result);
+  return octave_value (result);
 }
 
-tree_constant
+octave_value
 do_unary_op (const Complex& c, tree_expression::type t)
 {
   Complex result = 0.0;
@@ -1058,10 +1058,10 @@
       break;
     }
 
-  return tree_constant (result);
+  return octave_value (result);
 }
 
-tree_constant
+octave_value
 do_unary_op (const ComplexMatrix& a, tree_expression::type t)
 {
   ComplexMatrix result;
@@ -1089,7 +1089,7 @@
       break;
     }
 
-  return tree_constant (result);
+  return octave_value (result);
 }
 
 // Binary operations.  One for each type combination, in the order
@@ -1107,7 +1107,7 @@
 //                  +---+---+----+----+
 
 // -*- 1 -*-
-tree_constant
+octave_value
 do_binary_op (double a, double b, tree_expression::type t)
 {
   double result = 0.0;
@@ -1184,13 +1184,13 @@
     }
 
   if (error_state)
-    return tree_constant ();
-
-  return tree_constant (result);
+    return octave_value ();
+
+  return octave_value (result);
 }
 
 // -*- 2 -*-
-tree_constant
+octave_value
 do_binary_op (double a, const Matrix& b, tree_expression::type t)
 {
   Matrix result;
@@ -1271,13 +1271,13 @@
     }
 
   if (error_state)
-    return tree_constant ();
-
-  return tree_constant (result);
+    return octave_value ();
+
+  return octave_value (result);
 }
 
 // -*- 3 -*-
-tree_constant
+octave_value
 do_binary_op (double a, const Complex& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -1371,18 +1371,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 4 -*-
-tree_constant
+octave_value
 do_binary_op (double a, const ComplexMatrix& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -1478,18 +1478,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 5 -*-
-tree_constant
+octave_value
 do_binary_op (const Matrix& a, double b, tree_expression::type t)
 {
   Matrix result;
@@ -1568,13 +1568,13 @@
     }
 
   if (error_state)
-    return tree_constant ();
-
-  return tree_constant (result);
+    return octave_value ();
+
+  return octave_value (result);
 }
 
 // -*- 6 -*-
-tree_constant
+octave_value
 do_binary_op (const Matrix& a, const Matrix& b, tree_expression::type t)
 {
   Matrix result;
@@ -1674,13 +1674,13 @@
     }
 
   if (error_state)
-    return tree_constant ();
-
-  return tree_constant (result);
+    return octave_value ();
+
+  return octave_value (result);
 }
 
 // -*- 7 -*-
-tree_constant
+octave_value
 do_binary_op (const Matrix& a, const Complex& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -1775,18 +1775,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 8 -*-
-tree_constant
+octave_value
 do_binary_op (const Matrix& a, const ComplexMatrix& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -1904,18 +1904,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 9 -*-
-tree_constant
+octave_value
 do_binary_op (const Complex& a, double b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -2009,18 +2009,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 10 -*-
-tree_constant
+octave_value
 do_binary_op (const Complex& a, const Matrix& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -2117,18 +2117,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 11 -*-
-tree_constant
+octave_value
 do_binary_op (const Complex& a, const Complex& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -2222,18 +2222,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 12 -*-
-tree_constant
+octave_value
 do_binary_op (const Complex& a, const ComplexMatrix& b,
 	      tree_expression::type t)
 {
@@ -2331,18 +2331,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 13 -*-
-tree_constant
+octave_value
 do_binary_op (const ComplexMatrix& a, double b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -2437,18 +2437,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 14 -*-
-tree_constant
+octave_value
 do_binary_op (const ComplexMatrix& a, const Matrix& b, tree_expression::type t)
 {
   enum RT { RT_unknown, RT_real, RT_complex };
@@ -2566,18 +2566,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 15 -*-
-tree_constant
+octave_value
 do_binary_op (const ComplexMatrix& a, const Complex& b,
 	      tree_expression::type t)
 {
@@ -2673,18 +2673,18 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 // -*- 16 -*-
-tree_constant
+octave_value
 do_binary_op (const ComplexMatrix& a, const ComplexMatrix& b,
 	      tree_expression::type t)
 {
@@ -2803,14 +2803,14 @@
     }
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   assert (result_type != RT_unknown);
 
   if (result_type == RT_real)
-    return tree_constant (result);
+    return octave_value (result);
   else
-    return tree_constant (complex_result);
+    return octave_value (complex_result);
 }
 
 /*
diff --git a/src/arith-ops.h b/src/arith-ops.h
--- a/src/arith-ops.h
+++ b/src/arith-ops.h
@@ -29,63 +29,63 @@
 
 class Matrix;
 class ComplexMatrix;
-class tree_constant;
+class octave_value;
 
-extern tree_constant do_unary_op (double d, tree_expression::type t);
+extern octave_value do_unary_op (double d, tree_expression::type t);
 
-extern tree_constant do_unary_op (const Matrix& a, tree_expression::type t);
+extern octave_value do_unary_op (const Matrix& a, tree_expression::type t);
 
-extern tree_constant do_unary_op (const Complex& c, tree_expression::type t);
+extern octave_value do_unary_op (const Complex& c, tree_expression::type t);
 
-extern tree_constant do_unary_op (const ComplexMatrix& a,
+extern octave_value do_unary_op (const ComplexMatrix& a,
 				  tree_expression::type t);
 
-extern tree_constant do_binary_op (double a, double b,
+extern octave_value do_binary_op (double a, double b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (double a, const Matrix& b,
+extern octave_value do_binary_op (double a, const Matrix& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (double a, const Complex& b,
+extern octave_value do_binary_op (double a, const Complex& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (double a, const ComplexMatrix& b,
+extern octave_value do_binary_op (double a, const ComplexMatrix& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Matrix& a, double b,
+extern octave_value do_binary_op (const Matrix& a, double b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Matrix& a, const Matrix& b,
+extern octave_value do_binary_op (const Matrix& a, const Matrix& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Matrix& a, const Complex& b,
+extern octave_value do_binary_op (const Matrix& a, const Complex& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Matrix& a, const ComplexMatrix& b,
+extern octave_value do_binary_op (const Matrix& a, const ComplexMatrix& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Complex& a, double b,
+extern octave_value do_binary_op (const Complex& a, double b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Complex& a, const Matrix& b,
+extern octave_value do_binary_op (const Complex& a, const Matrix& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Complex& a, const Complex& b,
+extern octave_value do_binary_op (const Complex& a, const Complex& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const Complex& a, const ComplexMatrix& b,
+extern octave_value do_binary_op (const Complex& a, const ComplexMatrix& b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const ComplexMatrix& a, double b,
+extern octave_value do_binary_op (const ComplexMatrix& a, double b,
 				   tree_expression::type t);
 
-extern tree_constant do_binary_op (const ComplexMatrix& a, const Matrix& b,
+extern octave_value do_binary_op (const ComplexMatrix& a, const Matrix& b,
 				   tree_expression::type t); 
 
-extern tree_constant do_binary_op (const ComplexMatrix& a, const Complex& b,
+extern octave_value do_binary_op (const ComplexMatrix& a, const Complex& b,
 				   tree_expression::type t); 
 
-extern tree_constant do_binary_op (const ComplexMatrix& a,
+extern octave_value do_binary_op (const ComplexMatrix& a,
 				   const ComplexMatrix& b,
 				   tree_expression::type t); 
 
diff --git a/src/balance.cc b/src/balance.cc
--- a/src/balance.cc
+++ b/src/balance.cc
@@ -61,7 +61,7 @@
 \n\
 [CC, DD, AA, BB] = balance (A, B, OPT) returns AA (BB) = CC*A*DD (CC*B*DD)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -88,7 +88,7 @@
       my_nargin = nargin;
     }
 
-  tree_constant arg_a = args(0);
+  octave_value arg_a = args(0);
 
   int a_nr = arg_a.rows ();
   int a_nc = arg_a.columns ();
@@ -100,7 +100,7 @@
   if (arg_is_empty < 0)
     return retval;
   if (arg_is_empty > 0)
-    return Octave_object (2, Matrix ());
+    return octave_value_list (2, Matrix ());
 
   if (a_nr != a_nc)
     {
@@ -160,7 +160,7 @@
 
 	// 1st we have to check argument 2 dimensions and type...
 
-	tree_constant arg_b = args(1);
+	octave_value arg_b = args(1);
 
 	int b_nr = arg_b.rows ();
 	int b_nc = arg_b.columns ();
diff --git a/src/chol.cc b/src/chol.cc
--- a/src/chol.cc
+++ b/src/chol.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (chol, args, nargout,
   "R = chol (X): cholesky factorization")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -48,7 +48,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
     
   int nr = arg.rows ();
   int nc = arg.columns ();
diff --git a/src/colloc.cc b/src/colloc.cc
--- a/src/colloc.cc
+++ b/src/colloc.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (colloc, args, ,
   "[R, A, B, Q] = colloc (N [, \"left\"] [, \"right\"]): collocation weights")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/dassl.cc b/src/dassl.cc
--- a/src/dassl.cc
+++ b/src/dassl.cc
@@ -53,7 +53,7 @@
 
   assert (nstates == xdot.capacity ());
 
-  Octave_object args;
+  octave_value_list args;
   args(2) = t;
 
   if (nstates > 1)
@@ -65,8 +65,8 @@
 	  m1 (i, 0) = x.elem (i);
 	  m2 (i, 0) = xdot.elem (i);
 	}
-      tree_constant state (m1);
-      tree_constant deriv (m2);
+      octave_value state (m1);
+      octave_value deriv (m2);
       args(1) = deriv;
       args(0) = state;
     }
@@ -74,15 +74,15 @@
     {
       double d1 = x.elem (0);
       double d2 = xdot.elem (0);
-      tree_constant state (d1);
-      tree_constant deriv (d2);
+      octave_value state (d1);
+      octave_value deriv (d2);
       args(1) = deriv;
       args(0) = state;
     }
 
   if (dassl_fcn)
     {
-      Octave_object tmp = dassl_fcn->eval (0, 1, args);
+      octave_value_list tmp = dassl_fcn->eval (0, 1, args);
 
       if (error_state)
 	{
@@ -115,7 +115,7 @@
 \n\
 where x, xdot, and res are vectors, and t is a scalar.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -294,10 +294,10 @@
   warning ("dassl_options: no match for `%s'", keyword.c_str ());
 }
 
-static Octave_object
+static octave_value_list
 show_dassl_option (const string& keyword)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   DASSL_OPTIONS *list = dassl_option_table;
 
@@ -322,7 +322,7 @@
 Set or show options for dassl.  Keywords may be abbreviated\n\
 to the shortest match.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/data.cc b/src/data.cc
--- a/src/data.cc
+++ b/src/data.cc
@@ -57,7 +57,7 @@
 DEFUN (all, args, ,
   "all (X): are all elements of X nonzero?")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -72,7 +72,7 @@
 DEFUN (any, args, ,
   "any (X): are any elements of X nonzero?")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -141,14 +141,14 @@
 DEFUN (atan2, args, ,
   "atan2 (Y, X): atan (Y / X) in range -pi to pi")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
     {
-      tree_constant arg_y = args(0);
-      tree_constant arg_x = args(1);
+      octave_value arg_y = args(0);
+      octave_value arg_x = args(1);
 
       int y_nr = arg_y.rows ();
       int y_nc = arg_y.columns ();
@@ -227,13 +227,13 @@
 DEFUN (cumprod, args, ,
   "cumprod (X): cumulative products")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_real_type ())
 	{
@@ -264,13 +264,13 @@
 DEFUN (cumsum, args, ,
   "cumsum (X): cumulative sums")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_real_type ())
 	{
@@ -298,14 +298,14 @@
   return retval;
 }
 
-static tree_constant
+static octave_value
 make_diag (const Matrix& v, int k)
 {
   int nr = v.rows ();
   int nc = v.columns ();
   assert (nc == 1 || nr == 1);
 
-  tree_constant retval;
+  octave_value retval;
 
   int roff = 0;
   int coff = 0;
@@ -326,7 +326,7 @@
       Matrix m (n, n, 0.0);
       for (int i = 0; i < nc; i++)
 	m.elem (i+roff, i+coff) = v.elem (0, i);
-      retval = tree_constant (m);
+      retval = octave_value (m);
     }
   else
     {
@@ -334,20 +334,20 @@
       Matrix m (n, n, 0.0);
       for (int i = 0; i < nr; i++)
 	m.elem (i+roff, i+coff) = v.elem (i, 0);
-      retval = tree_constant (m);
+      retval = octave_value (m);
     }
 
   return retval;
 }
 
-static tree_constant
+static octave_value
 make_diag (const ComplexMatrix& v, int k)
 {
   int nr = v.rows ();
   int nc = v.columns ();
   assert (nc == 1 || nr == 1);
 
-  tree_constant retval;
+  octave_value retval;
 
   int roff = 0;
   int coff = 0;
@@ -368,7 +368,7 @@
       ComplexMatrix m (n, n, 0.0);
       for (int i = 0; i < nc; i++)
 	m.elem (i+roff, i+coff) = v.elem (0, i);
-      retval = tree_constant (m);
+      retval = octave_value (m);
     }
   else
     {
@@ -376,16 +376,16 @@
       ComplexMatrix m (n, n, 0.0);
       for (int i = 0; i < nr; i++)
 	m.elem (i+roff, i+coff) = v.elem (i, 0);
-      retval = tree_constant (m);
+      retval = octave_value (m);
     }
 
   return retval;
 }
 
-static tree_constant
-make_diag (const tree_constant& arg)
+static octave_value
+make_diag (const octave_value& arg)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (arg.is_real_type ())
     {
@@ -439,10 +439,10 @@
   return retval;
 }
 
-static tree_constant
-make_diag (const tree_constant& a, const tree_constant& b)
+static octave_value
+make_diag (const octave_value& a, const octave_value& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   double tmp = b.double_value ();
 
@@ -546,7 +546,7 @@
 DEFUN (diag, args, ,
   "diag (X [,k]): form/extract diagonals")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -563,13 +563,13 @@
 DEFUN (prod, args, ,
   "prod (X): products")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_real_type ())
 	{
@@ -605,7 +605,7 @@
 m = size (x, 1): return number of rows in x\n\
 m = size (x, 2): return number of columns in x")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -652,13 +652,13 @@
 DEFUN (sum, args, ,
   "sum (X): sum of elements")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_real_type ())
 	{
@@ -689,13 +689,13 @@
 DEFUN (sumsq, args, ,
   "sumsq (X): sum of squares of elements")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_real_type ())
 	{
@@ -726,13 +726,13 @@
 DEFUN (is_struct, args, ,
   "is_struct (x): return nonzero if x is a structure")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_map ())
 	retval = 1.0;
@@ -750,7 +750,7 @@
 \n\
 Return a list of the names of the elements of the structure S.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -775,7 +775,7 @@
 \n\
 return nonzero if S is a structure with element NAME")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -785,7 +785,7 @@
       if (args(0).is_map () && args(1).is_string ())
 	{
 	  string s = args(1).string_value ();
-	  tree_constant tmp = args(0).lookup_map_element (s, 0, 1);
+	  octave_value tmp = args(0).lookup_map_element (s, 0, 1);
 	  retval = (double) tmp.is_defined ();
 	}
     }
@@ -816,7 +816,7 @@
 }
 
 static void
-get_dimensions (const tree_constant& a, const char *warn_for,
+get_dimensions (const octave_value& a, const char *warn_for,
 		int& nr, int& nc)
 {
   if (a.is_scalar_type ())
@@ -847,7 +847,7 @@
 }
 
 static void
-get_dimensions (const tree_constant& a, const tree_constant& b,
+get_dimensions (const octave_value& a, const octave_value& b,
 		const char *warn_for, int& nr, int& nc)
 {
   nr = NINT (a.double_value ());
@@ -859,29 +859,29 @@
     check_dimensions (nr, nc, warn_for); // May set error_state.
 }
 
-static tree_constant
-fill_matrix (const tree_constant& a, double val, const char *warn_for)
+static octave_value
+fill_matrix (const octave_value& a, double val, const char *warn_for)
 {
   int nr, nc;
   get_dimensions (a, warn_for, nr, nc);
 
   if (error_state)
-    return  tree_constant ();
+    return  octave_value ();
 
   Matrix m (nr, nc, val);
 
   return m;
 }
 
-static tree_constant
-fill_matrix (const tree_constant& a, const tree_constant& b,
+static octave_value
+fill_matrix (const octave_value& a, const octave_value& b,
 	     double val, const char *warn_for)
 {
   int nr, nc;
   get_dimensions (a, b, warn_for, nr, nc); // May set error_state.
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   Matrix m (nr, nc, val);
 
@@ -891,7 +891,7 @@
 DEFUN (ones, args, ,
   "ones (N), ones (N, M), ones (X): create a matrix of all ones")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -920,7 +920,7 @@
 DEFUN (zeros, args, ,
   "zeros (N), zeros (N, M), zeros (X): create a matrix of all zeros")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -946,14 +946,14 @@
   return retval;
 }
 
-static tree_constant
-identity_matrix (const tree_constant& a)
+static octave_value
+identity_matrix (const octave_value& a)
 {
   int nr, nc;
   get_dimensions (a, "eye", nr, nc); // May set error_state.
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   Matrix m (nr, nc, 0.0);
 
@@ -967,14 +967,14 @@
   return m;
 }
 
-static tree_constant
-identity_matrix (const tree_constant& a, const tree_constant& b)
+static octave_value
+identity_matrix (const octave_value& a, const octave_value& b)
 {
   int nr, nc;
   get_dimensions (a, b, "eye", nr, nc);  // May set error_state.
 
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
   Matrix m (nr, nc, 0.0);
 
@@ -991,7 +991,7 @@
 DEFUN (eye, args, ,
   "eye (N), eye (N, M), eye (X): create an identity matrix")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -1029,7 +1029,7 @@
 \n\
 See also: logspace")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -1053,8 +1053,8 @@
     {
       if (npoints > 1)
 	{
-	  tree_constant arg_1 = args(0);
-	  tree_constant arg_2 = args(1);
+	  octave_value arg_1 = args(0);
+	  octave_value arg_2 = args(1);
 
 	  if (arg_1.is_complex_type () || arg_2.is_complex_type ())
 	    {
@@ -1066,7 +1066,7 @@
 		  ComplexRowVector rv = linspace (x1, x2, npoints);
 
 		  if (! error_state)
-		    retval (0) = tree_constant (rv, 0);
+		    retval (0) = octave_value (rv, 0);
 		}
 	    }
 	  else
@@ -1079,7 +1079,7 @@
 		  RowVector rv = linspace (x1, x2, npoints);
 
 		  if (! error_state)
-		    retval (0) = tree_constant (rv, 0);
+		    retval (0) = octave_value (rv, 0);
 		}
 	    }
 	}
diff --git a/src/defun-int.h b/src/defun-int.h
--- a/src/defun-int.h
+++ b/src/defun-int.h
@@ -75,7 +75,7 @@
   }
 
 #define DECLARE_FUN(name, args_name, nargout_name) \
-  Octave_object F ## name (const Octave_object& args_name, int nargout_name)
+  octave_value_list F ## name (const octave_value_list& args_name, int nargout_name)
 
 #endif
 
diff --git a/src/defun.h b/src/defun.h
--- a/src/defun.h
+++ b/src/defun.h
@@ -77,7 +77,7 @@
 #define DEFVAR_INT(name, sname, defn, inst_as_fcn, protect, sv_fcn, doc) \
   do \
     { \
-      builtin_variable sname (name, new tree_constant (defn), \
+      builtin_variable sname (name, new octave_value (defn), \
 			      inst_as_fcn, protect, (sv_fcn ? 1 : 0), \
 			      sv_fcn, doc); \
       install_builtin_variable (sname); \
@@ -88,7 +88,7 @@
 //
 //   name is the name of the function, unqouted.
 //
-//   args_name is the name of the Octave_object variable used to pass
+//   args_name is the name of the octave_value_list variable used to pass
 //     the argument list to this function.
 //
 //   nargout_name is the name of the int variable used to pass the
diff --git a/src/det.cc b/src/det.cc
--- a/src/det.cc
+++ b/src/det.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (det, args, ,
   "det (X): determinant of a square matrix")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -48,7 +48,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
     
   int nr = arg.rows ();
   int nc = arg.columns ();
diff --git a/src/dirfns.cc b/src/dirfns.cc
--- a/src/dirfns.cc
+++ b/src/dirfns.cc
@@ -313,7 +313,7 @@
 if no arguments are given, the current directory is changed to the\n\
 users home directory")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -342,7 +342,7 @@
     }
 
   string directory = get_working_directory ("cd");
-  tree_constant *dir = new tree_constant (directory);
+  octave_value *dir = new octave_value (directory);
   bind_builtin_variable ("PWD", dir, 1);
 
   return retval;
@@ -363,7 +363,7 @@
 \n\
 print a directory listing")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -410,7 +410,7 @@
 DEFUN (pwd, , nargout,
   "pwd (): print current working directory")
 {
-  Octave_object retval;
+  octave_value_list retval;
   string directory;
 
   if (verbatim_pwd)
@@ -445,7 +445,7 @@
 named directory.  If sucessful, returns 0; otherwise an error message
 is printed.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (args.length () == 1)
     {
@@ -484,7 +484,7 @@
 Create the directory named by NAME.  If successful, returns 0;\n\
 otherwise prints an error message.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int status = 0;
 
@@ -520,7 +520,7 @@
 Remove the directory named by NAME.  If successful, returns 0;\n\
 otherwise prints an error message.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int status = 0;
 
@@ -556,7 +556,7 @@
 Rename a file.  If successful, returns 0;\n\
 otherwise prints an error message and returns -1.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int status = 0;
 
diff --git a/src/dynamic-ld.h b/src/dynamic-ld.h
--- a/src/dynamic-ld.h
+++ b/src/dynamic-ld.h
@@ -25,7 +25,7 @@
 
 #include "oct-obj.h"
 
-typedef Octave_object (*Octave_builtin_fcn)(const Octave_object&, int);
+typedef octave_value_list (*Octave_builtin_fcn)(const octave_value_list&, int);
 
 extern int load_octave_oct_file (const string& name);
 
diff --git a/src/eig.cc b/src/eig.cc
--- a/src/eig.cc
+++ b/src/eig.cc
@@ -37,7 +37,7 @@
 DEFUN_DLD_BUILTIN (eig, args, nargout,
   "eig (X) or [V, D] = eig (X): compute eigenvalues and eigenvectors of X")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -47,7 +47,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int nr = arg.rows ();
   int nc = arg.columns ();
@@ -56,7 +56,7 @@
   if (arg_is_empty < 0)
     return retval;
   else if (arg_is_empty > 0)
-    return Octave_object (2, Matrix ());
+    return octave_value_list (2, Matrix ());
 
   if (nr != nc)
     {
diff --git a/src/error.cc b/src/error.cc
--- a/src/error.cc
+++ b/src/error.cc
@@ -196,18 +196,18 @@
 
 typedef void (*error_fun)(const char *, ...);
 
-extern Octave_object Fsprintf (const Octave_object&, int);
+extern octave_value_list Fsprintf (const octave_value_list&, int);
 
-static Octave_object
-handle_message (error_fun f, const char *msg, const Octave_object& args)
+static octave_value_list
+handle_message (error_fun f, const char *msg, const octave_value_list& args)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   string tstr;
 
   int nargin = args.length ();
 
-  tree_constant arg = ((nargin > 1) ? Fsprintf (args, 1) : args) (0);
+  octave_value arg = ((nargin > 1) ? Fsprintf (args, 1) : args) (0);
 
   if (arg.is_defined ())
     {
diff --git a/src/expm.cc b/src/expm.cc
--- a/src/expm.cc
+++ b/src/expm.cc
@@ -36,7 +36,7 @@
 DEFUN_DLD_BUILTIN (expm, args, ,
   "expm (X): matrix exponential, e^A")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -46,7 +46,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int nr = arg.rows ();
   int nc = arg.columns ();
diff --git a/src/fft.cc b/src/fft.cc
--- a/src/fft.cc
+++ b/src/fft.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (fft, args, ,
   "fft (X [, N]): fast fourier transform of a vector")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -48,7 +48,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int n_points = arg.rows ();
   if (n_points == 1)
diff --git a/src/fft2.cc b/src/fft2.cc
--- a/src/fft2.cc
+++ b/src/fft2.cc
@@ -40,7 +40,7 @@
 \n\
 two dimensional fast fourier transform of a vector")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -50,7 +50,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int n_rows = arg.rows ();
   if (nargin > 1)
diff --git a/src/filter.cc b/src/filter.cc
--- a/src/filter.cc
+++ b/src/filter.cc
@@ -166,7 +166,7 @@
 The particular algorithm employed is known as a transposed Direct Form II\n\
 implementation.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin  = args.length ();
 
@@ -199,7 +199,7 @@
 	      ComplexColumnVector y (filter (b, a, x));
 
 	      if (x_is_vector)
-		retval (0) = tree_constant (y, (args(2).columns () == 1));
+		retval (0) = octave_value (y, (args(2).columns () == 1));
 	      else
 		retval (0) = y;
 	    }
@@ -212,12 +212,12 @@
 		  ComplexColumnVector y (filter (b, a, x, si));
 
 		  if (si_is_vector)
-		    retval (1) = tree_constant (si, (args(3).columns () == 1));
+		    retval (1) = octave_value (si, (args(3).columns () == 1));
 		  else
 		    retval (1) = si;
 
 		  if (x_is_vector)
-		    retval (0) = tree_constant (y, (args(2).columns () == 1));
+		    retval (0) = octave_value (y, (args(2).columns () == 1));
 		  else
 		    retval (0) = y;
 		}
@@ -241,7 +241,7 @@
 	      ColumnVector y (filter (b, a, x));
 
 	      if (x_is_vector)
-		retval (0) = tree_constant (y, (args(2).columns () == 1));
+		retval (0) = octave_value (y, (args(2).columns () == 1));
 	      else
 		retval (0) = y;
 	    }
@@ -254,12 +254,12 @@
 		  ColumnVector y (filter (b, a, x, si));
 
 		  if (si_is_vector)
-		    retval (1) = tree_constant (si, (args(3).columns () == 1));
+		    retval (1) = octave_value (si, (args(3).columns () == 1));
 		  else
 		    retval (1) = si;
 
 		  if (x_is_vector)
-		    retval (0) = tree_constant (y, (args(2).columns () == 1));
+		    retval (0) = octave_value (y, (args(2).columns () == 1));
 		  else
 		    retval (0) = y;
 		}
diff --git a/src/find.cc b/src/find.cc
--- a/src/find.cc
+++ b/src/find.cc
@@ -30,11 +30,11 @@
 #include "help.h"
 #include "oct-obj.h"
 
-static Octave_object
+static octave_value_list
 find_to_fortran_idx (const ColumnVector i_idx, const ColumnVector j_idx,
-		     const tree_constant& val, int nr, int nargout)
+		     const octave_value& val, int nr, int nargout)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   switch (nargout)
     {
@@ -49,7 +49,7 @@
 	// If the original argument was a row vector, force a row
 	// vector of indices to be returned.
 
-	retval(0) = tree_constant (tmp, (nr != 1));
+	retval(0) = octave_value (tmp, (nr != 1));
       }
       break;
 
@@ -58,12 +58,12 @@
       // Fall through!
 
     case 2:
-      retval(1) = tree_constant (j_idx, 1);
-      retval(0) = tree_constant (i_idx, 1);
+      retval(1) = octave_value (j_idx, 1);
+      retval(0) = octave_value (i_idx, 1);
 
       // If you want this to work more like Matlab, use
       //
-      //    retval(0) = tree_constant (i_idx, (nr != 1));
+      //    retval(0) = octave_value (i_idx, (nr != 1));
       //
       // instead of the previous statement.
 
@@ -77,7 +77,7 @@
   return retval;
 }
 
-static Octave_object
+static octave_value_list
 find_nonzero_elem_idx (const Matrix& m, int nargout)
 {
   int count = 0;
@@ -90,7 +90,7 @@
       if (m.elem (i, j) != 0.0)
 	count++;
 
-  Octave_object retval (((nargout == 0) ? 1 : nargout), Matrix ());
+  octave_value_list retval (((nargout == 0) ? 1 : nargout), Matrix ());
 
   if (count == 0)
     return retval;
@@ -113,11 +113,11 @@
 	  }
       }
 
-  tree_constant tmp (v, 1);
+  octave_value tmp (v, 1);
   return find_to_fortran_idx (i_idx, j_idx, tmp, m_nr, nargout);
 }
 
-static Octave_object
+static octave_value_list
 find_nonzero_elem_idx (const ComplexMatrix& m, int nargout)
 {
   int count = 0;
@@ -130,7 +130,7 @@
       if (m.elem (i, j) != 0.0)
 	count++;
 
-  Octave_object retval (((nargout == 0) ? 1 : nargout), Matrix ());
+  octave_value_list retval (((nargout == 0) ? 1 : nargout), Matrix ());
 
   if (count == 0)
     return retval;
@@ -153,14 +153,14 @@
 	  }
       }
 
-  tree_constant tmp (v, 1);
+  octave_value tmp (v, 1);
   return find_to_fortran_idx (i_idx, j_idx, tmp, m_nr, nargout);
 }
 
 DEFUN_DLD_BUILTIN (find, args, nargout,
   "find (X) or [I, J, V] = find (X): Return indices of nonzero elements")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -170,7 +170,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   if (arg.is_real_type ())
     {
diff --git a/src/fsolve.cc b/src/fsolve.cc
--- a/src/fsolve.cc
+++ b/src/fsolve.cc
@@ -85,7 +85,7 @@
 
   int n = x.capacity ();
 
-  Octave_object args;
+  octave_value_list args;
   args.resize (1);
 
   if (n > 1)
@@ -93,19 +93,19 @@
       Matrix m (n, 1);
       for (int i = 0; i < n; i++)
 	m (i, 0) = x.elem (i);
-      tree_constant vars (m);
+      octave_value vars (m);
       args(0) = vars;
     }
   else
     {
       double d = x.elem (0);
-      tree_constant vars (d);
+      octave_value vars (d);
       args(0) = vars;
     }
 
   if (fsolve_fcn)
     {
-      Octave_object tmp = fsolve_fcn->eval (0, 1, args);
+      octave_value_list tmp = fsolve_fcn->eval (0, 1, args);
       if (tmp.length () > 0 && tmp(0).is_defined ())
 	{
 	  retval = tmp(0).vector_value ();
@@ -132,7 +132,7 @@
 \n\
 where y and x are vectors.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -260,10 +260,10 @@
   warning ("fsolve_options: no match for `%s'", keyword.c_str ());
 }
 
-static Octave_object
+static octave_value_list
 show_fsolve_option (const string& keyword)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   NLEQN_OPTIONS *list = fsolve_option_table;
 
@@ -288,7 +288,7 @@
 Set or show options for fsolve.  Keywords may be abbreviated\n\
 to the shortest match.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/fsqp.cc b/src/fsqp.cc
--- a/src/fsqp.cc
+++ b/src/fsqp.cc
@@ -80,7 +80,7 @@
 
 */
 
-  Octave_object retval;
+  octave_value_list retval;
 
   error ("fsqp: not implemented yet");
 
@@ -100,7 +100,7 @@
 to the shortest match.")
 #endif
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   error ("fsqp_options: not implemented yet");
 
diff --git a/src/givens.cc b/src/givens.cc
--- a/src/givens.cc
+++ b/src/givens.cc
@@ -39,7 +39,7 @@
 \n\
 [c, s] = givens (x, y) returns the (c, s) values themselves.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/gripes.cc b/src/gripes.cc
--- a/src/gripes.cc
+++ b/src/gripes.cc
@@ -123,19 +123,19 @@
 }
 
 void
-gripe_wrong_type_arg (const char *name, const tree_constant& tc)
+gripe_wrong_type_arg (const char *name, const octave_value& tc)
 {
   error ("%s: wrong type argument `%s'", name, tc.type_as_string ());
 }
 
 void
-gripe_wrong_type_arg_for_unary_op (const tree_constant& op)
+gripe_wrong_type_arg_for_unary_op (const octave_value& op)
 {
   error ("invalid operand `%s' for unary operator", op.type_as_string ());
 }
 
 void
-gripe_wrong_type_arg_for_binary_op (const tree_constant& op)
+gripe_wrong_type_arg_for_binary_op (const octave_value& op)
 {
   error ("invalid operand `%s' for binary operator", op.type_as_string ());
 }
diff --git a/src/gripes.h b/src/gripes.h
--- a/src/gripes.h
+++ b/src/gripes.h
@@ -23,7 +23,7 @@
 #if !defined (octave_gripes_h)
 #define octave_gripes_h 1
 
-class tree_constant;
+class octave_value;
 
 extern void gripe_not_supported (void);
 extern void gripe_string_invalid (void);
@@ -40,9 +40,9 @@
 extern void gripe_unrecognized_float_fmt (void);
 extern void gripe_unrecognized_data_fmt (const char *warn_for);
 extern void gripe_data_conversion (const char *from, const char *to);
-extern void gripe_wrong_type_arg (const char *name, const tree_constant& tc);
-extern void gripe_wrong_type_arg_for_unary_op (const tree_constant& op);
-extern void gripe_wrong_type_arg_for_binary_op (const tree_constant& op);
+extern void gripe_wrong_type_arg (const char *name, const octave_value& tc);
+extern void gripe_wrong_type_arg_for_unary_op (const octave_value& op);
+extern void gripe_wrong_type_arg_for_binary_op (const octave_value& op);
 
 #endif
 
diff --git a/src/help.cc b/src/help.cc
--- a/src/help.cc
+++ b/src/help.cc
@@ -677,7 +677,7 @@
 print cryptic yet witty messages")
 #endif
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -710,7 +710,7 @@
 \n\
 display the definition of each NAME that refers to a function")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   begin_unwind_frame ("Ftype");
 
@@ -782,14 +782,14 @@
 
 		  assert (defn && defn->is_constant ());
 
-		  tree_constant *tmp = (tree_constant *) defn;
+		  octave_value *tmp = (octave_value *) defn;
 
 		  int var_ok = 1;
 		  if (tmp && tmp->is_map ())
 		    {
 		      if (! elts.empty ())
 			{
-			  tree_constant ult =
+			  octave_value ult =
 			    tmp->lookup_map_element (elts, 0, 1);
 
 			  if (! ult.is_defined ())
@@ -857,7 +857,7 @@
 display the type of each NAME.  If NAME is defined from an function\n\
 file, print the full name of the file.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/hess.cc b/src/hess.cc
--- a/src/hess.cc
+++ b/src/hess.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (hess, args, nargout,
   "[P, H] = hess (A) or H = hess (A): Hessenberg decomposition")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -48,7 +48,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int nr = arg.rows ();
   int nc = arg.columns ();
@@ -58,7 +58,7 @@
   if (arg_is_empty < 0)
     return retval;
   else if (arg_is_empty > 0)
-    return Octave_object (2, Matrix ());
+    return octave_value_list (2, Matrix ());
 
   if (nr != nc)
     {
diff --git a/src/ifft.cc b/src/ifft.cc
--- a/src/ifft.cc
+++ b/src/ifft.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (ifft, args, ,
   "ifft (X [, N]): inverse fast fourier transform of a vector")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -48,7 +48,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
     
   int n_points = arg.rows ();
   if (n_points == 1)
diff --git a/src/ifft2.cc b/src/ifft2.cc
--- a/src/ifft2.cc
+++ b/src/ifft2.cc
@@ -40,7 +40,7 @@
 \n\
 two dimensional inverse fast fourier transform of a vector") 
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -50,7 +50,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int n_rows = arg.rows ();
   if (nargin > 1)
diff --git a/src/input.cc b/src/input.cc
--- a/src/input.cc
+++ b/src/input.cc
@@ -661,9 +661,9 @@
     {
       tree_fvc *tmp_fvc = sr->def ();
 
-      tree_constant *def = 0;
+      octave_value *def = 0;
       if (tmp_fvc->is_constant ())
-	def = (tree_constant *) tmp_fvc;
+	def = (octave_value *) tmp_fvc;
 
       if (def && def->is_map ())
 	{
@@ -671,7 +671,7 @@
 
 	  if (elts && *elts)
 	    {
-	      tree_constant ult = def->lookup_map_element (elts, 0, 1);
+	      octave_value ult = def->lookup_map_element (elts, 0, 1);
 
 	      if (ult.is_map ())
 		{
@@ -756,15 +756,15 @@
     {
       tree_fvc *tmp_fvc = sr->def ();
 
-      tree_constant *def = 0;
+      octave_value *def = 0;
       if (tmp_fvc->is_constant ())
-	def = (tree_constant *) tmp_fvc;
+	def = (octave_value *) tmp_fvc;
 
       if (def && def->is_map ())
 	{
 	  if (elts && *elts)
 	    {
-	      tree_constant ult = def->lookup_map_element (elts, 0, 1);
+	      octave_value ult = def->lookup_map_element (elts, 0, 1);
 
 	      if (ult.is_map ())
 		retval = 1;
@@ -1003,10 +1003,10 @@
 
 // If the user simply hits return, this will produce an empty matrix.
 
-static Octave_object
-get_user_input (const Octave_object& args, int debug = 0)
+static octave_value_list
+get_user_input (const octave_value_list& args, int debug = 0)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nargin = args.length ();
 
@@ -1092,7 +1092,7 @@
 Prompt user for input.  If the second argument is present, return
 value as a string.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -1109,7 +1109,7 @@
 \n\
 maybe help in debugging function files")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -1132,7 +1132,7 @@
 \n\
 Without any arguments, toggle the current echo state.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/inv.cc b/src/inv.cc
--- a/src/inv.cc
+++ b/src/inv.cc
@@ -35,7 +35,7 @@
 DEFUN_DLD_BUILTIN (inv, args, ,
   "inv (X): inverse of a square matrix")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -45,7 +45,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int nr = arg.rows ();
   int nc = arg.columns ();
diff --git a/src/load-save.cc b/src/load-save.cc
--- a/src/load-save.cc
+++ b/src/load-save.cc
@@ -79,7 +79,7 @@
 // Assumes TC is defined.
 
 static void
-install_loaded_variable (int force, char *name, const tree_constant& tc,
+install_loaded_variable (int force, char *name, const octave_value& tc,
 			 int global, char *doc)
 {
   // Is there already a symbol by this name?  If so, what is it?
@@ -197,7 +197,7 @@
 
   if (sr)
     {
-      tree_constant *tmp_tc = new tree_constant (tc);
+      octave_value *tmp_tc = new octave_value (tc);
       sr->define (tmp_tc);
       if (doc)
 	sr->document (doc);
@@ -435,7 +435,7 @@
 
 static char *
 read_ascii_data (istream& is, const string& filename, int& global,
-		 tree_constant& tc)
+		 octave_value& tc)
 {
   // Read name for this entry or break on EOF.
 
@@ -699,7 +699,7 @@
 static char *
 read_binary_data (istream& is, int swap, floating_point_format fmt,
 		  const string& filename, int& global,
-		  tree_constant& tc, char *&doc)
+		  octave_value& tc, char *&doc)
 {
   char tmp = 0;
 
@@ -1057,7 +1057,7 @@
 
 static char *
 read_mat_binary_data (istream& is, const string& filename,
-		      tree_constant& tc)
+		      octave_value& tc)
 {
   // These are initialized here instead of closer to where they are
   // first used to avoid errors from gcc about goto crossing
@@ -1256,20 +1256,20 @@
   return retval;
 }
 
-static Octave_object
+static octave_value_list
 do_load (istream& stream, const string& orig_fname, int force,
 	 load_save_format format, floating_point_format flt_fmt,
 	 int list_only, int swap, int verbose, const string_vector& argv,
 	 int argv_idx, int argc, int nargout)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   ostrstream output_buf;
   int count = 0;
   for (;;)
     {
       int global = 0;
-      tree_constant tc;
+      octave_value tc;
 
       char *name = 0;
       char *doc = 0;
@@ -1376,7 +1376,7 @@
 If the option -force is given, variables with the same names as those
 found in the file will be replaced with the values read from the file.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -1569,7 +1569,7 @@
 // binary format described above for read_binary_data.
 
 static int
-save_binary_data (ostream& os, const tree_constant& tc,
+save_binary_data (ostream& os, const octave_value& tc,
 		  const string& name, const string& doc,
 		  int mark_as_global, int save_as_floats) 
 {
@@ -1711,7 +1711,7 @@
 // in the MatLab binary format.
 
 static int
-save_mat_binary_data (ostream& os, const tree_constant& tc,
+save_mat_binary_data (ostream& os, const octave_value& tc,
 		      const string& name) 
 {
   int fail = 0;
@@ -1889,7 +1889,7 @@
 // XXX FIXME XXX -- should probably write the help string here too.
 
 int
-save_ascii_data (ostream& os, const tree_constant& tc,
+save_ascii_data (ostream& os, const octave_value& tc,
 		 const string& name, int strip_nan_and_inf,
 		 int mark_as_global, int precision) 
 {
@@ -2028,7 +2028,7 @@
   string name = sr->name ();
   string help = sr->help ();
   int global = sr->is_linked_to_global ();
-  tree_constant tc = *((tree_constant *) sr->def ());
+  octave_value tc = *((octave_value *) sr->def ());
 
   if (tc.is_undefined ())
     return;
@@ -2183,7 +2183,7 @@
 \n\
 save variables in a file")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -2246,7 +2246,7 @@
       i++;
 
       // XXX FIXME XXX -- should things intended for the screen end up
-      // in a tree_constant (string)?
+      // in a octave_value (string)?
 
       ostrstream buf;
 
@@ -2297,7 +2297,7 @@
 // nonzero, assume a parametric 3-dimensional plot will be generated.
 
 int
-save_three_d (ostream& os, const tree_constant& tc, int parametric)
+save_three_d (ostream& os, const octave_value& tc, int parametric)
 {
   int fail = 0;
 
diff --git a/src/load-save.h b/src/load-save.h
--- a/src/load-save.h
+++ b/src/load-save.h
@@ -25,16 +25,16 @@
 
 class ostream;
 
-class tree_constant;
+class octave_value;
 
 #include <string>
 
-extern int save_ascii_data (ostream& os, const tree_constant& t,
+extern int save_ascii_data (ostream& os, const octave_value& t,
 			    const string& name = string (),
 			    int strip_nan_and_inf = 0,
 			    int mark_as_global = 0, int precision = 0);
 
-extern int save_three_d (ostream& os, const tree_constant& t,
+extern int save_three_d (ostream& os, const octave_value& t,
 			 int parametric = 0);
 
 extern void save_user_variables (void);
diff --git a/src/log.cc b/src/log.cc
--- a/src/log.cc
+++ b/src/log.cc
@@ -40,7 +40,7 @@
 DEFUN_DLD_BUILTIN (logm, args, ,
   "logm (X): matrix logarithm")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -50,7 +50,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int arg_is_empty = empty_arg ("logm", arg.rows (), arg.columns ());
 
@@ -152,7 +152,7 @@
 DEFUN_DLD_BUILTIN (sqrtm, args, ,
  "sqrtm (X): matrix sqrt")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -162,7 +162,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int arg_is_empty = empty_arg ("sqrtm", arg.rows (), arg.columns ());
 
diff --git a/src/lpsolve.cc b/src/lpsolve.cc
--- a/src/lpsolve.cc
+++ b/src/lpsolve.cc
@@ -34,7 +34,7 @@
 DEFUN_DLD_BUILTIN (lp_solve, , ,
   "lp_solve (): solve linear programs using lp_solve.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   // Force a bad value of inform, and empty matrices for x and phi.
 
@@ -54,7 +54,7 @@
 Set or show options for lp_solve.  Keywords may be abbreviated\n\
 to the shortest match.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   error ("lp_solve_options: not implemented yet");
 
diff --git a/src/lsode.cc b/src/lsode.cc
--- a/src/lsode.cc
+++ b/src/lsode.cc
@@ -51,7 +51,7 @@
 
   int nstates = x.capacity ();
 
-  Octave_object args;
+  octave_value_list args;
   args(1) = t;
 
   if (nstates > 1)
@@ -59,19 +59,19 @@
       Matrix m (nstates, 1);
       for (int i = 0; i < nstates; i++)
 	m (i, 0) = x.elem (i);
-      tree_constant state (m);
+      octave_value state (m);
       args(0) = state;
     }
   else
     {
       double d = x.elem (0);
-      tree_constant state (d);
+      octave_value state (d);
       args(0) = state;
     }
 
   if (lsode_fcn)
     {
-      Octave_object tmp = lsode_fcn->eval (0, 1, args);
+      octave_value_list tmp = lsode_fcn->eval (0, 1, args);
 
       if (error_state)
 	{
@@ -103,7 +103,7 @@
 \n\
 where xdot and x are vectors and t is a scalar.\n")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -275,10 +275,10 @@
   warning ("lsode_options: no match for `%s'", keyword.c_str ());
 }
 
-static Octave_object
+static octave_value_list
 show_lsode_option (const string& keyword)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   LSODE_OPTIONS *list = lsode_option_table;
 
@@ -303,7 +303,7 @@
 Set or show options for lsode.  Keywords may be abbreviated\n\
 to the shortest match.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/lu.cc b/src/lu.cc
--- a/src/lu.cc
+++ b/src/lu.cc
@@ -38,7 +38,7 @@
 DEFUN_DLD_BUILTIN (lu, args, nargout,
   "[L, U, P] = lu (A): LU factorization")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -48,7 +48,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int nr = arg.rows ();
   int nc = arg.columns ();
@@ -58,7 +58,7 @@
   if (arg_is_empty < 0)
     return retval;
   else if (arg_is_empty > 0)
-    return Octave_object (3, Matrix ());
+    return octave_value_list (3, Matrix ());
 
   if (nr != nc)
     {
diff --git a/src/minmax.cc b/src/minmax.cc
--- a/src/minmax.cc
+++ b/src/minmax.cc
@@ -364,7 +364,7 @@
 DEFUN_DLD_BUILTIN (min, args, nargout,
   "min (X): minimum value(s) of a vector (matrix)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -374,8 +374,8 @@
       return retval;
     }
 
-  tree_constant arg1;
-  tree_constant arg2;
+  octave_value arg1;
+  octave_value arg2;
 
   switch (nargin)
     {
@@ -411,7 +411,7 @@
 	      if (m.rows () == 1)
 		retval(0) = m.row_min ();
 	      else
-		retval(0) = tree_constant (m.column_min (), 0);
+		retval(0) = octave_value (m.column_min (), 0);
 	    }
 	}
       else if (arg1.is_complex_type ())
@@ -423,7 +423,7 @@
 	      if (m.rows () == 1)
 		retval(0) = m.row_min ();
 	      else
-		retval(0) = tree_constant (m.column_min (), 0);
+		retval(0) = octave_value (m.column_min (), 0);
 	    }
 	}
       else
@@ -457,8 +457,8 @@
 		}
 	      else
 		{
-		  retval(1) = tree_constant (m.column_min_loc (), 0);
-		  retval(0) = tree_constant (m.column_min (), 0);
+		  retval(1) = octave_value (m.column_min_loc (), 0);
+		  retval(0) = octave_value (m.column_min (), 0);
 		}
 	    }
 	}
@@ -475,8 +475,8 @@
 		}
 	      else
 		{
-		  retval(1) = tree_constant (m.column_min_loc (), 0);
-		  retval(0) = tree_constant (m.column_min (), 0);
+		  retval(1) = octave_value (m.column_min_loc (), 0);
+		  retval(0) = octave_value (m.column_min (), 0);
 		}
 	    }
 	}
@@ -592,7 +592,7 @@
 DEFUN_DLD_BUILTIN (max, args, nargout,
   "max (X): maximum value(s) of a vector (matrix)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -602,8 +602,8 @@
       return retval;
     }
 
-  tree_constant arg1;
-  tree_constant arg2;
+  octave_value arg1;
+  octave_value arg2;
 
   switch (nargin)
     {
@@ -639,7 +639,7 @@
 	      if (m.rows () == 1)
 		retval(0) = m.row_max ();
 	      else
-		retval(0) = tree_constant (m.column_max (), 0);
+		retval(0) = octave_value (m.column_max (), 0);
 	    }
 	}
       else if (arg1.is_complex_type ())
@@ -651,7 +651,7 @@
 	      if (m.rows () == 1)
 		retval(0) = m.row_max ();
 	      else
-		retval(0) = tree_constant (m.column_max (), 0);
+		retval(0) = octave_value (m.column_max (), 0);
 	    }
 	}
       else
@@ -685,8 +685,8 @@
 		}
 	      else
 		{
-		  retval(1) = tree_constant (m.column_max_loc (), 0);
-		  retval(0) = tree_constant (m.column_max (), 0);
+		  retval(1) = octave_value (m.column_max_loc (), 0);
+		  retval(0) = octave_value (m.column_max (), 0);
 		}
 	    }
 	}
@@ -703,8 +703,8 @@
 		}
 	      else
 		{
-		  retval(1) = tree_constant (m.column_max_loc (), 0);
-		  retval(0) = tree_constant (m.column_max (), 0);
+		  retval(1) = octave_value (m.column_max_loc (), 0);
+		  retval(0) = octave_value (m.column_max (), 0);
 		}
 	    }
 	}
diff --git a/src/npsol.cc b/src/npsol.cc
--- a/src/npsol.cc
+++ b/src/npsol.cc
@@ -53,7 +53,7 @@
 {
   int n = x.capacity ();
 
-  tree_constant decision_vars;
+  octave_value decision_vars;
   if (n > 1)
     {
       Matrix m (n, 1);
@@ -67,16 +67,16 @@
       decision_vars = d;
     }
 
-  Octave_object args;
+  octave_value_list args;
   args(0) = decision_vars;
 
   static double retval;
   retval = 0.0;
 
-  tree_constant objective_value;
+  octave_value objective_value;
   if (npsol_objective)
     {
-      Octave_object tmp = npsol_objective->eval (0, 1, args);
+      octave_value_list tmp = npsol_objective->eval (0, 1, args);
 
       if (error_state)
 	{
@@ -126,7 +126,7 @@
 
   int n = x.capacity ();
 
-  tree_constant decision_vars;
+  octave_value decision_vars;
   if (n > 1)
     {
       Matrix m (n, 1);
@@ -140,12 +140,12 @@
       decision_vars = d;
     }
 
-  Octave_object args;
+  octave_value_list args;
   args(0) = decision_vars;
 
   if (npsol_constraints)
     {
-      Octave_object tmp = npsol_constraints->eval (0, 1, args);
+      octave_value_list tmp = npsol_constraints->eval (0, 1, args);
 
       if (error_state)
 	{
@@ -272,7 +272,7 @@
 
 */
 
-  Octave_object retval;
+  octave_value_list retval;
 
 #if defined (NPSOL_MISSING)
 
@@ -744,10 +744,10 @@
   warning ("npsol_options: no match for `%s'", keyword.c_str ());
 }
 
-static Octave_object
+static octave_value_list
 show_npsol_option (const string& keyword)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   NPSOL_OPTIONS *list = npsol_option_table;
 
@@ -784,7 +784,7 @@
 to the shortest match.")
 #endif
 {
-  Octave_object retval;
+  octave_value_list retval;
 
 #if defined (NPSOL_MISSING)
 
diff --git a/src/oct-hist.cc b/src/oct-hist.cc
--- a/src/oct-hist.cc
+++ b/src/oct-hist.cc
@@ -521,7 +521,7 @@
 \n\
 edit commands from the history list")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -540,7 +540,7 @@
 \n\
 display, save, or load command history")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -559,7 +559,7 @@
 \n\
 run commands from the history list")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/oct-map.h b/src/oct-map.h
--- a/src/oct-map.h
+++ b/src/oct-map.h
@@ -34,18 +34,18 @@
 class string_vector;
 
 class
-Octave_map : public CHMap<tree_constant>
+Octave_map : public CHMap<octave_value>
 {
  public:
-  Octave_map (void) : CHMap<tree_constant> (tree_constant ()) { }
+  Octave_map (void) : CHMap<octave_value> (octave_value ()) { }
 
-  Octave_map (const string& key, const tree_constant& value)
-    : CHMap<tree_constant> (tree_constant ())
+  Octave_map (const string& key, const octave_value& value)
+    : CHMap<octave_value> (octave_value ())
       {
-	CHMap<tree_constant>::operator [] (key) = value;
+	CHMap<octave_value>::operator [] (key) = value;
       }
 
-  Octave_map (const Octave_map& m) : CHMap<tree_constant> (m) { }
+  Octave_map (const Octave_map& m) : CHMap<octave_value> (m) { }
 
   ~Octave_map (void) { }
 
diff --git a/src/oct-obj.cc b/src/oct-obj.cc
--- a/src/oct-obj.cc
+++ b/src/oct-obj.cc
@@ -32,7 +32,7 @@
 #include "oct-obj.h"
 
 int
-Octave_object::all_strings (void) const
+octave_value_list::all_strings (void) const
 {
   int n = length ();
 
@@ -44,7 +44,7 @@
 }
 
 string_vector
-Octave_object::make_argv (const string& fcn_name) const
+octave_value_list::make_argv (const string& fcn_name) const
 {
   string_vector argv;
 
diff --git a/src/oct-obj.h b/src/oct-obj.h
--- a/src/oct-obj.h
+++ b/src/oct-obj.h
@@ -38,80 +38,80 @@
 #include "pt-const.h"
 
 class
-Octave_object : public Array<tree_constant>
+octave_value_list : public Array<octave_value>
 {
 public:
 
-  Octave_object (void)
-    : Array<tree_constant> () { }
+  octave_value_list (void)
+    : Array<octave_value> () { }
 
-  Octave_object (int n, const tree_constant& val)
-    : Array<tree_constant> (n, val) { }
+  octave_value_list (int n, const octave_value& val)
+    : Array<octave_value> (n, val) { }
 
-  Octave_object (const tree_constant& tc)
-    : Array<tree_constant> (1, tc) { }
+  octave_value_list (const octave_value& tc)
+    : Array<octave_value> (1, tc) { }
 
-  Octave_object (double d)
-    : Array<tree_constant> (1, tree_constant (d)) { }
+  octave_value_list (double d)
+    : Array<octave_value> (1, octave_value (d)) { }
 
-  Octave_object (const Matrix& m)
-    : Array<tree_constant> (1, tree_constant (m)) { }
+  octave_value_list (const Matrix& m)
+    : Array<octave_value> (1, octave_value (m)) { }
 
-  Octave_object (const DiagMatrix& d)
-    : Array<tree_constant> (1, tree_constant (d)) { }
+  octave_value_list (const DiagMatrix& d)
+    : Array<octave_value> (1, octave_value (d)) { }
 
-  Octave_object (const RowVector& v, int pcv)
-    : Array<tree_constant> (1, tree_constant (v, pcv)) { }
+  octave_value_list (const RowVector& v, int pcv)
+    : Array<octave_value> (1, octave_value (v, pcv)) { }
 
-  Octave_object (const ColumnVector& v, int pcv)
-    : Array<tree_constant> (1, tree_constant (v, pcv)) { }
+  octave_value_list (const ColumnVector& v, int pcv)
+    : Array<octave_value> (1, octave_value (v, pcv)) { }
 
-  Octave_object (const Complex& c)
-    : Array<tree_constant> (1, tree_constant (c)) { }
+  octave_value_list (const Complex& c)
+    : Array<octave_value> (1, octave_value (c)) { }
 
-  Octave_object (const ComplexMatrix& m)
-    : Array<tree_constant> (1, tree_constant (m)) { }
+  octave_value_list (const ComplexMatrix& m)
+    : Array<octave_value> (1, octave_value (m)) { }
 
-  Octave_object (const ComplexDiagMatrix& d)
-    : Array<tree_constant> (1, tree_constant (d)) { }
+  octave_value_list (const ComplexDiagMatrix& d)
+    : Array<octave_value> (1, octave_value (d)) { }
 
-  Octave_object (const ComplexRowVector& v, int pcv)
-    : Array<tree_constant> (1, tree_constant (v, pcv)) { }
+  octave_value_list (const ComplexRowVector& v, int pcv)
+    : Array<octave_value> (1, octave_value (v, pcv)) { }
 
-  Octave_object (const ComplexColumnVector& v, int pcv)
-    : Array<tree_constant> (1, tree_constant (v, pcv)) { }
+  octave_value_list (const ComplexColumnVector& v, int pcv)
+    : Array<octave_value> (1, octave_value (v, pcv)) { }
 
-  Octave_object (const char *s)
-    : Array<tree_constant> (1, tree_constant (s)) { }
+  octave_value_list (const char *s)
+    : Array<octave_value> (1, octave_value (s)) { }
 
-  Octave_object (const string& s)
-    : Array<tree_constant> (1, tree_constant (s)) { }
+  octave_value_list (const string& s)
+    : Array<octave_value> (1, octave_value (s)) { }
 
-  Octave_object (const string_vector& s)
-    : Array<tree_constant> (1, tree_constant (s)) { }
+  octave_value_list (const string_vector& s)
+    : Array<octave_value> (1, octave_value (s)) { }
 
-  Octave_object (double base, double limit, double inc)
-    : Array<tree_constant> (1, tree_constant (base, limit, inc)) { }
+  octave_value_list (double base, double limit, double inc)
+    : Array<octave_value> (1, octave_value (base, limit, inc)) { }
 
-  Octave_object (const Range& r)
-    : Array<tree_constant> (1, tree_constant (r)) { }
+  octave_value_list (const Range& r)
+    : Array<octave_value> (1, octave_value (r)) { }
 
-  Octave_object (const Octave_object& obj)
-    : Array<tree_constant> (obj) { }
+  octave_value_list (const octave_value_list& obj)
+    : Array<octave_value> (obj) { }
 
-  Octave_object& operator = (const Octave_object& obj)
+  octave_value_list& operator = (const octave_value_list& obj)
     {
       if (this != &obj)
-	Array<tree_constant>::operator = (obj);
+	Array<octave_value>::operator = (obj);
 
       return *this;
     }
 
 // Assignment will resize on range errors.
 
-  tree_constant& operator () (int n) { return elem (n); }
+  octave_value& operator () (int n) { return elem (n); }
 
-  tree_constant operator () (int n) const { return elem (n); }
+  octave_value operator () (int n) const { return elem (n); }
 
   int all_strings (void) const;
 
@@ -122,17 +122,17 @@
 // This constructor is private with no definition to keep statements
 // like
 //
-//   Octave_object foo = 5;
-//   Octave_object foo = 5.0;
+//   octave_value_list foo = 5;
+//   octave_value_list foo = 5.0;
 //
 // from doing different things.  Instead, you have to use the
 // constructor
 //
-//   Octave_object (n, val);
+//   octave_value_list (n, val);
 //
-// and supply a default value to create a vector-valued Octave_object.
+// and supply a default value to create a vector-valued octave_value_list.
 
-  Octave_object (int n);
+  octave_value_list (int n);
 
   void maybe_resize (int n)
     {
@@ -140,22 +140,22 @@
 	resize (n + 1, Matrix ());
     }
 
-  tree_constant& elem (int n)
+  octave_value& elem (int n)
     {
       maybe_resize (n);
-      return Array<tree_constant>::elem (n);
+      return Array<octave_value>::elem (n);
     }
 
-  tree_constant& checkelem (int n);
+  octave_value& checkelem (int n);
 
-  tree_constant& xelem (int n);
+  octave_value& xelem (int n);
 
-  tree_constant elem (int n) const
+  octave_value elem (int n) const
     {
-      return Array<tree_constant>::operator () (n);
+      return Array<octave_value>::operator () (n);
     }
 
-  tree_constant checkelem (int n) const;
+  octave_value checkelem (int n) const;
 };
 
 #endif
diff --git a/src/pager.cc b/src/pager.cc
--- a/src/pager.cc
+++ b/src/pager.cc
@@ -204,7 +204,7 @@
 \n\
 redirect all input and screen output to a file.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -256,7 +256,7 @@
 \n\
 Turn output pagination on or off.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/parse.y b/src/parse.y
--- a/src/parse.y
+++ b/src/parse.y
@@ -97,7 +97,7 @@
 static tree_expression *finish_colon_expression (tree_colon_expression *e);
 
 // Build a constant.
-static tree_constant *make_constant (int op, token *tok_val);
+static octave_value *make_constant (int op, token *tok_val);
 
 // Build a binary expression.
 static tree_expression *make_binary_op
@@ -221,7 +221,7 @@
   tree_matrix *tree_matrix_type;
   tree_matrix_row *tree_matrix_row_type;
   tree_expression *tree_expression_type;
-  tree_constant *tree_constant_type;
+  octave_value *octave_value_type;
   tree_identifier *tree_identifier_type;
   tree_indirect_ref *tree_indirect_ref_type;
   tree_function *tree_function_type;
@@ -773,9 +773,9 @@
 		| matrix
 		  { $$ = $1; }
 		| '[' ']'
-		  { $$ = new tree_constant (Matrix ()); }
+		  { $$ = new octave_value (Matrix ()); }
 		| '[' ';' ']'
-		  { $$ = new tree_constant (Matrix ()); }
+		  { $$ = new octave_value (Matrix ()); }
 		| colon_expr
 		  { $$ = finish_colon_expression ($1); }
 		| PLUS_PLUS identifier %prec UNARY
@@ -870,12 +870,12 @@
 
 word_list	: TEXT
 		  {
-		    tree_constant *tmp = make_constant (TEXT, $1);
+		    octave_value *tmp = make_constant (TEXT, $1);
 		    $$ = new tree_argument_list (tmp);
 		  }
 		| word_list TEXT
 		  {
-		    tree_constant *tmp = make_constant (TEXT, $2);
+		    octave_value *tmp = make_constant (TEXT, $2);
 		    $1->append (tmp);
 		    $$ = $1;
 		  }
@@ -1070,25 +1070,25 @@
 
 arg_list	: ':'
 		  {
-		    tree_constant *colon;
-		    tree_constant::magic_colon t;
-		    colon = new tree_constant (t);
+		    octave_value *colon;
+		    octave_value::magic_colon t;
+		    colon = new octave_value (t);
 		    $$ = new tree_argument_list (colon);
 		  }
 		| expression
 		  { $$ = new tree_argument_list ($1); }
 		| ALL_VA_ARGS
 		  {
-		    tree_constant *all_va_args;
-		    tree_constant::all_va_args t;
-		    all_va_args = new tree_constant (t);
+		    octave_value *all_va_args;
+		    octave_value::all_va_args t;
+		    all_va_args = new octave_value (t);
 		    $$ = new tree_argument_list (all_va_args);
 		  }
 		| arg_list ',' ':'
 		  {
-		    tree_constant *colon;
-		    tree_constant::magic_colon t;
-		    colon = new tree_constant (t);
+		    octave_value *colon;
+		    octave_value::magic_colon t;
+		    colon = new octave_value (t);
 		    $1->append (colon);
 		    $$ = $1;
 		  }
@@ -1099,9 +1099,9 @@
 		  }
 		| arg_list ',' ALL_VA_ARGS
 		  {
-		    tree_constant *all_va_args;
-		    tree_constant::all_va_args t;
-		    all_va_args = new tree_constant (t);
+		    octave_value *all_va_args;
+		    octave_value::all_va_args t;
+		    all_va_args = new octave_value (t);
 		    $1->append (all_va_args);
 		    $$ = $1;
 		  }
@@ -1370,12 +1370,12 @@
 
   if (e->is_range_constant ())
     {
-      tree_constant tmp = e->eval (0);
+      octave_value tmp = e->eval (0);
 
       delete e;
 
       if (! error_state)
-	retval = new tree_constant (tmp);
+	retval = new octave_value (tmp);
     }
   else
     retval = e;
@@ -1385,31 +1385,31 @@
 
 // Make a constant.
 
-static tree_constant *
+static octave_value *
 make_constant (int op, token *tok_val)
 {
   int l = tok_val->line ();
   int c = tok_val->column ();
 
-  tree_constant *retval;
+  octave_value *retval;
 
   switch (op)
     {
     case NUM:
-      retval = new tree_constant (tok_val->number (), l, c);
+      retval = new octave_value (tok_val->number (), l, c);
       retval->stash_original_text (tok_val->text_rep ());
       break;
 
     case IMAG_NUM:
       {
 	Complex C (0.0, tok_val->number ());
-	retval = new tree_constant (C, l, c);
+	retval = new octave_value (C, l, c);
 	retval->stash_original_text (tok_val->text_rep ());
       }
       break;
 
     case TEXT:
-      retval = new tree_constant (tok_val->text (), l, c);
+      retval = new octave_value (tok_val->text (), l, c);
       break;
 
     default:
@@ -1524,13 +1524,13 @@
 
   if (op1->is_constant () && op2->is_constant ())
     {
-      tree_constant tmp = retval->eval (0);
+      octave_value tmp = retval->eval (0);
 
       delete retval;
       retval = 0;
 
       if (! error_state)
-	retval = new tree_constant (tmp);
+	retval = new octave_value (tmp);
     }
 
   return retval;
@@ -1629,13 +1629,13 @@
 
   if (op1->is_constant ())
     {
-      tree_constant tmp = retval->eval (0);
+      octave_value tmp = retval->eval (0);
 
       delete retval;
       retval = 0;
 
       if (! error_state)
-	retval = new tree_constant (tmp);
+	retval = new octave_value (tmp);
     }
 
   return retval;
@@ -2042,12 +2042,12 @@
 
   if (m->is_matrix_constant ())
     {
-      tree_constant tmp = m->eval (0);
+      octave_value tmp = m->eval (0);
 
       delete m;
 
       if (! error_state)
-	retval = new tree_constant (tmp);
+	retval = new octave_value (tmp);
     }
   else
     retval = m;
diff --git a/src/pinv.cc b/src/pinv.cc
--- a/src/pinv.cc
+++ b/src/pinv.cc
@@ -36,7 +36,7 @@
   "pinv ( [, tol])\n\
 Returns the pseudoinverse of X; singular values less than tol are ignored.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -46,7 +46,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   double tol = 0.0;
   if (nargin == 2)
diff --git a/src/pr-output.cc b/src/pr-output.cc
--- a/src/pr-output.cc
+++ b/src/pr-output.cc
@@ -1573,7 +1573,7 @@
 DEFUN (disp, args, ,
   "disp (X): display value without name tag")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -1600,12 +1600,12 @@
 static void
 set_output_prec_and_fw (int prec, int fw)
 {
-  tree_constant *tmp = 0;
+  octave_value *tmp = 0;
 
-  tmp = new tree_constant ((double) prec);
+  tmp = new octave_value ((double) prec);
   bind_builtin_variable ("output_precision", tmp);
 
-  tmp = new tree_constant ((double) fw);
+  tmp = new octave_value ((double) fw);
   bind_builtin_variable ("output_max_field_width", tmp);
 }
 
@@ -1738,7 +1738,7 @@
 \n\
 set output formatting style")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/pt-cmd.cc b/src/pt-cmd.cc
--- a/src/pt-cmd.cc
+++ b/src/pt-cmd.cc
@@ -211,7 +211,7 @@
 
 inline void
 tree_for_command::do_for_loop_once (tree_return_list *lst,
-				    const Octave_object& rhs, bool& quit)
+				    const octave_value_list& rhs, bool& quit)
 {
   quit = false;
 
@@ -241,11 +241,11 @@
 
 inline void
 tree_for_command::do_for_loop_once (tree_index_expression *idx_expr,
-				    const tree_constant& rhs, bool& quit)
+				    const octave_value& rhs, bool& quit)
 {
   quit = false;
 
-  tree_constant *tmp = new tree_constant (rhs);
+  octave_value *tmp = new octave_value (rhs);
   tree_simple_assignment_expression tmp_ass (idx_expr, tmp, true);
   tmp_ass.eval (false);
 
@@ -271,7 +271,7 @@
 
 inline void
 tree_for_command::do_for_loop_once (tree_identifier *ident,
-				    tree_constant& rhs, bool& quit)
+				    octave_value& rhs, bool& quit)
 {
   quit = false;
 
@@ -303,7 +303,7 @@
       if (ident) \
 	for (int i = 0; i < steps; i++) \
 	  { \
-	    tree_constant rhs (val); \
+	    octave_value rhs (val); \
 	    bool quit = false; \
 	    do_for_loop_once (ident, rhs, quit); \
 	    if (quit) \
@@ -312,7 +312,7 @@
       else if (id_list) \
 	for (int i = 0; i < steps; i++) \
 	  { \
-	    Octave_object rhs (val); \
+	    octave_value_list rhs (val); \
 	    bool quit = false; \
 	    do_for_loop_once (id_list, rhs, quit); \
 	    if (quit) \
@@ -321,7 +321,7 @@
       else \
 	for (int i = 0; i < steps; i++) \
 	  { \
-	    tree_constant rhs (val); \
+	    octave_value rhs (val); \
 	    bool quit = false; \
 	    do_for_loop_once (tmp_id, rhs, quit); \
 	    if (quit) \
@@ -336,7 +336,7 @@
   if (error_state || ! expr)
     return;
 
-  tree_constant tmp_expr = expr->eval (false);
+  octave_value tmp_expr = expr->eval (false);
 
   if (error_state || tmp_expr.is_undefined ())
     {
@@ -369,7 +369,7 @@
 	do_for_loop_once (ident, tmp_expr, quit);
       else if (id_list)
 	{
-	  Octave_object rhs (tmp_expr);
+	  octave_value_list rhs (tmp_expr);
 	  do_for_loop_once (id_list, rhs, quit);
 	}
       else
@@ -427,7 +427,7 @@
 	    {
 	      double tmp_val = b + i * increment;
 
-	      tree_constant rhs (tmp_val);
+	      octave_value rhs (tmp_val);
 
 	      bool quit = false;
 	      do_for_loop_once (ident, rhs, quit);
@@ -442,7 +442,7 @@
 	    {
 	      double tmp_val = b + i * increment;
 
-	      Octave_object rhs (tmp_val);
+	      octave_value_list rhs (tmp_val);
 
 	      bool quit = false;
 	      do_for_loop_once (id_list, rhs, quit);
@@ -457,7 +457,7 @@
 	    {
 	      double tmp_val = b + i * increment;
 
-	      tree_constant rhs (tmp_val);
+	      octave_value rhs (tmp_val);
 
 	      bool quit = false;
 	      do_for_loop_once (tmp_id, rhs, quit);
@@ -475,7 +475,7 @@
 
 	  for (Pix p = tmp_val.first (); p != 0; tmp_val.next (p))
 	    {
-	      tree_constant rhs (tmp_val.contents (p));
+	      octave_value rhs (tmp_val.contents (p));
 
 	      bool quit = false;
 	      do_for_loop_once (ident, rhs, quit);
@@ -494,7 +494,7 @@
 
 	  for (Pix p = tmp_val.first (); p != 0; tmp_val.next (p))
 	    {
-	      Octave_object tmp;
+	      octave_value_list tmp;
 	      tmp (1) = tmp_val.key (p);
 	      tmp (0) = tmp_val.contents (p);
 
@@ -511,7 +511,7 @@
 
 	  for (Pix p = tmp_val.first (); p != 0; tmp_val.next (p))
 	    {
-	      tree_constant rhs = tmp_val.contents (p);
+	      octave_value rhs = tmp_val.contents (p);
 
 	      bool quit = false;
 	      do_for_loop_once (tmp_id, rhs, quit);
diff --git a/src/pt-cmd.h b/src/pt-cmd.h
--- a/src/pt-cmd.h
+++ b/src/pt-cmd.h
@@ -29,7 +29,7 @@
 
 class ostream;
 
-class Octave_object;
+class octave_value_list;
 
 class tree_statement_list;
 class tree_global_init_list;
@@ -38,7 +38,7 @@
 class tree_index_expression;
 class tree_identifier;
 class tree_return_list;
-class tree_constant;
+class octave_value;
 class symbol_record;
 
 class tree_command;
@@ -145,13 +145,13 @@
 
 private:
   void do_for_loop_once (tree_return_list *lst,
-			 const Octave_object& rhs, bool& quit);
+			 const octave_value_list& rhs, bool& quit);
 
   void do_for_loop_once (tree_index_expression *idx_expr,
-			 const tree_constant& rhs, bool& quit);
+			 const octave_value& rhs, bool& quit);
 
   void do_for_loop_once (tree_identifier *ident,
-			 tree_constant& rhs, bool& quit);
+			 octave_value& rhs, bool& quit);
 
   tree_index_expression *id;	// Identifier to modify.
   tree_return_list *id_list;	// List of identifiers to modify.
diff --git a/src/pt-const.cc b/src/pt-const.cc
--- a/src/pt-const.cc
+++ b/src/pt-const.cc
@@ -59,16 +59,16 @@
 #include "utils.h"
 #include "variables.h"
 
-#ifndef TC_REP
-#define TC_REP tree_constant::tree_constant_rep
+#ifndef OCT_VAL_REP
+#define OCT_VAL_REP octave_value::octave_value_rep
 #endif
 
 #ifndef MAX
 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 #endif
 
-#ifndef TC_REP
-#define TC_REP tree_constant::tree_constant_rep
+#ifndef OCT_VAL_REP
+#define OCT_VAL_REP octave_value::octave_value_rep
 #endif
 
 #ifndef MAX
@@ -76,10 +76,10 @@
 #endif
 
 // The following three variables could be made static members of the
-// TC_REP class.
+// OCT_VAL_REP class.
 
 // Pointer to the blocks of memory we manage.
-static TC_REP *tc_rep_newlist = 0;
+static OCT_VAL_REP *tc_rep_newlist = 0;
 
 // Multiplier for allocating new blocks.
 static const int tc_rep_newlist_grow_size = 128;
@@ -114,24 +114,24 @@
 }
 
 // The following three variables could be made static members of the
-// tree_constant class.
+// octave_value class.
 
 // Pointer to the blocks of memory we manage.
-static tree_constant *tc_newlist = 0;
+static octave_value *tc_newlist = 0;
 
 // Multiplier for allocating new blocks.
 static const int tc_newlist_grow_size = 128;
 
 Octave_map
-tree_constant::map_value (void) const
+octave_value::map_value (void) const
 {
   return rep->map_value ();
 }
 
-tree_constant::~tree_constant (void)
+octave_value::~octave_value (void)
 {
 #if defined (MDEBUG)
-  cerr << "~tree_constant: rep: " << rep
+  cerr << "~octave_value: rep: " << rep
        << " rep->count: " << rep->count << "\n";
 #endif
 
@@ -143,14 +143,14 @@
 }
 
 void *
-tree_constant::operator new (size_t size)
+octave_value::operator new (size_t size)
 {
-  assert (size == sizeof (tree_constant));
+  assert (size == sizeof (octave_value));
 
   if (! tc_newlist)
     {
-      int block_size = tc_newlist_grow_size * sizeof (tree_constant);
-      tc_newlist = (tree_constant *) new char [block_size];
+      int block_size = tc_newlist_grow_size * sizeof (octave_value);
+      tc_newlist = (octave_value *) new char [block_size];
 
       int i = 0;
 
@@ -160,23 +160,23 @@
       tc_newlist[i].freeptr = 0;
     }
 
-  tree_constant *tmp = tc_newlist;
+  octave_value *tmp = tc_newlist;
   tc_newlist = tc_newlist->freeptr;
   return tmp;
 }
 
 void
-tree_constant::operator delete (void *p, size_t /* size */)
+octave_value::operator delete (void *p, size_t /* size */)
 {
-  tree_constant *tmp = (tree_constant *) p;
+  octave_value *tmp = (octave_value *) p;
   tmp->freeptr = tc_newlist;
   tc_newlist = tmp;
 }
 
 // Simple assignment.
 
-tree_constant
-tree_constant::operator = (const tree_constant& a)
+octave_value
+octave_value::operator = (const octave_value& a)
 {
   if (rep != a.rep)
     {
@@ -188,11 +188,11 @@
   return *this;  
 }
 
-tree_constant
-tree_constant::lookup_map_element (const string& ref, bool insert,
+octave_value
+octave_value::lookup_map_element (const string& ref, bool insert,
 				   bool silent)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (! ref.empty ())
     {
@@ -218,13 +218,13 @@
   return retval;
 }
 
-tree_constant
-tree_constant::lookup_map_element (SLList<string>& list, bool insert,
+octave_value
+octave_value::lookup_map_element (SLList<string>& list, bool insert,
 				   bool silent)
 {
-  tree_constant retval;
-
-  tree_constant_rep *tmp_rep = rep;
+  octave_value retval;
+
+  octave_value_rep *tmp_rep = rep;
 
   Pix p = list.first ();
   while (p)
@@ -233,7 +233,7 @@
 
       list.next (p);
 
-      tree_constant tmp;
+      octave_value tmp;
 
       tmp = tmp_rep->lookup_map_element (elt, insert, silent);
 
@@ -250,7 +250,7 @@
 }
 
 void
-tree_constant::print (void)
+octave_value::print (void)
 {
   ostrstream output_buf;
   print (output_buf);
@@ -259,7 +259,7 @@
 }
 
 void
-tree_constant::print_with_name (const string& name, bool print_padding)
+octave_value::print_with_name (const string& name, bool print_padding)
 {
   ostrstream output_buf;
   print_with_name (output_buf, name, print_padding);
@@ -268,7 +268,7 @@
 }
 
 void
-tree_constant::print_with_name (ostream& output_buf, const string& name,
+octave_value::print_with_name (ostream& output_buf, const string& name,
 				bool print_padding) 
 {
   bool pad_after = false;
@@ -298,12 +298,12 @@
 // Simple structure assignment.
 
 void
-tree_constant::make_unique (void)
+octave_value::make_unique (void)
 {
   if (rep->count > 1)
     {
       --rep->count;
-      rep = new tree_constant_rep (*rep);
+      rep = new octave_value_rep (*rep);
       rep->count = 1;
     }
 
@@ -316,8 +316,8 @@
     }
 }
 
-tree_constant::tree_constant_rep *
-tree_constant::make_unique_map (void)
+octave_value::octave_value_rep *
+octave_value::make_unique_map (void)
 {
   if (! rep->is_map ())
     {
@@ -325,7 +325,7 @@
 	delete rep;
 
       Octave_map m;
-      rep = new tree_constant_rep (m);
+      rep = new octave_value_rep (m);
       rep->count = 1;
     }
 
@@ -334,11 +334,11 @@
   return rep;
 }
 
-tree_constant
-tree_constant::assign_map_element (SLList<string>& list,
-				   tree_constant& rhs)
+octave_value
+octave_value::assign_map_element (SLList<string>& list,
+				   octave_value& rhs)
 {
-  tree_constant_rep *tmp_rep = make_unique_map ();
+  octave_value_rep *tmp_rep = make_unique_map ();
 
   if (rhs.is_map ())
     rhs.make_unique ();
@@ -350,7 +350,7 @@
 
       list.next (p);
 
-      tree_constant& tmp = tmp_rep->lookup_map_element (elt, 1);
+      octave_value& tmp = tmp_rep->lookup_map_element (elt, 1);
 
       if (! p)
 	{
@@ -361,17 +361,17 @@
       tmp_rep = tmp.make_unique_map ();
     }
 
-  return tree_constant ();
+  return octave_value ();
 }
 
 // Indexed structure assignment.
 
-tree_constant
-tree_constant::assign_map_element (SLList<string>& list,
-				   tree_constant& rhs,
-				   const Octave_object& args)
+octave_value
+octave_value::assign_map_element (SLList<string>& list,
+				   octave_value& rhs,
+				   const octave_value_list& args)
 {
-  tree_constant_rep *tmp_rep = make_unique_map ();
+  octave_value_rep *tmp_rep = make_unique_map ();
 
   if (rhs.is_map ())
     rhs.make_unique ();
@@ -383,7 +383,7 @@
 
       list.next (p);
 
-      tree_constant& tmp = tmp_rep->lookup_map_element (elt, 1);
+      octave_value& tmp = tmp_rep->lookup_map_element (elt, 1);
 
       if (! p)
 	{
@@ -394,13 +394,13 @@
       tmp_rep = tmp.make_unique_map ();
     }
 
-  return tree_constant ();
+  return octave_value ();
 }
 
-Octave_object
-tree_constant::eval (bool print, int, const Octave_object& args)
+octave_value_list
+octave_value::eval (bool print, int, const octave_value_list& args)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (args.length () > 0)
     retval(0) = rep->do_index (args);
@@ -414,7 +414,7 @@
 }
 
 void
-tree_constant::print_code (ostream& os)
+octave_value::print_code (ostream& os)
 {
   print_code_indent (os);
 
@@ -430,18 +430,18 @@
 
 // The real representation of constants.
 
-TC_REP::tree_constant_rep (void)
+OCT_VAL_REP::octave_value_rep (void)
 {
   type_tag = unknown_constant;
 }
 
-TC_REP::tree_constant_rep (double d)
+OCT_VAL_REP::octave_value_rep (double d)
 {
   scalar = d;
   type_tag = scalar_constant;
 }
 
-TC_REP::tree_constant_rep (const Matrix& m)
+OCT_VAL_REP::octave_value_rep (const Matrix& m)
 {
   if (m.rows () == 1 && m.columns () == 1)
     {
@@ -455,7 +455,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const DiagMatrix& d)
+OCT_VAL_REP::octave_value_rep (const DiagMatrix& d)
 {
   if (d.rows () == 1 && d.columns () == 1)
     {
@@ -469,7 +469,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const RowVector& v, int prefer_column_vector)
+OCT_VAL_REP::octave_value_rep (const RowVector& v, int prefer_column_vector)
 {
   int len = v.capacity ();
   if (len == 1)
@@ -502,7 +502,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const ColumnVector& v, int prefer_column_vector)
+OCT_VAL_REP::octave_value_rep (const ColumnVector& v, int prefer_column_vector)
 {
   int len = v.capacity ();
   if (len == 1)
@@ -535,7 +535,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const Complex& c)
+OCT_VAL_REP::octave_value_rep (const Complex& c)
 {
   if (::imag (c) == 0.0)
     {
@@ -549,7 +549,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const ComplexMatrix& m)
+OCT_VAL_REP::octave_value_rep (const ComplexMatrix& m)
 {
   if (m.rows () == 1 && m.columns () == 1)
     {
@@ -573,7 +573,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const ComplexDiagMatrix& d)
+OCT_VAL_REP::octave_value_rep (const ComplexDiagMatrix& d)
 {
   if (d.rows () == 1 && d.columns () == 1)
     {
@@ -597,7 +597,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const ComplexRowVector& v,
+OCT_VAL_REP::octave_value_rep (const ComplexRowVector& v,
 			   int prefer_column_vector) 
 {
   int len = v.capacity ();
@@ -641,7 +641,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const ComplexColumnVector& v, int
+OCT_VAL_REP::octave_value_rep (const ComplexColumnVector& v, int
 			   prefer_column_vector)
 {
   int len = v.capacity ();
@@ -685,19 +685,19 @@
     }
 }
 
-TC_REP::tree_constant_rep (const char *s)
+OCT_VAL_REP::octave_value_rep (const char *s)
 {
   char_matrix = new charMatrix (s);
   type_tag = char_matrix_constant_str;
 }
 
-TC_REP::tree_constant_rep (const string& s)
+OCT_VAL_REP::octave_value_rep (const string& s)
 {
   char_matrix = new charMatrix (s);
   type_tag = char_matrix_constant_str;
 }
 
-TC_REP::tree_constant_rep (const string_vector& s)
+OCT_VAL_REP::octave_value_rep (const string_vector& s)
 {
   int nr = s.length ();
   int nc = s.max_length ();
@@ -711,13 +711,13 @@
   type_tag = char_matrix_constant_str;
 }
 
-TC_REP::tree_constant_rep (const charMatrix& chm, bool is_str)
+OCT_VAL_REP::octave_value_rep (const charMatrix& chm, bool is_str)
 {
   char_matrix = new charMatrix (chm);
   type_tag = is_str ? char_matrix_constant_str : char_matrix_constant;
 }
 
-TC_REP::tree_constant_rep (double b, double l, double i)
+OCT_VAL_REP::octave_value_rep (double b, double l, double i)
 {
   range = new Range (b, l, i);
   int nel = range->nelem ();
@@ -747,7 +747,7 @@
     }
 }
 
-TC_REP::tree_constant_rep (const Range& r)
+OCT_VAL_REP::octave_value_rep (const Range& r)
 {
   int nel = r.nelem ();
   if (nel > 1)
@@ -775,19 +775,19 @@
     }
 }
 
-TC_REP::tree_constant_rep (const Octave_map& m)
+OCT_VAL_REP::octave_value_rep (const Octave_map& m)
 {
   a_map = new Octave_map (m);
   type_tag = map_constant;
 }
 
-TC_REP::tree_constant_rep (TC_REP::constant_type t)
+OCT_VAL_REP::octave_value_rep (OCT_VAL_REP::constant_type t)
 {
   assert (t == magic_colon || t == all_va_args);
   type_tag = t;
 }
 
-TC_REP::tree_constant_rep (const tree_constant_rep& t)
+OCT_VAL_REP::octave_value_rep (const octave_value_rep& t)
 {
   type_tag = t.type_tag;
 
@@ -836,7 +836,7 @@
   orig_text = t.orig_text;
 }
 
-TC_REP::~tree_constant_rep (void)
+OCT_VAL_REP::~octave_value_rep (void)
 {
   switch (type_tag)
     {
@@ -874,14 +874,14 @@
 }
 
 void *
-TC_REP::operator new (size_t size)
+OCT_VAL_REP::operator new (size_t size)
 {
-  assert (size == sizeof (TC_REP));
+  assert (size == sizeof (OCT_VAL_REP));
 
   if (! tc_rep_newlist)
     {
-      int block_size = tc_rep_newlist_grow_size * sizeof (TC_REP);
-      tc_rep_newlist = (TC_REP *) new char [block_size];
+      int block_size = tc_rep_newlist_grow_size * sizeof (OCT_VAL_REP);
+      tc_rep_newlist = (OCT_VAL_REP *) new char [block_size];
 
       int i = 0;
 
@@ -891,21 +891,21 @@
       tc_rep_newlist[i].freeptr = 0;
     }
 
-  TC_REP *tmp = tc_rep_newlist;
+  OCT_VAL_REP *tmp = tc_rep_newlist;
   tc_rep_newlist = tc_rep_newlist->freeptr;
   return tmp;
 }
 
 void
-TC_REP::operator delete (void *p, size_t /* size */)
+OCT_VAL_REP::operator delete (void *p, size_t /* size */)
 {
-  TC_REP *tmp = (TC_REP *) p;
+  OCT_VAL_REP *tmp = (OCT_VAL_REP *) p;
   tmp->freeptr = tc_rep_newlist;
   tc_rep_newlist = tmp;
 }
 
 int
-TC_REP::rows (void) const
+OCT_VAL_REP::rows (void) const
 {
   int retval = -1;
 
@@ -941,7 +941,7 @@
 }
 
 int
-TC_REP::columns (void) const
+OCT_VAL_REP::columns (void) const
 {
   int retval = -1;
 
@@ -976,17 +976,17 @@
   return retval;
 }
 
-tree_constant
-TC_REP::all (void) const
+octave_value
+OCT_VAL_REP::all (void) const
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
 
   if (! is_numeric_type ())
     {
-      tree_constant tmp = make_numeric ();
+      octave_value tmp = make_numeric ();
 
       if (error_state)
 	return retval;
@@ -1020,17 +1020,17 @@
   return retval;
 }
 
-tree_constant
-TC_REP::any (void) const
+octave_value
+OCT_VAL_REP::any (void) const
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
 
   if (! is_numeric_type ())
     {
-      tree_constant tmp = make_numeric ();
+      octave_value tmp = make_numeric ();
 
       if (error_state)
 	return retval;
@@ -1065,7 +1065,7 @@
 }
 
 bool
-TC_REP::valid_as_scalar_index (void) const
+OCT_VAL_REP::valid_as_scalar_index (void) const
 {
   return (type_tag == magic_colon
 	  || (type_tag == scalar_constant 
@@ -1078,7 +1078,7 @@
 }
 
 bool
-TC_REP::valid_as_zero_index (void) const
+OCT_VAL_REP::valid_as_zero_index (void) const
 {
   return ((type_tag == scalar_constant
 	   && ! xisnan (scalar)
@@ -1093,7 +1093,7 @@
 }
 
 bool
-TC_REP::is_true (void) const
+OCT_VAL_REP::is_true (void) const
 {
   int retval = false;
 
@@ -1102,7 +1102,7 @@
 
   if (! is_numeric_type ())
     {
-      tree_constant tmp = make_numeric ();
+      octave_value tmp = make_numeric ();
 
       if (error_state)
 	return retval;
@@ -1155,7 +1155,7 @@
 // XXX FIXME XXX -- we need a better way of handling conversions.
 
 double
-TC_REP::double_value (bool force_string_conv) const
+OCT_VAL_REP::double_value (bool force_string_conv) const
 {
   double retval = octave_NaN;
 
@@ -1251,7 +1251,7 @@
 }
 
 Matrix
-TC_REP::matrix_value (bool force_string_conv) const
+OCT_VAL_REP::matrix_value (bool force_string_conv) const
 {
   Matrix retval;
 
@@ -1319,7 +1319,7 @@
 }
 
 Complex
-TC_REP::complex_value (bool force_string_conv) const
+OCT_VAL_REP::complex_value (bool force_string_conv) const
 {
   Complex retval (octave_NaN, octave_NaN);
 
@@ -1397,7 +1397,7 @@
 }
 
 ComplexMatrix
-TC_REP::complex_matrix_value (bool force_string_conv) const
+OCT_VAL_REP::complex_matrix_value (bool force_string_conv) const
 {
   ComplexMatrix retval;
 
@@ -1454,7 +1454,7 @@
 // XXX FIXME XXX -- this needs to try to do some conversions...
 
 charMatrix
-TC_REP::char_matrix_value (bool force_string_conv) const
+OCT_VAL_REP::char_matrix_value (bool force_string_conv) const
 {
   charMatrix retval;
 
@@ -1479,7 +1479,7 @@
 }
 
 charMatrix
-TC_REP::all_strings (void) const
+OCT_VAL_REP::all_strings (void) const
 {
   if (type_tag == char_matrix_constant_str)
     return *char_matrix;
@@ -1491,7 +1491,7 @@
 }
 
 string
-TC_REP::string_value (void) const
+OCT_VAL_REP::string_value (void) const
 {
   string retval;
 
@@ -1504,23 +1504,23 @@
 }
 
 Range
-TC_REP::range_value (void) const
+OCT_VAL_REP::range_value (void) const
 {
   assert (type_tag == range_constant);
   return *range;
 }
 
 Octave_map
-TC_REP::map_value (void) const
+OCT_VAL_REP::map_value (void) const
 {
   assert (type_tag == map_constant);
   return *a_map;
 }
 
-tree_constant&
-TC_REP::lookup_map_element (const string& name, bool insert, bool silent)
+octave_value&
+OCT_VAL_REP::lookup_map_element (const string& name, bool insert, bool silent)
 {
-  static tree_constant retval;
+  static octave_value retval;
 
   if (type_tag == map_constant)
     {
@@ -1543,7 +1543,7 @@
 // than relying on matrix_value() to do any possible type conversions.
 
 ColumnVector
-TC_REP::vector_value (bool force_string_conv,
+OCT_VAL_REP::vector_value (bool force_string_conv,
 		      bool force_vector_conversion) const
 {
   ColumnVector retval;
@@ -1587,7 +1587,7 @@
 // conversions.
 
 ComplexColumnVector
-TC_REP::complex_vector_value (bool force_string_conv,
+OCT_VAL_REP::complex_vector_value (bool force_string_conv,
 			      bool force_vector_conversion) const
 {
   ComplexColumnVector retval;
@@ -1626,10 +1626,10 @@
   return retval;
 }
 
-tree_constant
-TC_REP::convert_to_str (void) const
+octave_value
+OCT_VAL_REP::convert_to_str (void) const
 {
-  tree_constant retval;
+  octave_value retval;
 
   switch (type_tag)
     {
@@ -1651,7 +1651,7 @@
 	    char s[2];
 	    s[0] = (char) i;
 	    s[1] = '\0';
-	    retval = tree_constant (s, 1);
+	    retval = octave_value (s, 1);
 	  }
       }
       break;
@@ -1662,7 +1662,7 @@
 	if (rows () == 0 && columns () == 0)
 	  {
 	    char s = '\0';
-	    retval = tree_constant (&s, 1);
+	    retval = octave_value (&s, 1);
 	  }
 	else
 	  {
@@ -1674,7 +1674,7 @@
 	    if (nr == 0 || nc == 0)
 	      {
 		char s = '\0';
-		retval = tree_constant (&s, 1);
+		retval = octave_value (&s, 1);
 	      }
 	    else
 	      {
@@ -1702,7 +1702,7 @@
 		      }
 		  }
 
-		retval = tree_constant (chm, 1);
+		retval = octave_value (chm, 1);
 	      }
 	  }
       }
@@ -1735,17 +1735,17 @@
 		s[i] = (char) ival;
 	      }
 	  }
-	retval = tree_constant (s, 1);
+	retval = octave_value (s, 1);
 	delete [] s;
       }
       break;
 
     case char_matrix_constant:
-      retval = tree_constant (*char_matrix, 1);
+      retval = octave_value (*char_matrix, 1);
       break;
 
     case char_matrix_constant_str:
-      retval = tree_constant (*char_matrix, 1);
+      retval = octave_value (*char_matrix, 1);
       break;
 
     default:
@@ -1757,7 +1757,7 @@
 }
 
 void
-TC_REP::convert_to_row_or_column_vector (void)
+OCT_VAL_REP::convert_to_row_or_column_vector (void)
 {
   assert (type_tag == matrix_constant || type_tag == complex_matrix_constant);
 
@@ -1816,7 +1816,7 @@
 }
 
 void
-TC_REP::convert_to_matrix_type (bool make_complex)
+OCT_VAL_REP::convert_to_matrix_type (bool make_complex)
 {
   switch (type_tag)
     {
@@ -1885,7 +1885,7 @@
 }
 
 void
-TC_REP::force_numeric (bool force_string_conv)
+OCT_VAL_REP::force_numeric (bool force_string_conv)
 {
   switch (type_tag)
     {
@@ -1971,10 +1971,10 @@
     }
 }
 
-tree_constant
-TC_REP::make_numeric (bool force_string_conv) const
+octave_value
+OCT_VAL_REP::make_numeric (bool force_string_conv) const
 {
-  tree_constant retval;
+  octave_value retval;
 
   switch (type_tag)
     {
@@ -2031,7 +2031,7 @@
 }
 
 void
-TC_REP::bump_value (tree_expression::type etype)
+OCT_VAL_REP::bump_value (tree_expression::type etype)
 {
   switch (etype)
     {
@@ -2094,7 +2094,7 @@
 }
 
 void
-TC_REP::resize (int i, int j)
+OCT_VAL_REP::resize (int i, int j)
 {
   switch (type_tag)
     {
@@ -2113,7 +2113,7 @@
 }
 
 void
-TC_REP::resize (int i, int j, double val)
+OCT_VAL_REP::resize (int i, int j, double val)
 {
   switch (type_tag)
     {
@@ -2132,13 +2132,13 @@
 }
 
 void
-TC_REP::stash_original_text (const string &s)
+OCT_VAL_REP::stash_original_text (const string &s)
 {
   orig_text = s;
 }
 
 void
-TC_REP::maybe_mutate (void)
+OCT_VAL_REP::maybe_mutate (void)
 {
   switch (type_tag)
     {
@@ -2216,7 +2216,7 @@
 }
 
 void
-TC_REP::print (ostream& output_buf)
+OCT_VAL_REP::print (ostream& output_buf)
 {
   if (error_state)
     return;
@@ -2261,7 +2261,7 @@
 	// standard order.  Maybe all substructures first, maybe
 	// alphabetize entries, etc.
 
-	begin_unwind_frame ("TC_REP_print");
+	begin_unwind_frame ("OCT_VAL_REP_print");
 
 	unwind_protect_int (struct_indent);
 	unwind_protect_int (user_pref.struct_levels_to_print);
@@ -2279,7 +2279,7 @@
 		bool pad_after = false;
 
 		string key = a_map->key (p);
-		tree_constant val = a_map->contents (p);
+		octave_value val = a_map->contents (p);
 
 		a_map->next (p);
 
@@ -2314,7 +2314,7 @@
 	else
 	  output_buf << " <structure>\n";
 
-	run_unwind_frame ("TC_REP_print");
+	run_unwind_frame ("OCT_VAL_REP_print");
       }
       break;
 
@@ -2327,7 +2327,7 @@
 }
 
 void
-TC_REP::print_code (ostream& os)
+OCT_VAL_REP::print_code (ostream& os)
 {
   switch (type_tag)
     {
@@ -2390,8 +2390,8 @@
 }
 
 void
-TC_REP::gripe_wrong_type_arg (const char *name,
-			      const tree_constant_rep& tcr) const
+OCT_VAL_REP::gripe_wrong_type_arg (const char *name,
+			      const octave_value_rep& tcr) const
 {
   if (name)
     ::error ("%s: wrong type argument `%s'", name, tcr.type_as_string ());
@@ -2400,7 +2400,7 @@
 }
 
 char *
-TC_REP::type_as_string (void) const
+OCT_VAL_REP::type_as_string (void) const
 {
   switch (type_tag)
     {
@@ -2433,10 +2433,10 @@
     }
 }
 
-tree_constant
-do_binary_op (tree_constant& a, tree_constant& b, tree_expression::type t)
+octave_value
+do_binary_op (octave_value& a, octave_value& b, tree_expression::type t)
 {
-  tree_constant retval;
+  octave_value retval;
 
   bool first_empty = (a.rows () == 0 || a.columns () == 0);
   bool second_empty = (b.rows () == 0 || b.columns () == 0);
@@ -2453,18 +2453,18 @@
 	}
     }
 
-  tree_constant tmp_a = a.make_numeric ();
+  octave_value tmp_a = a.make_numeric ();
 
   if (error_state)
     return retval;
 
-  tree_constant tmp_b = b.make_numeric ();
+  octave_value tmp_b = b.make_numeric ();
 
   if (error_state)
     return retval;
 
-  TC_REP::constant_type a_type = tmp_a.const_type ();
-  TC_REP::constant_type b_type = tmp_b.const_type ();
+  OCT_VAL_REP::constant_type a_type = tmp_a.const_type ();
+  OCT_VAL_REP::constant_type b_type = tmp_b.const_type ();
 
   double d1, d2;
   Matrix m1, m2;
@@ -2473,29 +2473,29 @@
 
   switch (a_type)
     {
-    case TC_REP::scalar_constant:
+    case OCT_VAL_REP::scalar_constant:
 
       d1 = tmp_a.double_value ();
 
       switch (b_type)
 	{
-	case TC_REP::scalar_constant:
+	case OCT_VAL_REP::scalar_constant:
 	  d2 = tmp_b.double_value ();
 	  retval = do_binary_op (d1, d2, t);
 	  break;
 
-	case TC_REP::matrix_constant:
-	case TC_REP::char_matrix_constant:
+	case OCT_VAL_REP::matrix_constant:
+	case OCT_VAL_REP::char_matrix_constant:
 	  m2 = tmp_b.matrix_value ();
 	  retval = do_binary_op (d1, m2, t);
 	  break;
 
-	case TC_REP::complex_scalar_constant:
+	case OCT_VAL_REP::complex_scalar_constant:
 	  c2 = tmp_b.complex_value ();
 	  retval = do_binary_op (d1, c2, t);
 	  break;
 
-	case TC_REP::complex_matrix_constant:
+	case OCT_VAL_REP::complex_matrix_constant:
 	  cm2 = tmp_b.complex_matrix_value ();
 	  retval = do_binary_op (d1, cm2, t);
 	  break;
@@ -2506,30 +2506,30 @@
 	}
       break;
 
-    case TC_REP::matrix_constant:
-    case TC_REP::char_matrix_constant:
+    case OCT_VAL_REP::matrix_constant:
+    case OCT_VAL_REP::char_matrix_constant:
 
       m1 = tmp_a.matrix_value ();
 
       switch (b_type)
 	{
-	case TC_REP::scalar_constant:
+	case OCT_VAL_REP::scalar_constant:
 	  d2 = tmp_b.double_value ();
 	  retval = do_binary_op (m1, d2, t);
 	  break;
 
-	case TC_REP::matrix_constant:
-	case TC_REP::char_matrix_constant:
+	case OCT_VAL_REP::matrix_constant:
+	case OCT_VAL_REP::char_matrix_constant:
 	  m2 = tmp_b.matrix_value ();
 	  retval = do_binary_op (m1, m2, t);
 	  break;
 
-	case TC_REP::complex_scalar_constant:
+	case OCT_VAL_REP::complex_scalar_constant:
 	  c2 = tmp_b.complex_value ();
 	  retval = do_binary_op (m1, c2, t);
 	  break;
 
-	case TC_REP::complex_matrix_constant:
+	case OCT_VAL_REP::complex_matrix_constant:
 	  cm2 = tmp_b.complex_matrix_value ();
 	  retval = do_binary_op (m1, cm2, t);
 	  break;
@@ -2540,29 +2540,29 @@
 	}
       break;
 
-    case TC_REP::complex_scalar_constant:
+    case OCT_VAL_REP::complex_scalar_constant:
 
       c1 = tmp_a.complex_value ();
 
       switch (b_type)
 	{
-	case TC_REP::scalar_constant:
+	case OCT_VAL_REP::scalar_constant:
 	  d2 = tmp_b.double_value ();
 	  retval = do_binary_op (c1, d2, t);
 	  break;
 
-	case TC_REP::matrix_constant:
-	case TC_REP::char_matrix_constant:
+	case OCT_VAL_REP::matrix_constant:
+	case OCT_VAL_REP::char_matrix_constant:
 	  m2 = tmp_b.matrix_value ();
 	  retval = do_binary_op (c1, m2, t);
 	  break;
 
-	case TC_REP::complex_scalar_constant:
+	case OCT_VAL_REP::complex_scalar_constant:
 	  c2 = tmp_b.complex_value ();
 	  retval = do_binary_op (c1, c2, t);
 	  break;
 
-	case TC_REP::complex_matrix_constant:
+	case OCT_VAL_REP::complex_matrix_constant:
 	  cm2 = tmp_b.complex_matrix_value ();
 	  retval = do_binary_op (c1, cm2, t);
 	  break;
@@ -2573,29 +2573,29 @@
 	}
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
 
       cm1 = tmp_a.complex_matrix_value ();
 
       switch (b_type)
 	{
-	case TC_REP::scalar_constant:
+	case OCT_VAL_REP::scalar_constant:
 	  d2 = tmp_b.double_value ();
 	  retval = do_binary_op (cm1, d2, t);
 	  break;
 
-	case TC_REP::matrix_constant:
-	case TC_REP::char_matrix_constant:
+	case OCT_VAL_REP::matrix_constant:
+	case OCT_VAL_REP::char_matrix_constant:
 	  m2 = tmp_b.matrix_value ();
 	  retval = do_binary_op (cm1, m2, t);
 	  break;
 
-	case TC_REP::complex_scalar_constant:
+	case OCT_VAL_REP::complex_scalar_constant:
 	  c2 = tmp_b.complex_value ();
 	  retval = do_binary_op (cm1, c2, t);
 	  break;
 
-	case TC_REP::complex_matrix_constant:
+	case OCT_VAL_REP::complex_matrix_constant:
 	  cm2 = tmp_b.complex_matrix_value ();
 	  retval = do_binary_op (cm1, cm2, t);
 	  break;
@@ -2614,10 +2614,10 @@
   return retval;
 }
 
-tree_constant
-do_unary_op (tree_constant& a, tree_expression::type t)
+octave_value
+do_unary_op (octave_value& a, tree_expression::type t)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (a.rows () == 0 || a.columns () == 0)
     {
@@ -2631,29 +2631,29 @@
 	}
     }
 
-  tree_constant tmp_a = a.make_numeric ();
+  octave_value tmp_a = a.make_numeric ();
 
   if (error_state)
     return retval;
 
   switch (tmp_a.const_type ())
     {
-    case TC_REP::scalar_constant:
+    case OCT_VAL_REP::scalar_constant:
       retval = do_unary_op (tmp_a.double_value (), t);
       break;
 
-    case TC_REP::matrix_constant:
+    case OCT_VAL_REP::matrix_constant:
       {
 	Matrix m = tmp_a.matrix_value ();
 	retval = do_unary_op (m, t);
       }
       break;
 
-    case TC_REP::complex_scalar_constant:
+    case OCT_VAL_REP::complex_scalar_constant:
       retval = do_unary_op (tmp_a.complex_value (), t);
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
       {
 	ComplexMatrix m = tmp_a.complex_matrix_value ();
 	retval = do_unary_op (m, t);
@@ -2671,7 +2671,7 @@
 // Indexing operations for the tree-constant representation class.
 
 void
-TC_REP::clear_index (void)
+OCT_VAL_REP::clear_index (void)
 {
   switch (type_tag)
     {
@@ -2679,7 +2679,7 @@
       matrix->clear_index ();
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
       complex_matrix->clear_index ();
       break;
 
@@ -2696,7 +2696,7 @@
 
 #if 0
 void
-TC_REP::set_index (double d)
+OCT_VAL_REP::set_index (double d)
 {
   switch (type_tag)
     {
@@ -2704,12 +2704,12 @@
       matrix->set_index (d);
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
       complex_matrix->set_index (d);
       break;
 
-    case TC_REP::char_matrix_constant:
-    case TC_REP::char_matrix_constant_str:
+    case OCT_VAL_REP::char_matrix_constant:
+    case OCT_VAL_REP::char_matrix_constant_str:
       char_matrix->set_index (d);
       break;
 
@@ -2721,7 +2721,7 @@
 #endif
 
 void
-TC_REP::set_index (const Range& r)
+OCT_VAL_REP::set_index (const Range& r)
 {
   switch (type_tag)
     {
@@ -2729,12 +2729,12 @@
       matrix->set_index (r);
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
       complex_matrix->set_index (r);
       break;
 
-    case TC_REP::char_matrix_constant:
-    case TC_REP::char_matrix_constant_str:
+    case OCT_VAL_REP::char_matrix_constant:
+    case OCT_VAL_REP::char_matrix_constant_str:
       char_matrix->set_index (r);
       break;
 
@@ -2745,7 +2745,7 @@
 }
 
 void
-TC_REP::set_index (const ColumnVector& v)
+OCT_VAL_REP::set_index (const ColumnVector& v)
 {
   switch (type_tag)
     {
@@ -2753,12 +2753,12 @@
       matrix->set_index (v);
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
       complex_matrix->set_index (v);
       break;
 
-    case TC_REP::char_matrix_constant:
-    case TC_REP::char_matrix_constant_str:
+    case OCT_VAL_REP::char_matrix_constant:
+    case OCT_VAL_REP::char_matrix_constant_str:
       char_matrix->set_index (v);
       break;
 
@@ -2769,7 +2769,7 @@
 }
 
 void
-TC_REP::set_index (const Matrix& m)
+OCT_VAL_REP::set_index (const Matrix& m)
 {
   int nr = m.rows ();
   int nc = m.cols ();
@@ -2783,12 +2783,12 @@
 	  matrix->set_index (m);
 	  break;
 
-	case TC_REP::complex_matrix_constant:
+	case OCT_VAL_REP::complex_matrix_constant:
 	  complex_matrix->set_index (m);
 	  break;
 
-	case TC_REP::char_matrix_constant:
-	case TC_REP::char_matrix_constant_str:
+	case OCT_VAL_REP::char_matrix_constant:
+	case OCT_VAL_REP::char_matrix_constant_str:
 	  char_matrix->set_index (m);
 	  break;
 
@@ -2804,7 +2804,7 @@
 // XXX FIXME XXX -- this should probably be handled some other way...
 // The arg here is expected to be ':'.
 void
-TC_REP::set_index (char c)
+OCT_VAL_REP::set_index (char c)
 {
   switch (type_tag)
     {
@@ -2812,12 +2812,12 @@
       matrix->set_index (c);
       break;
 
-    case TC_REP::complex_matrix_constant:
+    case OCT_VAL_REP::complex_matrix_constant:
       complex_matrix->set_index (c);
       break;
 
-    case TC_REP::char_matrix_constant:
-    case TC_REP::char_matrix_constant_str:
+    case OCT_VAL_REP::char_matrix_constant:
+    case OCT_VAL_REP::char_matrix_constant_str:
       char_matrix->set_index (c);
       break;
 
@@ -2828,7 +2828,7 @@
 }
 
 void
-TC_REP::set_index (const Octave_object& args, bool rhs_is_complex)
+OCT_VAL_REP::set_index (const octave_value_list& args, bool rhs_is_complex)
 {
   switch (type_tag)
     {
@@ -2847,7 +2847,7 @@
 
   for (int i = 0; i < n; i++)
     {
-      tree_constant arg = args (i);
+      octave_value arg = args (i);
 
       switch (arg.const_type ())
 	{
@@ -2873,7 +2873,7 @@
 }
 
 static inline bool
-valid_scalar_indices (const Octave_object& args)
+valid_scalar_indices (const octave_value_list& args)
 {
   int nargin = args.length ();
 
@@ -2884,10 +2884,10 @@
   return true;
 }
 
-tree_constant
-TC_REP::do_index (const Octave_object& args)
+octave_value
+OCT_VAL_REP::do_index (const octave_value_list& args)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -2936,7 +2936,7 @@
 	      break;
 
 	    case char_matrix_constant_str:
-	      retval = tree_constant (charMatrix (char_matrix->value ()), 1);
+	      retval = octave_value (charMatrix (char_matrix->value ()), 1);
 	      break;
 
 	    default:
@@ -2950,7 +2950,7 @@
 }
 
 void
-TC_REP::maybe_widen (TC_REP::constant_type rhs_type)
+OCT_VAL_REP::maybe_widen (OCT_VAL_REP::constant_type rhs_type)
 {
   switch (type_tag)
     {
@@ -3024,13 +3024,13 @@
 extern void assign (Array2<char>&, const Array2<char>&);
 
 void
-TC_REP::assign (tree_constant& rhs, const Octave_object& args)
+OCT_VAL_REP::assign (octave_value& rhs, const octave_value_list& args)
 {
   // XXX FIXME XXX -- we should probably have special cases for rhs
   // being a range type, since converting to a matrix can waste a lot
   // of memory.
 
-  tree_constant rhs_tmp = rhs;
+  octave_value rhs_tmp = rhs;
 
   if (! (is_string ()
 	 && (rhs_tmp.is_string ()
@@ -3147,7 +3147,7 @@
 }
 
 bool
-TC_REP::print_as_scalar (void)
+OCT_VAL_REP::print_as_scalar (void)
 {
   int nr = rows ();
   int nc = columns ();
@@ -3161,7 +3161,7 @@
 }
 
 bool
-TC_REP::print_as_structure (void)
+OCT_VAL_REP::print_as_structure (void)
 {
   return is_map ();
 }
diff --git a/src/pt-const.h b/src/pt-const.h
--- a/src/pt-const.h
+++ b/src/pt-const.h
@@ -40,19 +40,19 @@
 #include "pt-fvc.h"
 
 class Octave_map;
-class Octave_object;
+class octave_value_list;
 
 // Constants.
 
 class
-tree_constant : public tree_fvc
+octave_value : public tree_fvc
 {
 private:
 
-// The actual representation of the tree_constant.
+// The actual representation of the octave_value.
 
   class
-  tree_constant_rep
+  octave_value_rep
   {
   public:
 
@@ -78,35 +78,35 @@
 	column_orient,
       };
 
-    tree_constant_rep (void);
+    octave_value_rep (void);
 
-    tree_constant_rep (double d);
-    tree_constant_rep (const Matrix& m);
-    tree_constant_rep (const DiagMatrix& d);
-    tree_constant_rep (const RowVector& v, int pcv);
-    tree_constant_rep (const ColumnVector& v, int pcv);
+    octave_value_rep (double d);
+    octave_value_rep (const Matrix& m);
+    octave_value_rep (const DiagMatrix& d);
+    octave_value_rep (const RowVector& v, int pcv);
+    octave_value_rep (const ColumnVector& v, int pcv);
 
-    tree_constant_rep (const Complex& c);
-    tree_constant_rep (const ComplexMatrix& m);
-    tree_constant_rep (const ComplexDiagMatrix& d);
-    tree_constant_rep (const ComplexRowVector& v, int pcv);
-    tree_constant_rep (const ComplexColumnVector& v, int pcv);
+    octave_value_rep (const Complex& c);
+    octave_value_rep (const ComplexMatrix& m);
+    octave_value_rep (const ComplexDiagMatrix& d);
+    octave_value_rep (const ComplexRowVector& v, int pcv);
+    octave_value_rep (const ComplexColumnVector& v, int pcv);
 
-    tree_constant_rep (const char *s);
-    tree_constant_rep (const string& s);
-    tree_constant_rep (const string_vector& s);
-    tree_constant_rep (const charMatrix& chm, bool is_string);
+    octave_value_rep (const char *s);
+    octave_value_rep (const string& s);
+    octave_value_rep (const string_vector& s);
+    octave_value_rep (const charMatrix& chm, bool is_string);
 
-    tree_constant_rep (double base, double limit, double inc);
-    tree_constant_rep (const Range& r);
+    octave_value_rep (double base, double limit, double inc);
+    octave_value_rep (const Range& r);
 
-    tree_constant_rep (const Octave_map& m);
+    octave_value_rep (const Octave_map& m);
 
-    tree_constant_rep (tree_constant_rep::constant_type t);
+    octave_value_rep (octave_value_rep::constant_type t);
 
-    tree_constant_rep (const tree_constant_rep& t);
+    octave_value_rep (const octave_value_rep& t);
 
-    ~tree_constant_rep (void);
+    ~octave_value_rep (void);
 
     void *operator new (size_t size);
     void operator delete (void *p, size_t size);
@@ -153,8 +153,8 @@
     bool is_all_va_args (void) const
       { return type_tag == all_va_args; }
 
-    tree_constant all (void) const;
-    tree_constant any (void) const;
+    octave_value all (void) const;
+    octave_value any (void) const;
 
     bool is_real_type (void) const
       {
@@ -217,7 +217,7 @@
     Range range_value (void) const;
     Octave_map map_value (void) const;
 
-    tree_constant& lookup_map_element (const string& name,
+    octave_value& lookup_map_element (const string& name,
 				       bool insert = false,
 				       bool silent = false);
 
@@ -228,7 +228,7 @@
     complex_vector_value (bool frc_str_conv = false,
 			  bool frc_vec_conv = false) const;
 
-    tree_constant convert_to_str (void) const;
+    octave_value convert_to_str (void) const;
 
     void convert_to_row_or_column_vector (void);
 
@@ -247,17 +247,17 @@
     void print_code (ostream& os);
 
     void gripe_wrong_type_arg (const char *name,
-			       const tree_constant_rep& tcr) const;
+			       const octave_value_rep& tcr) const;
 
     char *type_as_string (void) const;
 
     // Binary and unary operations.
 
-    friend tree_constant do_binary_op (tree_constant& a, tree_constant& b,
-				       tree_expression::type t);
+    friend octave_value do_binary_op (octave_value& a, octave_value& b,
+				      tree_expression::type t);
 
-    friend tree_constant do_unary_op (tree_constant& a,
-				      tree_expression::type t);
+    friend octave_value do_unary_op (octave_value& a,
+				     tree_expression::type t);
 
     // We want to eliminate this.
 
@@ -266,7 +266,7 @@
     // We want to get rid of these too:
 
     void force_numeric (bool frc_str_conv = false);
-    tree_constant make_numeric (bool frc_str_conv = false) const;
+    octave_value make_numeric (bool frc_str_conv = false) const;
 
     // But not this.
 
@@ -282,14 +282,14 @@
     void set_index (const Matrix& m);
     void set_index (char c);
 
-    void set_index (const Octave_object& args,
+    void set_index (const octave_value_list& args,
 		    bool rhs_is_complex = false);
 
-    tree_constant do_index (const Octave_object& args);
+    octave_value do_index (const octave_value_list& args);
 
     void maybe_widen (constant_type t);
 
-    void assign (tree_constant& rhs, const Octave_object& args);
+    void assign (octave_value& rhs, const octave_value_list& args);
 
     bool print_as_scalar (void);
 
@@ -307,7 +307,7 @@
 	Range *range;			// A set of evenly spaced values.
 	Octave_map *a_map;		// An associative array.
 
-	tree_constant_rep *freeptr;	// For custom memory management.
+	octave_value_rep *freeptr;	// For custom memory management.
       };
 
     constant_type type_tag;
@@ -319,8 +319,8 @@
 
   union
     {
-      tree_constant *freeptr;  // For custom memory management.
-      tree_constant_rep *rep;  // The real representation.
+      octave_value *freeptr;  // For custom memory management.
+      octave_value_rep *rep;  // The real representation.
     };
 
 public:
@@ -351,105 +351,105 @@
   // range            double, double, double
   //                  Range
   // map              Octave_map
-  // magic colon      tree_constant::magic_colon
-  // all_va_args      tree_constant::all_va_args
+  // magic colon      octave_value::magic_colon
+  // all_va_args      octave_value::all_va_args
 
-  tree_constant (void) : tree_fvc ()
-    { rep = new tree_constant_rep (); rep->count = 1; }
+  octave_value (void) : tree_fvc ()
+    { rep = new octave_value_rep (); rep->count = 1; }
 
-  tree_constant (double d, int l = -1, int c = -1) : tree_fvc (l, c)
-    { rep = new tree_constant_rep (d); rep->count = 1; }
+  octave_value (double d, int l = -1, int c = -1) : tree_fvc (l, c)
+    { rep = new octave_value_rep (d); rep->count = 1; }
 
-  tree_constant (const Matrix& m) : tree_fvc ()
-    { rep = new tree_constant_rep (m); rep->count = 1; }
+  octave_value (const Matrix& m) : tree_fvc ()
+    { rep = new octave_value_rep (m); rep->count = 1; }
 
-  tree_constant (const DiagMatrix& d) : tree_fvc ()
-    { rep = new tree_constant_rep (d); rep->count = 1; }
+  octave_value (const DiagMatrix& d) : tree_fvc ()
+    { rep = new octave_value_rep (d); rep->count = 1; }
 
-  tree_constant (const RowVector& v, int pcv = -1) : tree_fvc ()
-    { rep = new tree_constant_rep (v, pcv); rep->count = 1; }
+  octave_value (const RowVector& v, int pcv = -1) : tree_fvc ()
+    { rep = new octave_value_rep (v, pcv); rep->count = 1; }
 
-  tree_constant (const ColumnVector& v, int pcv = -1) : tree_fvc ()
-    { rep = new tree_constant_rep (v, pcv); rep->count = 1; }
+  octave_value (const ColumnVector& v, int pcv = -1) : tree_fvc ()
+    { rep = new octave_value_rep (v, pcv); rep->count = 1; }
 
-  tree_constant (const Complex& C, int l = -1, int c = -1) : tree_fvc (l, c)
-    { rep = new tree_constant_rep (C); rep->count = 1; }
+  octave_value (const Complex& C, int l = -1, int c = -1) : tree_fvc (l, c)
+    { rep = new octave_value_rep (C); rep->count = 1; }
 
-  tree_constant (const ComplexMatrix& m) : tree_fvc ()
-    { rep = new tree_constant_rep (m); rep->count = 1; }
+  octave_value (const ComplexMatrix& m) : tree_fvc ()
+    { rep = new octave_value_rep (m); rep->count = 1; }
 
-  tree_constant (const ComplexDiagMatrix& d) : tree_fvc ()
-    { rep = new tree_constant_rep (d); rep->count = 1; }
+  octave_value (const ComplexDiagMatrix& d) : tree_fvc ()
+    { rep = new octave_value_rep (d); rep->count = 1; }
 
-  tree_constant (const ComplexRowVector& v, int pcv = -1) : tree_fvc ()
-    { rep = new tree_constant_rep (v, pcv); rep->count = 1; }
+  octave_value (const ComplexRowVector& v, int pcv = -1) : tree_fvc ()
+    { rep = new octave_value_rep (v, pcv); rep->count = 1; }
 
-  tree_constant (const ComplexColumnVector& v, int pcv = -1) : tree_fvc () 
-    { rep = new tree_constant_rep (v, pcv); rep->count = 1; }
+  octave_value (const ComplexColumnVector& v, int pcv = -1) : tree_fvc () 
+    { rep = new octave_value_rep (v, pcv); rep->count = 1; }
 
-  tree_constant (const char *s, int l = -1, int c = -1) : tree_fvc (l, c)
-    { rep = new tree_constant_rep (s); rep->count = 1; }
+  octave_value (const char *s, int l = -1, int c = -1) : tree_fvc (l, c)
+    { rep = new octave_value_rep (s); rep->count = 1; }
 
-  tree_constant (const string& s, int l = -1, int c = -1) : tree_fvc (l, c)
-    { rep = new tree_constant_rep (s); rep->count = 1; }
+  octave_value (const string& s, int l = -1, int c = -1) : tree_fvc (l, c)
+    { rep = new octave_value_rep (s); rep->count = 1; }
 
-  tree_constant (const string_vector& s, int l = -1, int c = -1)
+  octave_value (const string_vector& s, int l = -1, int c = -1)
     : tree_fvc (l, c)
-    { rep = new tree_constant_rep (s); rep->count = 1; }
+    { rep = new octave_value_rep (s); rep->count = 1; }
 
-  tree_constant (const charMatrix& chm, bool is_string = false) : tree_fvc ()
-    { rep = new tree_constant_rep (chm, is_string); rep->count = 1; }
+  octave_value (const charMatrix& chm, bool is_string = false) : tree_fvc ()
+    { rep = new octave_value_rep (chm, is_string); rep->count = 1; }
 
-  tree_constant (double base, double limit, double inc) : tree_fvc ()
-    { rep = new tree_constant_rep (base, limit, inc); rep->count = 1; }
+  octave_value (double base, double limit, double inc) : tree_fvc ()
+    { rep = new octave_value_rep (base, limit, inc); rep->count = 1; }
 
-  tree_constant (const Range& r) : tree_fvc ()
-    { rep = new tree_constant_rep (r); rep->count = 1; }
+  octave_value (const Range& r) : tree_fvc ()
+    { rep = new octave_value_rep (r); rep->count = 1; }
 
-  tree_constant (const Octave_map& m) : tree_fvc ()
-    { rep = new tree_constant_rep (m); rep->count = 1; }
+  octave_value (const Octave_map& m) : tree_fvc ()
+    { rep = new octave_value_rep (m); rep->count = 1; }
 
-  tree_constant (tree_constant::magic_colon) : tree_fvc ()
+  octave_value (octave_value::magic_colon) : tree_fvc ()
     {
-      tree_constant_rep::constant_type tmp;
-      tmp = tree_constant_rep::magic_colon;
-      rep = new tree_constant_rep (tmp);
+      octave_value_rep::constant_type tmp;
+      tmp = octave_value_rep::magic_colon;
+      rep = new octave_value_rep (tmp);
       rep->count = 1;
     }
 
-  tree_constant (tree_constant::all_va_args) : tree_fvc ()
+  octave_value (octave_value::all_va_args) : tree_fvc ()
     {
-      tree_constant_rep::constant_type tmp;
-      tmp = tree_constant_rep::all_va_args;
-      rep = new tree_constant_rep (tmp);
+      octave_value_rep::constant_type tmp;
+      tmp = octave_value_rep::all_va_args;
+      rep = new octave_value_rep (tmp);
       rep->count = 1;
     }
 
   // Copy constructor.
 
-  tree_constant (const tree_constant& a) : tree_fvc ()
+  octave_value (const octave_value& a) : tree_fvc ()
     { rep = a.rep; rep->count++; }
 
   // Delete the representation of this constant if the count drops to
   // zero.
 
-  ~tree_constant (void);
+  ~octave_value (void);
 
   void *operator new (size_t size);
   void operator delete (void *p, size_t size);
 
   // Simple assignment.
 
-  tree_constant operator = (const tree_constant& a);
+  octave_value operator = (const octave_value& a);
 
   // Indexed assignment.
 
-  tree_constant assign (tree_constant& rhs, const Octave_object& args)
+  octave_value assign (octave_value& rhs, const octave_value_list& args)
     {
       if (rep->count > 1)
 	{
 	  --rep->count;
-	  rep = new tree_constant_rep (*rep);
+	  rep = new octave_value_rep (*rep);
 	  rep->count = 1;
 	}
 
@@ -460,14 +460,14 @@
 
   // Simple structure assignment.
 
-  tree_constant assign_map_element (SLList<string>& list,
-				    tree_constant& rhs);
+  octave_value assign_map_element (SLList<string>& list,
+				    octave_value& rhs);
 
   // Indexed structure assignment.
 
-  tree_constant assign_map_element (SLList<string>& list,
-				    tree_constant& rhs,
-				    const Octave_object& args);
+  octave_value assign_map_element (SLList<string>& list,
+				    octave_value& rhs,
+				    const octave_value_list& args);
 
   // Type.  It would be nice to eliminate the need for this.
 
@@ -501,8 +501,8 @@
 
   // Are any or all of the elements in this constant nonzero?
 
-  tree_constant all (void) const { return rep->all (); }
-  tree_constant any (void) const { return rep->any (); }
+  octave_value all (void) const { return rep->all (); }
+  octave_value any (void) const { return rep->any (); }
 
   // Other type stuff.
 
@@ -567,11 +567,11 @@
 
   Octave_map map_value (void) const;
 
-  tree_constant lookup_map_element (const string& ref,
+  octave_value lookup_map_element (const string& ref,
 				    bool insert = false,
 				    bool silent = false);
 
-  tree_constant lookup_map_element (SLList<string>& list,
+  octave_value lookup_map_element (SLList<string>& list,
 				    bool insert = false,
 				    bool silent = false);
 
@@ -586,17 +586,17 @@
 
   // Binary and unary operations.
 
-  friend tree_constant do_binary_op (tree_constant& a, tree_constant& b,
+  friend octave_value do_binary_op (octave_value& a, octave_value& b,
 				     tree_expression::type t);
 
-  friend tree_constant do_unary_op (tree_constant& a,
+  friend octave_value do_unary_op (octave_value& a,
 				    tree_expression::type t);
 
   // Conversions.  These should probably be private.  If a user of this
   // class wants a certain kind of constant, he should simply ask for
   // it, and we should convert it if possible.
 
-  tree_constant convert_to_str (void)
+  octave_value convert_to_str (void)
     { return rep->convert_to_str (); }
 
   void convert_to_row_or_column_vector (void)
@@ -609,7 +609,7 @@
       if (rep->count > 1)
 	{
 	  --rep->count;
-	  rep = new tree_constant_rep (*rep);
+	  rep = new octave_value_rep (*rep);
 	  rep->count = 1;
 	}
 
@@ -626,7 +626,7 @@
   // Evaluate this constant, possibly converting complex to real, or
   // matrix to scalar, etc.
 
-  tree_constant eval (bool print_result)
+  octave_value eval (bool print_result)
     {
       if (print_result)
 	{
@@ -637,7 +637,7 @@
       return *this;
     }
 
-  Octave_object eval (bool, int, const Octave_object&);
+  octave_value_list eval (bool, int, const octave_value_list&);
 
   // Store the original text corresponding to this constant for later
   // pretty printing.
@@ -658,11 +658,11 @@
 
   void make_unique (void);
 
-  tree_constant_rep *make_unique_map (void);
+  octave_value_rep *make_unique_map (void);
 
   // We want to eliminate this, or at least make it private.
 
-  tree_constant_rep::constant_type const_type (void) const
+  octave_value_rep::constant_type const_type (void) const
     { return rep->const_type (); }
 
   void convert_to_matrix_type (bool make_complex)
@@ -675,7 +675,7 @@
   void force_numeric (bool frc_str_conv = false)
     { rep->force_numeric (frc_str_conv); }
 
-  tree_constant make_numeric (bool frc_str_conv = false) const
+  octave_value make_numeric (bool frc_str_conv = false) const
     {
       if (is_numeric_type ())
 	return *this;
diff --git a/src/pt-exp-base.cc b/src/pt-exp-base.cc
--- a/src/pt-exp-base.cc
+++ b/src/pt-exp-base.cc
@@ -44,7 +44,7 @@
 {
   bool expr_value = false;
 
-  tree_constant t1 = eval (false);
+  octave_value t1 = eval (false);
 
   if (! error_state)
     {
@@ -66,7 +66,7 @@
 	    }
 	  else if (! t1.is_scalar_type ())
 	    {
-	      tree_constant t2 = t1.all ();
+	      octave_value t2 = t1.all ();
 	      if (! error_state)
 		t1 = t2.all ();
 	    }
@@ -99,11 +99,11 @@
   panic_impossible ();
 }
 
-tree_constant
+octave_value
 tree_expression::eval (bool /* print */)
 {
   panic ("invalid evaluation of generic expression");
-  return tree_constant ();
+  return octave_value ();
 }
 
 /*
diff --git a/src/pt-exp-base.h b/src/pt-exp-base.h
--- a/src/pt-exp-base.h
+++ b/src/pt-exp-base.h
@@ -27,7 +27,7 @@
 #pragma interface
 #endif
 
-class tree_constant;
+class octave_value;
 
 #include "pt-base.h"
 
@@ -112,7 +112,7 @@
 
   virtual void mark_for_possible_ans_assign (void);
 
-  virtual tree_constant eval (bool print) = 0;
+  virtual octave_value eval (bool print) = 0;
 
 protected:
   type etype;
diff --git a/src/pt-exp.cc b/src/pt-exp.cc
--- a/src/pt-exp.cc
+++ b/src/pt-exp.cc
@@ -59,10 +59,10 @@
   delete id;
 }
 
-tree_constant
+octave_value
 tree_prefix_expression::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -77,7 +77,7 @@
 	  retval = id->eval (print);
 	  if (error_state)
 	    {
-	      retval = tree_constant ();
+	      retval = octave_value ();
 	      if (error_state)
 		eval_error ();
 	    }
@@ -143,10 +143,10 @@
   delete id;
 }
 
-tree_constant
+octave_value
 tree_postfix_expression::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -157,7 +157,7 @@
       id->bump_value (etype);
       if (error_state)
 	{
-	  retval = tree_constant ();
+	  retval = octave_value ();
 	  if (error_state)
 	    eval_error ();
 	}
@@ -217,13 +217,13 @@
 
 // Unary expressions.
 
-tree_constant
+octave_value
 tree_unary_expression::eval (bool /* print */)
 {
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
-  tree_constant retval;
+  octave_value retval;
 
   switch (etype)
     {
@@ -233,7 +233,7 @@
     case tree_expression::transpose:
       if (op)
 	{
-	  tree_constant u = op->eval (false);
+	  octave_value u = op->eval (false);
 	  if (error_state)
 	    eval_error ();
 	  else if (u.is_defined ())
@@ -241,7 +241,7 @@
 	      retval = do_unary_op (u, etype);
 	      if (error_state)
 		{
-		  retval = tree_constant ();
+		  retval = octave_value ();
 		  if (error_state)
 		    eval_error ();
 		}
@@ -335,13 +335,13 @@
 
 // Binary expressions.
  
-tree_constant
+octave_value
 tree_binary_expression::eval (bool /* print */)
 {
   if (error_state)
-    return tree_constant ();
+    return octave_value ();
 
-  tree_constant retval;
+  octave_value retval;
 
   switch (etype)
     {
@@ -365,12 +365,12 @@
     case tree_expression::or:
       if (op1)
 	{
-	  tree_constant a = op1->eval (false);
+	  octave_value a = op1->eval (false);
 	  if (error_state)
 	    eval_error ();
 	  else if (a.is_defined () && op2)
 	    {
-	      tree_constant b = op2->eval (false);
+	      octave_value b = op2->eval (false);
 	      if (error_state)
 		eval_error ();
 	      else if (b.is_defined ())
@@ -378,7 +378,7 @@
 		  retval = do_binary_op (a, b, etype);
 		  if (error_state)
 		    {
-		      retval = tree_constant ();
+		      retval = octave_value ();
 		      if (error_state)
 			eval_error ();
 		    }
@@ -393,7 +393,7 @@
 	bool result = false;
 	if (op1)
 	  {
-	    tree_constant a = op1->eval (false);
+	    octave_value a = op1->eval (false);
 	    if (error_state)
 	      {
 		eval_error ();
@@ -426,7 +426,7 @@
 
 	    if (op2)
 	      {
-		tree_constant b = op2->eval (false);
+		octave_value b = op2->eval (false);
 		if (error_state)
 		  {
 		    eval_error ();
@@ -442,7 +442,7 @@
 	      }
 	  }
       done:
-	retval = tree_constant ((double) result);
+	retval = octave_value ((double) result);
       }
       break;
 
@@ -628,19 +628,19 @@
   return lhs->ident ();
 }
 
-tree_constant
+octave_value
 tree_simple_assignment_expression::eval (bool print)
 {
   assert (etype == tree_expression::assignment);
 
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
 
   if (rhs)
     {
-      tree_constant rhs_val = rhs->eval (false);
+      octave_value rhs_val = rhs->eval (false);
       if (error_state)
 	{
 	  eval_error ();
@@ -660,7 +660,7 @@
 	{
 	  // Extract the arguments into a simple vector.
 
-	  Octave_object args = index->convert_to_const_vector ();
+	  octave_value_list args = index->convert_to_const_vector ();
 
 	  if (error_state)
 	    eval_error ();
@@ -757,15 +757,15 @@
   return retval;
 }
 
-tree_constant
+octave_value
 tree_colon_expression::eval (bool /* print */)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state || ! op1 || ! op2)
     return retval;
 
-  tree_constant tmp = op1->eval (false);
+  octave_value tmp = op1->eval (false);
 
   if (tmp.is_undefined ())
     {
@@ -820,13 +820,13 @@
 	}
     }
 
-  retval = tree_constant (base, limit, inc);
+  retval = octave_value (base, limit, inc);
 
   if (error_state)
     {
       if (error_state)
 	eval_error ("evaluating colon expression");
-      return tree_constant ();
+      return octave_value ();
     }
 
   return retval;
diff --git a/src/pt-exp.h b/src/pt-exp.h
--- a/src/pt-exp.h
+++ b/src/pt-exp.h
@@ -51,7 +51,7 @@
 
   ~tree_prefix_expression (void);
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   void eval_error (void);
 
@@ -81,7 +81,7 @@
 
   ~tree_postfix_expression (void);
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   void eval_error (void);
 
@@ -109,7 +109,7 @@
   ~tree_unary_expression (void)
     { delete op; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   void eval_error (void);
 
@@ -140,7 +140,7 @@
       delete op2;
     }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   void eval_error (void);
 
@@ -210,7 +210,7 @@
   bool is_ans_assign (void)
     { return ans_ass; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   bool is_assignment_expression (void) const
     { return true; }
@@ -254,7 +254,7 @@
 
   tree_colon_expression *chain (tree_expression *t);
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   void eval_error (const char *s);
 
diff --git a/src/pt-fcn.cc b/src/pt-fcn.cc
--- a/src/pt-fcn.cc
+++ b/src/pt-fcn.cc
@@ -65,12 +65,12 @@
 void
 tree_function::bind_nargin_and_nargout (int nargin, int nargout)
 {
-  tree_constant *tmp;
+  octave_value *tmp;
 
-  tmp = new tree_constant (nargin);
+  tmp = new octave_value (nargin);
   nargin_sr->define (tmp);
 
-  tmp = new tree_constant (nargout);
+  tmp = new octave_value (nargout);
   nargout_sr->define (tmp);
 }
 
@@ -157,10 +157,10 @@
   return (param_list && param_list->takes_varargs ());
 }
 
-tree_constant
+octave_value
 tree_function::octave_va_arg (void)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (curr_va_arg_number < num_args_passed)
     retval = args_passed (curr_va_arg_number++);
@@ -171,10 +171,10 @@
   return retval;
 }
 
-Octave_object
+octave_value_list
 tree_function::octave_all_va_args (void)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   retval.resize (num_args_passed - num_named_args);
 
@@ -192,7 +192,7 @@
 }
 
 void
-tree_function::octave_vr_val (const tree_constant& val)
+tree_function::octave_vr_val (const octave_value& val)
 {
   assert (vr_list);
 
@@ -205,16 +205,16 @@
   fcn_name = s;
 }
 
-tree_constant
+octave_value
 tree_function::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state || ! cmd_list)
     return retval;
 
-  Octave_object tmp_args;
-  Octave_object tmp = eval (print, 0, tmp_args);
+  octave_value_list tmp_args;
+  octave_value_list tmp = eval (print, 0, tmp_args);
 
   if (! error_state && tmp.length () > 0)
     retval = tmp(0);
@@ -246,10 +246,10 @@
   tmp->clear ();
 }
 
-Octave_object
-tree_function::eval (bool /* print */, int nargout, const Octave_object& args)
+octave_value_list
+tree_function::eval (bool /* print */, int nargout, const octave_value_list& args)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (error_state)
     return retval;
@@ -333,7 +333,7 @@
     // Evaluate the commands that make up the function.
 
     bool pf = ! user_pref.silent_functions;
-    tree_constant last_computed_value = cmd_list->eval (pf);
+    octave_value last_computed_value = cmd_list->eval (pf);
 
     if (echo_commands)
       print_code_function_trailer ();
@@ -356,7 +356,7 @@
       {
 	if (nargout > 0 && user_pref.define_all_return_values)
 	  {
-	    tree_constant tmp = builtin_any_variable ("default_return_value");
+	    octave_value tmp = builtin_any_variable ("default_return_value");
 	    if (tmp.is_defined ())
 	      ret_list->initialize_undefined_elements (tmp);
 	  }
@@ -490,7 +490,7 @@
   "va_arg (): return next argument in a function that takes a\n\
 variable number of parameters")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -519,7 +519,7 @@
   "va_start (): reset the pointer to the list of optional arguments\n\
 to the beginning")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -548,7 +548,7 @@
   "vr_val (X): append X to the list of optional return values for a
 function that allows a variable number of return values")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/pt-fcn.h b/src/pt-fcn.h
--- a/src/pt-fcn.h
+++ b/src/pt-fcn.h
@@ -107,22 +107,22 @@
   void octave_va_start (void)
     { curr_va_arg_number = num_named_args; }
 
-  tree_constant octave_va_arg (void);
+  octave_value octave_va_arg (void);
 
-  Octave_object octave_all_va_args (void);
+  octave_value_list octave_all_va_args (void);
 
   bool takes_var_return (void) const;
 
-  void octave_vr_val (const tree_constant& val);
+  void octave_vr_val (const octave_value& val);
 
   void stash_function_name (const string& s);
 
   string function_name (void)
     { return fcn_name; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   void traceback_error (void);
 
@@ -139,7 +139,7 @@
   time_t t_parsed;
   bool system_fcn_file;
   int num_named_args;
-  Octave_object args_passed;
+  octave_value_list args_passed;
   int num_args_passed;
   int curr_va_arg_number;
   tree_va_return_list *vr_list;
diff --git a/src/pt-fvc-base.cc b/src/pt-fvc-base.cc
--- a/src/pt-fvc-base.cc
+++ b/src/pt-fvc-base.cc
@@ -39,11 +39,11 @@
 
 // A base class for objects that can be evaluated with argument lists.
 
-tree_constant
-tree_fvc::assign (tree_constant&, const Octave_object&)
+octave_value
+tree_fvc::assign (octave_value&, const octave_value_list&)
 {
   panic_impossible ();
-  return tree_constant ();
+  return octave_value ();
 }
 
 string
@@ -60,10 +60,10 @@
   panic_impossible ();
 }
 
-tree_constant
+octave_value
 tree_fvc::lookup_map_element (SLList<string>&, bool, bool)
 {
-  static tree_constant retval;
+  static octave_value retval;
 
   int l = line ();
   int c = column ();
diff --git a/src/pt-fvc-base.h b/src/pt-fvc-base.h
--- a/src/pt-fvc-base.h
+++ b/src/pt-fvc-base.h
@@ -35,8 +35,8 @@
 
 #include <SLList.h>
 
-class tree_constant;
-class Octave_object;
+class octave_value;
+class octave_value_list;
 
 #include "pt-mvr-base.h"
 
@@ -50,14 +50,14 @@
 
   ~tree_fvc (void) { }
 
-  virtual tree_constant assign (tree_constant& t,
-				const Octave_object& args);
+  virtual octave_value assign (octave_value& t,
+				const octave_value_list& args);
 
   virtual string name (void) const;
 
   virtual void bump_value (tree_expression::type);
 
-  virtual tree_constant lookup_map_element (SLList<string>& list,
+  virtual octave_value lookup_map_element (SLList<string>& list,
 					    bool insert = false,
 					    bool silent = false);
 
diff --git a/src/pt-fvc.cc b/src/pt-fvc.cc
--- a/src/pt-fvc.cc
+++ b/src/pt-fvc.cc
@@ -79,7 +79,7 @@
 // Are any of the arguments `:'?
 
 static bool
-any_arg_is_magic_colon (const Octave_object& args)
+any_arg_is_magic_colon (const octave_value_list& args)
 {
   int nargin = args.length ();
 
@@ -102,7 +102,7 @@
 }
 
 tree_identifier *
-tree_identifier::define (tree_constant *t)
+tree_identifier::define (octave_value *t)
 {
   int status = sym->define (t);
   return status ? this : 0;
@@ -122,10 +122,10 @@
     sym->document (s);
 }
 
-tree_constant
-tree_identifier::assign (tree_constant& rhs)
+octave_value
+tree_identifier::assign (octave_value& rhs)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (rhs.is_defined ())
     {
@@ -142,7 +142,7 @@
 	  sym->clear ();
 	}
 
-      tree_constant *tmp = new tree_constant (rhs);
+      octave_value *tmp = new octave_value (rhs);
 
       if (sym->define (tmp))
 	retval = rhs;
@@ -153,10 +153,10 @@
   return retval;
 }
 
-tree_constant
-tree_identifier::assign (tree_constant& rhs, const Octave_object& args)
+octave_value
+tree_identifier::assign (octave_value& rhs, const octave_value_list& args)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (rhs.is_defined ())
     {
@@ -189,7 +189,7 @@
 	    }
 	  else
 	    {
-	      tree_constant *tmp = new tree_constant ();
+	      octave_value *tmp = new octave_value ();
 	      retval = tmp->assign (rhs, args);
 	      if (retval.is_defined ())
 		sym->define (tmp);
@@ -200,10 +200,10 @@
   return retval;
 }
 
-tree_constant
-tree_identifier::assign (SLList<string> list, tree_constant& rhs)
+octave_value
+tree_identifier::assign (SLList<string> list, octave_value& rhs)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (rhs.is_defined ())
     {
@@ -212,12 +212,12 @@
 
       tree_fvc *curr_val = sym->def ();
 
-      tree_constant *tmp = 0;
+      octave_value *tmp = 0;
       if (curr_val && curr_val->is_constant ())
-	tmp = (tree_constant *) curr_val;
+	tmp = (octave_value *) curr_val;
       else
 	{
-	  tmp = new tree_constant ();
+	  tmp = new octave_value ();
 	  if (! sym->define (tmp))
 	    {
 	      delete tmp;
@@ -232,11 +232,11 @@
   return retval;
 }
 
-tree_constant
-tree_identifier::assign (SLList<string> list, tree_constant& rhs,
-			 const Octave_object& args)
+octave_value
+tree_identifier::assign (SLList<string> list, octave_value& rhs,
+			 const octave_value_list& args)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (rhs.is_defined ())
     {
@@ -247,9 +247,9 @@
 	{
 	  tree_fvc *curr_val = sym->def ();
 
-	  tree_constant *tmp;
+	  octave_value *tmp;
 	  if (curr_val && curr_val->is_constant ())
-	    tmp = (tree_constant *) curr_val;
+	    tmp = (octave_value *) curr_val;
 	  else
 	    panic_impossible ();
 
@@ -266,7 +266,7 @@
 	    }
 	  else
 	    {
-	      tree_constant *tmp = new tree_constant ();
+	      octave_value *tmp = new octave_value ();
 
 	      retval = tmp->assign_map_element (list, rhs, args);
 
@@ -359,10 +359,10 @@
     sym->mark_as_formal_parameter ();
 }
 
-tree_constant
+octave_value
 tree_identifier::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -379,8 +379,8 @@
 
 	  if (nargout)
 	    {
-	      Octave_object tmp_args;
-	      Octave_object tmp = object_to_eval->eval (0, nargout, tmp_args);
+	      octave_value_list tmp_args;
+	      octave_value_list tmp = object_to_eval->eval (0, nargout, tmp_args);
 
 	      if (tmp.length () > 0)
 		retval = tmp(0);
@@ -403,10 +403,10 @@
   return retval;
 }
 
-Octave_object
-tree_identifier::eval (bool print, int nargout, const Octave_object& args)
+octave_value_list
+tree_identifier::eval (bool print, int nargout, const octave_value_list& args)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (error_state)
     return retval;
@@ -491,10 +491,10 @@
     }
 }
 
-tree_constant
-tree_indirect_ref::assign (tree_constant& t)
+octave_value
+tree_indirect_ref::assign (octave_value& t)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (refs.empty ())
     retval = id->assign (t);
@@ -504,10 +504,10 @@
   return retval;
 }
 
-tree_constant
-tree_indirect_ref::assign (tree_constant& t, const Octave_object& args)
+octave_value
+tree_indirect_ref::assign (octave_value& t, const octave_value_list& args)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (refs.empty ())
     retval = id->assign (t, args);
@@ -517,10 +517,10 @@
   return retval;
 }
 
-tree_constant
+octave_value
 tree_indirect_ref::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -549,10 +549,10 @@
   return retval;
 }
 
-Octave_object
-tree_indirect_ref::eval (bool print, int nargout, const Octave_object& args)
+octave_value_list
+tree_indirect_ref::eval (bool print, int nargout, const octave_value_list& args)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (error_state)
     return retval;
@@ -569,7 +569,7 @@
 
       if (object_to_eval)
 	{
-	  tree_constant tmp = object_to_eval->lookup_map_element (refs);
+	  octave_value tmp = object_to_eval->lookup_map_element (refs);
 
 	  if (! error_state)
 	    {
@@ -632,18 +632,18 @@
   my_name = nm;
 }
 
-tree_constant
+octave_value
 tree_builtin::eval (bool /* print */)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
 
   if (fcn)
     {
-      Octave_object args;
-      Octave_object tmp = (*fcn) (args, 0);
+      octave_value_list args;
+      octave_value_list tmp = (*fcn) (args, 0);
       if (tmp.length () > 0)
 	retval = tmp(0);
     }
@@ -657,11 +657,11 @@
   return retval;
 }
 
-static tree_constant
-apply_mapper_fcn (const tree_constant& arg, Mapper_fcn& m_fcn,
+static octave_value
+apply_mapper_fcn (const octave_value& arg, Mapper_fcn& m_fcn,
 		  bool /* print */)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (arg.is_real_type ())
     {
@@ -744,10 +744,10 @@
   return retval;
 }
 
-Octave_object
-tree_builtin::eval (bool /* print */, int nargout, const Octave_object& args)
+octave_value_list
+tree_builtin::eval (bool /* print */, int nargout, const octave_value_list& args)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (error_state)
     return retval;
@@ -770,7 +770,7 @@
 //      else
       if (nargin > 0 && args(0).is_defined ())
 	{
-	  tree_constant tmp = apply_mapper_fcn (args(0), mapper_fcn, 0);
+	  octave_value tmp = apply_mapper_fcn (args(0), mapper_fcn, 0);
 	  retval(0) = tmp;
 	}
       else
diff --git a/src/pt-fvc.h b/src/pt-fvc.h
--- a/src/pt-fvc.h
+++ b/src/pt-fvc.h
@@ -59,17 +59,17 @@
 
   string name (void) const;
 
-  tree_identifier *define (tree_constant *t);
+  tree_identifier *define (octave_value *t);
   tree_identifier *define (tree_function *t);
 
   void document (const string& s);
 
-  tree_constant assign (tree_constant& t);
-  tree_constant assign (tree_constant& t, const Octave_object& args);
+  octave_value assign (octave_value& t);
+  octave_value assign (octave_value& t, const octave_value_list& args);
 
-  tree_constant assign (SLList<string> list, tree_constant& t);
-  tree_constant assign (SLList<string> list, tree_constant& t,
-			const Octave_object& args); 
+  octave_value assign (SLList<string> list, octave_value& t);
+  octave_value assign (SLList<string> list, octave_value& t,
+			const octave_value_list& args); 
 
   bool is_defined (void);
 
@@ -84,9 +84,9 @@
   void mark_for_possible_ans_assign (void)
     { maybe_do_ans_assign = true; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   void eval_undefined_error (void);
 
@@ -127,15 +127,15 @@
 
   string name (void) const;
 
-  tree_constant assign (tree_constant& t);
-  tree_constant assign (tree_constant& t, const Octave_object& args);
+  octave_value assign (octave_value& t);
+  octave_value assign (octave_value& t, const octave_value_list& args);
 
   void mark_for_possible_ans_assign (void)
     { id->mark_for_possible_ans_assign (); }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   void print_code (ostream& os);
 
@@ -164,9 +164,9 @@
   bool is_mapper_function (void) const
     { return is_mapper; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   string name (void) const
     { return my_name; }
diff --git a/src/pt-mat.cc b/src/pt-mat.cc
--- a/src/pt-mat.cc
+++ b/src/pt-mat.cc
@@ -53,16 +53,16 @@
 private:
 
   class
-  tm_row_const_rep : public SLList<tree_constant>
+  tm_row_const_rep : public SLList<octave_value>
   {
   public:
 
     tm_row_const_rep (void)
-      : SLList<tree_constant> (), count (1), nr (0), nc (0),
+      : SLList<octave_value> (), count (1), nr (0), nc (0),
 	all_str (false), is_cmplx (false), ok (false) { }
 
     tm_row_const_rep (const tree_matrix_row& mr)
-      : SLList<tree_constant> (), count (1), nr (0), nc (0),
+      : SLList<octave_value> (), count (1), nr (0), nc (0),
 	all_str (false), is_cmplx (false), ok (false)
         { init (mr); }
 
@@ -129,9 +129,9 @@
   bool all_strings (void) const { return rep->all_str; }
   bool is_complex (void) const { return rep->is_cmplx; }
 
-  tree_constant& operator () (Pix p) { return rep->operator () (p); }
+  octave_value& operator () (Pix p) { return rep->operator () (p); }
 
-  const tree_constant& operator () (Pix p) const
+  const octave_value& operator () (Pix p) const
     { return rep->operator () (p); }
 
   Pix first (void) const { return rep->first (); }
@@ -160,7 +160,7 @@
     {
       tree_expression *elt = mr (p);
 
-      tree_constant tmp = elt->eval (false);
+      octave_value tmp = elt->eval (false);
 
       if (error_state || tmp.is_undefined ())
 	break;
@@ -431,10 +431,10 @@
 // Less ugly than before, anyway.
 // Looking better all the time.
 
-tree_constant
+octave_value
 tree_matrix::eval (bool /* print */)
 {
-  tree_constant retval;
+  octave_value retval;
 
   tm_const tmp (*this);
 
@@ -470,7 +470,7 @@
 
 	  for (Pix q = row.first (); q != 0; row.next (q))
 	    {
-	      tree_constant elt = row (q);
+	      octave_value elt = row (q);
 
 	      if (found_complex)
 		{
@@ -515,7 +515,7 @@
 		}
 
 	      if (all_strings && chm.rows () > 0 && chm.cols () > 0)
-		retval = tree_constant (chm, true);
+		retval = octave_value (chm, true);
 	      else if (found_complex)
 		retval = cm;
 	      else
diff --git a/src/pt-mat.h b/src/pt-mat.h
--- a/src/pt-mat.h
+++ b/src/pt-mat.h
@@ -29,7 +29,7 @@
 
 class ostream;
 
-class tree_constant;
+class octave_value;
 class tree_return_list;
 
 #include <SLList.h>
@@ -75,7 +75,7 @@
 
   bool is_matrix_constant (void) const;
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
   void print_code (ostream& os);
 };
diff --git a/src/pt-misc.cc b/src/pt-misc.cc
--- a/src/pt-misc.cc
+++ b/src/pt-misc.cc
@@ -116,11 +116,11 @@
     }
 }
 
-tree_constant
+octave_value
 tree_statement_list::eval (bool print)
 {
   bool pf;
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -147,7 +147,7 @@
 	    retval = expr->eval (pf);
 
 	  if (error_state)
-	    return tree_constant ();
+	    return octave_value ();
 
 	  if (breaking || continuing)
 	    break;
@@ -156,15 +156,15 @@
 	    break;
 	}
       else
-	retval = tree_constant ();
+	retval = octave_value ();
     }
   return retval;
 }
 
-Octave_object
+octave_value_list
 tree_statement_list::eval (bool print, int nargout)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (nargout > 1)
     {
@@ -195,7 +195,7 @@
 		{
 		  if (expr->is_multi_val_ret_expression ())
 		    {
-		      Octave_object args;
+		      octave_value_list args;
 		      tree_multi_val_ret *t = (tree_multi_val_ret *) expr;
 		      retval = t->eval (pf, nargout, args);
 		    }
@@ -204,7 +204,7 @@
 		}
 
 	      if (error_state)
-		return tree_constant ();
+		return octave_value ();
 
 	      if (breaking || continuing)
 		break;
@@ -213,7 +213,7 @@
 		break;
 	    }
 	  else
-	    retval = Octave_object ();
+	    retval = octave_value_list ();
 	}
       return retval;
     }
@@ -235,7 +235,7 @@
     }
 }
 
-Octave_object
+octave_value_list
 tree_argument_list::convert_to_const_vector (void)
 {
   int len = length ();
@@ -244,7 +244,7 @@
   // needs to be even when we have a list containing an all_va_args
   // token.
 
-  Octave_object args;
+  octave_value_list args;
   args.resize (len);
 
   Pix p = first ();
@@ -254,11 +254,11 @@
       tree_expression *elt = this->operator () (p);
       if (elt)
 	{
-	  tree_constant tmp = elt->eval (false);
+	  octave_value tmp = elt->eval (false);
 	  if (error_state)
 	    {
 	      ::error ("evaluating argument list element number %d", k);
-	      args = Octave_object ();
+	      args = octave_value_list ();
 	      break;
 	    }
 	  else
@@ -267,7 +267,7 @@
 		{
 		  if (curr_function)
 		    {
-		      Octave_object tva;
+		      octave_value_list tva;
 		      tva = curr_function->octave_all_va_args ();
 		      int n = tva.length ();
 		      for (int i = 0; i < n; i++)
@@ -276,7 +276,7 @@
 		  else
 		    {
 		      ::error ("all_va_args is only valid inside functions");
-		      args = Octave_object ();
+		      args = octave_value_list ();
 		      break;
 		    }
 		}
@@ -287,7 +287,7 @@
 	}
       else
 	{
-	  args(j++) = tree_constant ();
+	  args(j++) = octave_value ();
 	  break;
 	}
     }
@@ -340,7 +340,7 @@
 }
 
 void
-tree_parameter_list::initialize_undefined_elements (tree_constant& val)
+tree_parameter_list::initialize_undefined_elements (octave_value& val)
 {
   for (Pix p = first (); p != 0; next (p))
     {
@@ -351,7 +351,7 @@
 }
 
 void
-tree_parameter_list::define_from_arg_vector (const Octave_object& args)
+tree_parameter_list::define_from_arg_vector (const octave_value_list& args)
 {
   int nargin = args.length ();
 
@@ -366,7 +366,7 @@
     {
       tree_identifier *elt = this->operator () (p);
 
-      tree_constant *tmp = 0;
+      octave_value *tmp = 0;
 
       if (i < nargin)
 	{
@@ -375,7 +375,7 @@
 	      ::error ("invalid use of colon in function argument list");
 	      return;
 	    }
-	  tmp = new tree_constant (args(i));
+	  tmp = new octave_value (args(i));
 	}
 
       elt->define (tmp);
@@ -384,7 +384,7 @@
     }
 }
 
-Octave_object
+octave_value_list
 tree_parameter_list::convert_to_const_vector (tree_va_return_list *vr_list)
 {
   int nout = length ();
@@ -392,7 +392,7 @@
   if (vr_list)
     nout += vr_list->length ();
 
-  Octave_object retval;
+  octave_value_list retval;
   retval.resize (nout);
 
   int i = 0;
diff --git a/src/pt-misc.h b/src/pt-misc.h
--- a/src/pt-misc.h
+++ b/src/pt-misc.h
@@ -29,8 +29,8 @@
 
 class ostream;
 
-class Octave_object;
-class tree_constant;
+class octave_value_list;
+class octave_value;
 class tree_command;
 class tree_expression;
 class tree_simple_assignment_expression;
@@ -116,9 +116,9 @@
 
   void mark_as_function_body (void) { function_body = true; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout);
+  octave_value_list eval (bool print, int nargout);
 
   void print_code (ostream& os);
 
@@ -149,7 +149,7 @@
 	}
     }
 
-  Octave_object convert_to_const_vector (void);
+  octave_value_list convert_to_const_vector (void);
 
   void print_code (ostream& os);
 };
@@ -189,13 +189,13 @@
   bool varargs_only (void)
     { return (marked_for_varargs < 0); }
 
-  void initialize_undefined_elements (tree_constant& val);
+  void initialize_undefined_elements (octave_value& val);
 
-  void define_from_arg_vector (const Octave_object& args);
+  void define_from_arg_vector (const octave_value_list& args);
 
   bool is_defined (void);
 
-  Octave_object convert_to_const_vector (tree_va_return_list *vr_list);
+  octave_value_list convert_to_const_vector (tree_va_return_list *vr_list);
 
   void print_code (ostream& os);
 
@@ -224,10 +224,10 @@
 };
 
 class
-tree_va_return_list : public SLList<tree_constant>
+tree_va_return_list : public SLList<octave_value>
 {
 public:
-  tree_va_return_list (void) : SLList<tree_constant> () { }
+  tree_va_return_list (void) : SLList<octave_value> () { }
 
   ~tree_va_return_list (void) { }
 };
diff --git a/src/pt-mvr-base.cc b/src/pt-mvr-base.cc
--- a/src/pt-mvr-base.cc
+++ b/src/pt-mvr-base.cc
@@ -34,11 +34,11 @@
 
 // A base class for objects that can be return multiple values
 
-tree_constant
+octave_value
 tree_multi_val_ret::eval (bool /* print */)
 {
   panic ("invalid evaluation of generic expression");
-  return tree_constant ();
+  return octave_value ();
 }
 
 /*
diff --git a/src/pt-mvr-base.h b/src/pt-mvr-base.h
--- a/src/pt-mvr-base.h
+++ b/src/pt-mvr-base.h
@@ -27,8 +27,8 @@
 #pragma interface
 #endif
 
-class tree_constant;
-class Octave_object;
+class octave_value;
+class octave_value_list;
 
 #include "pt-exp-base.h"
 
@@ -48,10 +48,10 @@
   bool is_multi_val_ret_expression (void) const
     { return true; }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  virtual Octave_object eval (bool print, int nargout,
-			      const Octave_object& args) = 0;
+  virtual octave_value_list eval (bool print, int nargout,
+			      const octave_value_list& args) = 0;
 };
 
 #endif
diff --git a/src/pt-mvr.cc b/src/pt-mvr.cc
--- a/src/pt-mvr.cc
+++ b/src/pt-mvr.cc
@@ -46,7 +46,7 @@
 // Make sure that all arguments have values.
 
 static bool
-all_args_defined (const Octave_object& args)
+all_args_defined (const octave_value_list& args)
 {
   int nargin = args.length ();
 
@@ -59,15 +59,15 @@
 
 // Used internally.
 
-tree_constant
+octave_value
 tree_oct_obj::eval (bool /* print */)
 {
   return values(0);
 }
 
-Octave_object
+octave_value_list
 tree_oct_obj::eval (bool /* print */, int /* nargout */,
-		    const Octave_object& /* args */)
+		    const octave_value_list& /* args */)
 {
   return values;
 }
@@ -109,10 +109,10 @@
     id->mark_for_possible_ans_assign ();
 }
 
-tree_constant
+octave_value
 tree_index_expression::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
@@ -122,7 +122,7 @@
       // Extract the arguments into a simple vector.  Don't pass null
       // args.
 
-      Octave_object args = list->convert_to_const_vector ();
+      octave_value_list args = list->convert_to_const_vector ();
 
       if (error_state)
 	eval_error ();
@@ -134,7 +134,7 @@
 	    {
 	      if (all_args_defined (args))
 		{
-		  Octave_object tmp = id->eval (print, 1, args);
+		  octave_value_list tmp = id->eval (print, 1, args);
 
 		  if (error_state)
 		    eval_error ();
@@ -160,11 +160,11 @@
   return retval;
 }
 
-Octave_object
+octave_value_list
 tree_index_expression::eval (bool print, int nargout,
-			     const Octave_object& /* args */)
+			     const octave_value_list& /* args */)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (error_state)
     return retval;
@@ -174,7 +174,7 @@
       // Extract the arguments into a simple vector.  Don't pass null
       // args.
 
-      Octave_object tmp_args = list->convert_to_const_vector ();
+      octave_value_list tmp_args = list->convert_to_const_vector ();
 
       if (error_state)
 	eval_error ();
@@ -201,7 +201,7 @@
     }
   else
     {
-      Octave_object tmp_args;
+      octave_value_list tmp_args;
 
       retval = id->eval (print, nargout, tmp_args);
 
@@ -271,16 +271,16 @@
   delete rhs;
 }
 
-tree_constant
+octave_value
 tree_multi_assignment_expression::eval (bool print)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (error_state)
     return retval;
 
-  Octave_object tmp_args;
-  Octave_object result = eval (print, 1, tmp_args);
+  octave_value_list tmp_args;
+  octave_value_list result = eval (print, 1, tmp_args);
 
   if (result.length () > 0)
     retval = result(0);
@@ -288,18 +288,18 @@
   return retval;
 }
 
-Octave_object
+octave_value_list
 tree_multi_assignment_expression::eval (bool print, int nargout,
-					const Octave_object& /* args */)
+					const octave_value_list& /* args */)
 {
   assert (etype == tree_expression::multi_assignment);
 
   if (error_state || ! rhs)
-    return Octave_object ();
+    return octave_value_list ();
 
   nargout = lhs->length ();
-  Octave_object tmp_args;
-  Octave_object results = rhs->eval (0, nargout, tmp_args);
+  octave_value_list tmp_args;
+  octave_value_list results = rhs->eval (0, nargout, tmp_args);
 
   if (error_state)
     eval_error ();
@@ -323,7 +323,7 @@
 	      // works, but maybe we should have the option of
 	      // skipping the assignment instead.
 
-	      tree_constant *tmp = 0;
+	      octave_value *tmp = 0;
 	      if (results(i).is_undefined ())
 		{
 		  error ("element number %d undefined in return list", i+1);
@@ -331,7 +331,7 @@
 		  break;
 		}
 	      else
-		tmp = new tree_constant (results(i));
+		tmp = new octave_value (results(i));
 
 	      tree_simple_assignment_expression tmp_expr
 		(lhs_expr, tmp, 1, 0, ma_line, ma_column);
diff --git a/src/pt-mvr.h b/src/pt-mvr.h
--- a/src/pt-mvr.h
+++ b/src/pt-mvr.h
@@ -29,7 +29,7 @@
 
 class ostream;
 
-class Octave_object;
+class octave_value_list;
 
 class tree_argument_list;
 class tree_identifier;
@@ -51,19 +51,19 @@
 public:
   tree_oct_obj (int l = -1, int c = -1) : tree_multi_val_ret (l, c) { }
 
-  tree_oct_obj (const Octave_object& v, int l = -1, int c = -1)
+  tree_oct_obj (const octave_value_list& v, int l = -1, int c = -1)
     : tree_multi_val_ret (l, c), values (v) { }
 
   ~tree_oct_obj (void) { }
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   void print_code (ostream&) { }
 
 private:
-  Octave_object values;
+  octave_value_list values;
 };
 
 // Index expressions.
@@ -102,9 +102,9 @@
 
   void mark_for_possible_ans_assign (void);
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   void eval_error (void);
 
@@ -134,9 +134,9 @@
 
   ~tree_multi_assignment_expression (void);
 
-  tree_constant eval (bool print);
+  octave_value eval (bool print);
 
-  Octave_object eval (bool print, int nargout, const Octave_object& args);
+  octave_value_list eval (bool print, int nargout, const octave_value_list& args);
 
   bool is_assignment_expression (void) const
     { return true; }
diff --git a/src/pt-plot.cc b/src/pt-plot.cc
--- a/src/pt-plot.cc
+++ b/src/pt-plot.cc
@@ -404,7 +404,7 @@
 
   if (lower)
     {
-      tree_constant lower_val = lower->eval (false);
+      octave_value lower_val = lower->eval (false);
       if (error_state)
 	{
 	  ::error ("evaluating lower bound of plot range");
@@ -421,7 +421,7 @@
 
   if (upper)
     {
-      tree_constant upper_val = upper->eval (false);
+      octave_value upper_val = upper->eval (false);
       if (error_state)
 	{
 	  ::error ("evaluating upper bound of plot range");
@@ -472,7 +472,7 @@
     {
       if (x[i])
 	{
-	  tree_constant tmp = x[i]->eval (false);
+	  octave_value tmp = x[i]->eval (false);
 	  if (error_state)
 	    {
 	      ::error ("evaluating plot using command");
@@ -599,7 +599,7 @@
 
       if (linetype)
 	{
-	  tree_constant tmp = linetype->eval (false);
+	  octave_value tmp = linetype->eval (false);
 	  if (! error_state && tmp.is_defined ())
 	    {
 	      double val = tmp.double_value ();
@@ -620,7 +620,7 @@
 
       if (pointtype)
 	{
-	  tree_constant tmp = pointtype->eval (false);
+	  octave_value tmp = pointtype->eval (false);
 	  if (! error_state && tmp.is_defined ())
 	    {
 	      double val = tmp.double_value ();
@@ -678,24 +678,24 @@
   delete style_clause;
 }
 
-tree_constant
-subplot::extract_plot_data (int ndim, tree_constant& data)
+octave_value
+subplot::extract_plot_data (int ndim, octave_value& data)
 {
-  tree_constant retval;
+  octave_value retval;
 
   if (using_clause)
     {
       ColumnVector val = using_clause->values (ndim);
 
-      Octave_object args;
+      octave_value_list args;
       args(1) = val;
-      args(0) = tree_constant::magic_colon_t;
+      args(0) = octave_value::magic_colon_t;
 
-      Octave_object tmp = data.eval (0, 1, args);
+      octave_value_list tmp = data.eval (0, 1, args);
       retval = tmp(0);
 
       if (error_state)
-	return tree_constant ();
+	return octave_value ();
     }
   else
     {
@@ -710,7 +710,7 @@
 	{
 	  error ("plots with errorbars require 3 or 4 columns of data");
 	  error ("but %d were provided", nc);
-	  return tree_constant ();
+	  return octave_value ();
 	}
     }
 
@@ -722,7 +722,7 @@
 {
   if (plot_data)
     {
-      tree_constant data = plot_data->eval (false);
+      octave_value data = plot_data->eval (false);
 
       if (! error_state && data.is_defined ())
 	{
@@ -767,7 +767,7 @@
 	      // Eliminate the need for printing a using clause to
 	      // plot_buf.
 
-	      tree_constant tmp_data = extract_plot_data (ndim, data);
+	      octave_value tmp_data = extract_plot_data (ndim, data);
 
 	      if (tmp_data.is_defined ())
 		{
@@ -814,7 +814,7 @@
 
   if (title_clause)
     {
-      tree_constant tmp = title_clause->eval (false);
+      octave_value tmp = title_clause->eval (false);
       if (! error_state && tmp.is_string ())
 	plot_buf << " " << GNUPLOT_COMMAND_TITLE << " "
 	  << '"' << tmp.string_value () << '"';
@@ -912,7 +912,7 @@
 }
 
 string
-save_in_tmp_file (tree_constant& t, int ndim, bool parametric)
+save_in_tmp_file (octave_value& t, int ndim, bool parametric)
 {
   string name = oct_tempnam ();
 
@@ -991,7 +991,7 @@
 DEFUN (clearplot, , ,
   "clearplot (): clear the plot window")
 {
-  Octave_object retval;
+  octave_value_list retval;
   send_to_plot_stream ("clear\n");
 
   // XXX FIXME XXX -- instead of just clearing these things, it would
@@ -1017,7 +1017,7 @@
 DEFUN (closeplot, , ,
   "closeplot (): close the stream to plotter")
 {
-  Octave_object retval;
+  octave_value_list retval;
   close_plot_stream ();
   return retval;
 }
@@ -1028,7 +1028,7 @@
 determine whether the plot window is cleared before the next line is\n\
 drawn.  With no argument, toggle the current state.") 
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -1071,7 +1071,7 @@
 DEFUN (purge_tmp_files, , ,
   "delete temporary data files used for plotting")
 {
-  Octave_object retval;
+  octave_value_list retval;
   cleanup_tmp_files ();
   return retval;
 }
@@ -1081,7 +1081,7 @@
 \n\
 set plotting options")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -1127,7 +1127,7 @@
 \n\
 show plotting options")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/pt-plot.h b/src/pt-plot.h
--- a/src/pt-plot.h
+++ b/src/pt-plot.h
@@ -202,7 +202,7 @@
       return this;
     }
 
-  tree_constant extract_plot_data (int ndim, tree_constant& data);
+  octave_value extract_plot_data (int ndim, octave_value& data);
 
   int handle_plot_data (int ndim, ostrstream& plot_buf);
 
@@ -233,7 +233,7 @@
   void print_code (ostream& os);
 };
 
-extern string save_in_tmp_file (tree_constant& t, int ndim = 2,
+extern string save_in_tmp_file (octave_value& t, int ndim = 2,
 				bool parametric = false);
 
 extern void mark_for_deletion (const string&);
diff --git a/src/qpsol.cc b/src/qpsol.cc
--- a/src/qpsol.cc
+++ b/src/qpsol.cc
@@ -103,7 +103,7 @@
 
 */
 
-  Octave_object retval;
+  octave_value_list retval;
 
 #if defined (QPSOL_MISSING)
 
@@ -385,10 +385,10 @@
   warning ("qpsol_options: no match for `%s'", keyword.c_str ());
 }
 
-static Octave_object
+static octave_value_list
 show_qpsol_option (const string& keyword)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   QPSOL_OPTIONS *list = qpsol_option_table;
 
@@ -425,7 +425,7 @@
 to the shortest match.")
 #endif
 {
-  Octave_object retval;
+  octave_value_list retval;
 
 #if defined (QPSOL_MISSING)
 
diff --git a/src/qr.cc b/src/qr.cc
--- a/src/qr.cc
+++ b/src/qr.cc
@@ -55,7 +55,7 @@
 qr (X) alone returns the output of the LAPACK routine dgeqrf, such\n\
 that R = triu (qr (X))")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -65,14 +65,14 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int arg_is_empty = empty_arg ("qr", arg.rows (), arg.columns ());
 
   if (arg_is_empty < 0)
     return retval;
   else if (arg_is_empty > 0)
-    return Octave_object (3, Matrix ());
+    return octave_value_list (3, Matrix ());
 
   QR::type type = nargout == 1 ? QR::raw
     : (nargin == 2 ? QR::economy : QR::std);
diff --git a/src/quad.cc b/src/quad.cc
--- a/src/quad.cc
+++ b/src/quad.cc
@@ -50,12 +50,12 @@
 {
   double retval = 0.0;
 
-  Octave_object args;
+  octave_value_list args;
   args(0) = x;
 
   if (quad_fcn)
     {
-      Octave_object tmp = quad_fcn->eval (0, 1, args);
+      octave_value_list tmp = quad_fcn->eval (0, 1, args);
 
       if (error_state)
 	{
@@ -105,7 +105,7 @@
 The optional argument @var{sing} is a vector of values at which the\n\
 integrand is singular.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -332,10 +332,10 @@
   warning ("quad_options: no match for `%s'", keyword.c_str ());
 }
 
-static Octave_object
+static octave_value_list
 show_quad_option (const string& keyword)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   QUAD_OPTIONS *list = quad_option_table;
 
@@ -360,7 +360,7 @@
 Set or show options for quad.  Keywords may be abbreviated\n\
 to the shortest match.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/qzval.cc b/src/qzval.cc
--- a/src/qzval.cc
+++ b/src/qzval.cc
@@ -40,14 +40,14 @@
 compute generalized eigenvalues of the matrix pencil (A - lambda B).\n\
 A and B must be real matrices.")
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nargin = args.length ();
 
   if (nargin == 2)
     {
-      tree_constant arg_a = args(0);
-      tree_constant arg_b = args(1);
+      octave_value arg_a = args(0);
+      octave_value arg_b = args(1);
 
       Matrix a = arg_a.matrix_value ();
       Matrix b = arg_b.matrix_value ();
diff --git a/src/rand.cc b/src/rand.cc
--- a/src/rand.cc
+++ b/src/rand.cc
@@ -150,10 +150,10 @@
   initialized = 1;
 }
 
-static Octave_object
-do_rand (const Octave_object& args, int nargin)
+static octave_value_list
+do_rand (const octave_value_list& args, int nargin)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int n = 0;
   int m = 0;
@@ -167,7 +167,7 @@
     }
   else if (nargin == 1)
     {
-      tree_constant tmp = args(0);
+      octave_value tmp = args(0);
 
       if (tmp.is_string ())
 	{
@@ -341,7 +341,7 @@
 \n\
 See also: randn")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -375,7 +375,7 @@
 \n\
 See also: rand")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/resource.cc b/src/resource.cc
--- a/src/resource.cc
+++ b/src/resource.cc
@@ -80,11 +80,11 @@
 
   tv_tmp ["sec"] = (double) ru.ru_utime.tv_sec;
   tv_tmp ["usec"] = (double) ru.ru_utime.tv_usec;
-  m ["utime"] = tree_constant (tv_tmp);
+  m ["utime"] = octave_value (tv_tmp);
 
   tv_tmp ["sec"] = (double) ru.ru_stime.tv_sec;
   tv_tmp ["usec"] = (double) ru.ru_stime.tv_usec;
-  m ["stime"] = tree_constant (tv_tmp);
+  m ["stime"] = octave_value (tv_tmp);
 
   m ["maxrss"] = (double) ru.ru_maxrss;
   m ["ixrss"] = (double) ru.ru_ixrss;
@@ -118,7 +118,7 @@
 
   tv_tmp ["sec"] = (double) seconds;
   tv_tmp ["usec"] = (double) (fraction * 1e6 / HZ);
-  m ["utime"] = tree_constant (tv_tmp);
+  m ["utime"] = octave_value (tv_tmp);
 
   ticks = t.tms_stime + t.tms_cstime;
   fraction = ticks % HZ;
@@ -126,17 +126,17 @@
 
   tv_tmp ["sec"] = (double) seconds;
   tv_tmp ["usec"] = (double) (fraction * 1e6 / HZ);
-  m ["stime"] = tree_constant (tv_tmp);
+  m ["stime"] = octave_value (tv_tmp);
 
 #else
 
   tv_tmp ["sec"] = 0.0;
   tv_tmp ["usec"] = 0.0;
-  m ["utime"] = tree_constant (tv_tmp);
+  m ["utime"] = octave_value (tv_tmp);
 
   tv_tmp ["sec"] = 0.0;
   tv_tmp ["usec"] = 0.0;
-  m ["stime"] = tree_constant (tv_tmp);
+  m ["stime"] = octave_value (tv_tmp);
 
 #endif
 
@@ -157,7 +157,7 @@
 
 #endif
 
-  return tree_constant (m);
+  return octave_value (m);
 }
 
 /*
diff --git a/src/schur.cc b/src/schur.cc
--- a/src/schur.cc
+++ b/src/schur.cc
@@ -50,7 +50,7 @@
   D = discrete time poles\n\
   U = unordered schur (default)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -60,7 +60,7 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   string ord;
 
@@ -93,7 +93,7 @@
   if (arg_is_empty < 0)
     return retval;
   else if (arg_is_empty > 0)
-    return Octave_object (2, Matrix ());
+    return octave_value_list (2, Matrix ());
 
   if (nr != nc)
     {
diff --git a/src/sort.cc b/src/sort.cc
--- a/src/sort.cc
+++ b/src/sort.cc
@@ -152,10 +152,10 @@
       ms.elem (i, j) = m.elem (k-1, j); \
     }
 
-static Octave_object
+static octave_value_list
 mx_sort (const Matrix& m)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nr = m.rows ();
   int nc = m.columns ();
@@ -188,10 +188,10 @@
   return retval;
 }
 
-static Octave_object
+static octave_value_list
 mx_sort (const RowVector& v)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int n = v.capacity ();
 
@@ -214,16 +214,16 @@
       VECTOR_CREATE_RETURN_VALUES (vs, v);
     }
 
-  retval (1) = tree_constant (idx, 0);
-  retval (0) = tree_constant (vs, 0);
+  retval (1) = octave_value (idx, 0);
+  retval (0) = octave_value (vs, 0);
 
   return retval;
 }
 
-static Octave_object
+static octave_value_list
 mx_sort (const ComplexMatrix& cm)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nr = cm.rows ();
   int nc = cm.columns ();
@@ -266,10 +266,10 @@
   return retval;
 }
 
-static Octave_object
+static octave_value_list
 mx_sort (ComplexRowVector& cv)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int n = cv.capacity ();
 
@@ -302,8 +302,8 @@
       VECTOR_CREATE_RETURN_VALUES (cvs, cv);
     }
 
-  retval (1) = tree_constant (idx, 0);
-  retval (0) = tree_constant (cvs, 0);
+  retval (1) = octave_value (idx, 0);
+  retval (0) = octave_value (cvs, 0);
 
   return retval;
 }
@@ -313,7 +313,7 @@
 \n\
 sort the columns of X, optionally return sort index")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -329,7 +329,7 @@
   else
     retval.resize (1);
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   if (arg.is_real_type ())
     {
diff --git a/src/strfns.cc b/src/strfns.cc
--- a/src/strfns.cc
+++ b/src/strfns.cc
@@ -39,7 +39,7 @@
 DEFUN (isstr, args, ,
   "isstr (X): return 1 if X is a string, 0 otherwise")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -54,7 +54,7 @@
 DEFUN (setstr, args, ,
   "setstr (V): convert a vector to a string")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -69,13 +69,13 @@
 DEFUN (toascii, args, ,
   "toascii (STRING): return ASCII representation of STRING in a matrix")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
   if (nargin == 1)
     {
-      tree_constant arg = args(0);
+      octave_value arg = args(0);
 
       if (arg.is_string ())
 	{
diff --git a/src/svd.cc b/src/svd.cc
--- a/src/svd.cc
+++ b/src/svd.cc
@@ -46,7 +46,7 @@
 \n\
 X may not contain any Inf or NaN values.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -56,14 +56,14 @@
       return retval;
     }
 
-  tree_constant arg = args(0);
+  octave_value arg = args(0);
 
   int arg_is_empty = empty_arg ("svd", arg.rows (), arg.columns ());
 
   if (arg_is_empty < 0)
     return retval;
   else if (arg_is_empty > 0)
-    return Octave_object (3, Matrix ());
+    return octave_value_list (3, Matrix ());
 
   SVD::type type = ((nargout == 0 || nargout == 1)
 		    ? SVD::sigma_only
@@ -88,7 +88,7 @@
 
 	  if (nargout == 0 || nargout == 1)
 	    {
-	      retval(0) = tree_constant (sigma.diag (), 1);
+	      retval(0) = octave_value (sigma.diag (), 1);
 	    }
 	  else
 	    {
@@ -117,7 +117,7 @@
 
 	  if (nargout == 0 || nargout == 1)
 	    {
-	      retval(0) = tree_constant (sigma.diag (), 1);
+	      retval(0) = octave_value (sigma.diag (), 1);
 	    }
 	  else
 	    {
diff --git a/src/syl.cc b/src/syl.cc
--- a/src/syl.cc
+++ b/src/syl.cc
@@ -36,7 +36,7 @@
 DEFUN_DLD_BUILTIN (syl, args, nargout,
   "X = syl (A, B, C): solve the Sylvester equation A X + X B + C = 0")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -46,9 +46,9 @@
       return retval;
     }
 
-  tree_constant arg_a = args(0);
-  tree_constant arg_b = args(1);
-  tree_constant arg_c = args(2);
+  octave_value arg_a = args(0);
+  octave_value arg_b = args(1);
+  octave_value arg_c = args(2);
 
   int a_nr = arg_a.rows ();
   int a_nc = arg_a.columns ();
diff --git a/src/symtab.cc b/src/symtab.cc
--- a/src/symtab.cc
+++ b/src/symtab.cc
@@ -49,7 +49,7 @@
   init_state ();
 }
 
-symbol_def::symbol_def (tree_constant *t)
+symbol_def::symbol_def (octave_value *t)
 {
   init_state ();
   definition = t;
@@ -136,7 +136,7 @@
 }
 
 void
-symbol_def::define (tree_constant *t)
+symbol_def::define (octave_value *t)
 {
   definition = t;
   if (! is_builtin_variable ())
@@ -370,7 +370,7 @@
 }
 
 int
-symbol_record::define (tree_constant *t)
+symbol_record::define (octave_value *t)
 {
   if (is_variable () && read_only_error ())
     return 0;
@@ -398,7 +398,7 @@
     {
       // Would be nice to be able to avoid this cast.  XXX FIXME XXX
 
-      definition->define ((tree_constant *) saved_def);
+      definition->define ((octave_value *) saved_def);
       return 0;
     }
 
@@ -465,7 +465,7 @@
 }
 
 int
-symbol_record::define_as_fcn (tree_constant *t)
+symbol_record::define_as_fcn (octave_value *t)
 {
   if (is_variable () && read_only_error ())
     return 0;
@@ -491,7 +491,7 @@
 }
 
 int
-symbol_record::define_builtin_var (tree_constant *t)
+symbol_record::define_builtin_var (octave_value *t)
 {
   define (t);
   if (is_variable ())
@@ -690,7 +690,7 @@
     {
       // Would be nice to avoid this cast.  XXX FIXME XXX
 
-      tree_constant *tmp = (tree_constant *) sr.def ();
+      octave_value *tmp = (octave_value *) sr.def ();
       if (tmp->is_real_scalar ())
 	const_type = SR_INFO_SCALAR;
       else if (tmp->is_complex_scalar ())
diff --git a/src/symtab.h b/src/symtab.h
--- a/src/symtab.h
+++ b/src/symtab.h
@@ -42,7 +42,7 @@
 class tree;
 class tree_fvc;
 class tree_builtin;
-class tree_constant;
+class octave_value;
 class tree_function;
 
 class string_vector;
@@ -62,7 +62,7 @@
 public:
 
   symbol_def (void);
-  symbol_def (tree_constant *t);
+  symbol_def (octave_value *t);
   symbol_def (tree_builtin *t, unsigned fcn_type = 0);
   symbol_def (tree_function *t, unsigned fcn_type = 0);
 
@@ -77,7 +77,7 @@
   int is_builtin_variable (void) const;
   int is_builtin_function (void) const;
 
-  void define (tree_constant *t);
+  void define (octave_value *t);
   void define (tree_builtin *t, unsigned fcn_type = 0);
   void define (tree_function *t, unsigned fcn_type = 0);
 
@@ -159,11 +159,11 @@
 
   void set_sv_function (sv_Function f);
 
-  int define (tree_constant *t);
+  int define (octave_value *t);
   int define (tree_builtin *t, int text_fcn = 0);
   int define (tree_function *t, int text_fcn = 0);
-  int define_as_fcn (tree_constant *t);
-  int define_builtin_var (tree_constant *t);
+  int define_as_fcn (octave_value *t);
+  int define_builtin_var (octave_value *t);
 
   void document (const string& h);
 
diff --git a/src/syscalls.cc b/src/syscalls.cc
--- a/src/syscalls.cc
+++ b/src/syscalls.cc
@@ -312,7 +312,7 @@
   Like stat (NAME), but if NAME refers to a symbolic link, returns\n\
   information about the link itself, not the file that it points to.")
 {
-  tree_constant retval = -1.0;
+  octave_value retval = -1.0;
 
   if (args.length () == 1)
     {
@@ -323,7 +323,7 @@
 	  file_stat fs (fname, false);
 
 	  if (fs)
-	    retval = tree_constant (mk_stat_map (fs));
+	    retval = octave_value (mk_stat_map (fs));
 	}
     }
   else
@@ -374,7 +374,7 @@
 DEFUN (pipe, args, ,
   "[file_ids, status] = pipe (): create an interprocess channel")
 {
-  Octave_object retval (2, tree_constant (-1.0));
+  octave_value_list retval (2, octave_value (-1.0));
 
 #if defined (HAVE_PIPE)
   int nargin = args.length ();
@@ -434,7 +434,7 @@
 \n\
   If the file does not exist, -1 is returned.")
 {
-  tree_constant retval = -1.0;
+  octave_value retval = -1.0;
 
   if (args.length () == 1)
     {
@@ -445,7 +445,7 @@
 	  file_stat fs (fname);
 
 	  if (fs)
-	    retval = tree_constant (mk_stat_map (fs));
+	    retval = octave_value (mk_stat_map (fs));
 	}
     }
   else
diff --git a/src/sysdep.cc b/src/sysdep.cc
--- a/src/sysdep.cc
+++ b/src/sysdep.cc
@@ -389,7 +389,7 @@
 DEFUN (clc, , ,
   "clc (): clear screen")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   rl_beg_of_line ();
   rl_kill_line (1);
@@ -413,7 +413,7 @@
 DEFUN (getenv, args, ,
   "getenv (STRING): get environment variable values")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -440,7 +440,7 @@
 DEFUN (putenv, args, ,
   "putenv (VAR, VALUE): define environment variable VAR=VALUE")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -469,7 +469,7 @@
 DEFUN (kbhit, , ,
   "kbhit: get a single character from the terminal")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   // XXX FIXME XXX -- add timeout and default value args?
 
@@ -488,7 +488,7 @@
 DEFUN (pause, args, ,
   "pause (seconds): suspend program execution")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -576,7 +576,7 @@
 DEFUN (tilde_expand, args, ,
   "tilde_expand (STRING): perform tilde expansion on STRING")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
diff --git a/src/timefns.cc b/src/timefns.cc
--- a/src/timefns.cc
+++ b/src/timefns.cc
@@ -128,7 +128,7 @@
   returned from localtime() but with values corresponding to\n\
   Coordinated Universal Time (UTC).")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (args.length () == 1)
     {
@@ -140,7 +140,7 @@
 	  double ip;
 	  double fraction = modf (tmp, &ip); 
 
-	  retval = tree_constant (mk_tm_map (gmtime (&timeval), fraction));
+	  retval = octave_value (mk_tm_map (gmtime (&timeval), fraction));
 	}
     }
   else
@@ -167,7 +167,7 @@
     isdst : Daylight Savings Time flag\n\
     zone  : Time zone")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (args.length () == 1)
     {
@@ -179,7 +179,7 @@
 	  double ip;
 	  double fraction = modf (tmp, &ip); 
 
-	  retval = tree_constant (mk_tm_map (localtime (&timeval), fraction));
+	  retval = octave_value (mk_tm_map (localtime (&timeval), fraction));
 	}
     }
   else
@@ -191,7 +191,7 @@
 DEFUN (mktime, args, ,
   "mktime (TMSTRUCT)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (args.length () == 1 && args(0).is_map ()) 
     {
@@ -271,7 +271,7 @@
     %y	last two digits of year (00..99)\n\
     %Y	year (1970...)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   if (args.length () == 2 && args(0).is_string () && args(1).is_map ()) 
     {
diff --git a/src/toplev.cc b/src/toplev.cc
--- a/src/toplev.cc
+++ b/src/toplev.cc
@@ -271,7 +271,7 @@
 Parse and execute the contents of FILE.  Like executing commands in a\n\
 script file but without requiring the file to be named `FILE.m'.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -331,7 +331,7 @@
 DEFUN_TEXT (casesen, args, ,
   "casesen [on|off]")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -355,7 +355,7 @@
 \n\
 Have Octave ask the system, \"What kind of computer are you?\"")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -390,7 +390,7 @@
 \n\
 STATUS should be an integer value.  If STATUS is missing, 0 is assumed.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int exit_status = 0;
 
@@ -418,7 +418,7 @@
 DEFUN (warranty, , ,
   "warranty (): describe copying conditions")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   ostrstream output_buf;
   output_buf << "\n" OCTAVE_NAME_VERSION_AND_COPYRIGHT "\n\n\
@@ -445,16 +445,16 @@
 
 // XXX FIXME XXX -- this may not be the best place for these...
 
-Octave_object
-feval (const Octave_object& args, int nargout)
+octave_value_list
+feval (const octave_value_list& args, int nargout)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   tree_fvc *fcn = is_valid_function (args(0), "feval", 1);
   if (fcn)
     {
       int tmp_nargin = args.length () - 1;
-      Octave_object tmp_args;
+      octave_value_list tmp_args;
       tmp_args.resize (tmp_nargin);
       for (int i = 0; i < tmp_nargin; i++)
 	tmp_args(i) = args(i+1);
@@ -469,7 +469,7 @@
 \n\
 evaluate NAME as a function, passing ARGS as its arguments")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -481,7 +481,7 @@
   return retval;
 }
 
-static Octave_object
+static octave_value_list
 eval_string (const string& s, int print, int& parse_status,
 	     int nargout) 
 {
@@ -518,7 +518,7 @@
 
   run_unwind_frame ("eval_string");
 
-  Octave_object retval;
+  octave_value_list retval;
 
   if (parse_status == 0 && command)
     {
@@ -529,20 +529,20 @@
   return retval;
 }
 
-tree_constant
+octave_value
 eval_string (const string& s, int print, int& parse_status)
 {
-  tree_constant retval;
+  octave_value retval;
 
-  Octave_object tmp = eval_string (s, print, parse_status, 1);
+  octave_value_list tmp = eval_string (s, print, parse_status, 1);
 
   retval = tmp(0);
 
   return retval;
 }
 
-static Octave_object
-eval_string (const tree_constant& arg, int& parse_status, int nargout)
+static octave_value_list
+eval_string (const octave_value& arg, int& parse_status, int nargout)
 {
   string s = arg.string_value ();
 
@@ -563,7 +563,7 @@
 Evaluate the string TRY as octave code.  If that fails, evaluate the\n\
 string CATCH.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -594,7 +594,7 @@
 
 	  eval_string (args(1), parse_status, nargout);
 
-	  retval = Octave_object ();
+	  retval = octave_value_list ();
 	}
 
       run_unwind_frame ("Feval");
@@ -613,10 +613,10 @@
   delete (iprocstream *) p;
 }
 
-static Octave_object
+static octave_value_list
 do_system (const string& cmd_str, bool return_output)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   iprocstream *cmd = new iprocstream (cmd_str.c_str ());
 
@@ -685,7 +685,7 @@
 sent to Octave's standard output (possibly being passed through the\n\
 pager).")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -757,7 +757,7 @@
 {
   while (! octave_atexit_functions.empty ())
     {
-      Octave_object fcn = octave_atexit_functions.pop ();
+      octave_value_list fcn = octave_atexit_functions.pop ();
 
       feval (fcn, 0);
     }
@@ -769,7 +769,7 @@
 Functions are called with no arguments in the reverse of the order in
 which they were registered with atexit()")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
 #if defined (HAVE_ATEXIT) || defined (HAVE_ON_EXIT)
   int nargin = args.length ();
diff --git a/src/toplev.h b/src/toplev.h
--- a/src/toplev.h
+++ b/src/toplev.h
@@ -25,7 +25,7 @@
 
 #include <cstdio>
 
-class tree_constant;
+class octave_value;
 class tree_function;
 class tree_statement_list;
 class charMatrix;
@@ -40,7 +40,7 @@
 			       int verbose = 0,
 			       const char *warn_for = 0);
 
-extern tree_constant eval_string (const string&, int print,
+extern octave_value eval_string (const string&, int print,
 				  int& parse_status);
 
 extern int main_loop (void);
diff --git a/src/utils.cc b/src/utils.cc
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -337,7 +337,7 @@
 DEFUN (file_in_path, args, ,
   "file_in_path (PATH, NAME)")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -477,7 +477,7 @@
 DEFUN (undo_string_escapes, args, ,
   "undo_string_escapes (STRING)")
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nargin = args.length ();
 
diff --git a/src/utils.h b/src/utils.h
--- a/src/utils.h
+++ b/src/utils.h
@@ -30,7 +30,7 @@
 
 #include "lo-utils.h"
 
-class Octave_object;
+class octave_value_list;
 class string_vector;
 
 extern char *strsave (const char *);
diff --git a/src/variables.cc b/src/variables.cc
--- a/src/variables.cc
+++ b/src/variables.cc
@@ -124,10 +124,10 @@
   return (sr && sr->is_linked_to_global ());
 }
 
-// Is this tree_constant a valid function?
+// Is this octave_value a valid function?
 
 tree_fvc *
-is_valid_function (const tree_constant& arg, const string& warn_for, int warn)
+is_valid_function (const octave_value& arg, const string& warn_for, int warn)
 {
   tree_fvc *ans = 0;
 
@@ -167,7 +167,7 @@
   "is_global (X): return 1 if the string X names a global variable\n\
 otherwise, return 0.")
 {
-  Octave_object retval = 0.0;
+  octave_value_list retval = 0.0;
 
   int nargin = args.length ();
 
@@ -203,7 +203,7 @@
    3 : NAME is a .oct file in the current LOADPATH\n\
    5 : NAME is a built-in function")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
@@ -247,9 +247,9 @@
 	  retval = 0.0;
 	  if (def->is_constant ())
 	    {
-	      tree_constant *tmp = (tree_constant *) def;
+	      octave_value *tmp = (octave_value *) def;
 
-	      tree_constant ult	= tmp->lookup_map_element (struct_elts, 0, 1);
+	      octave_value ult	= tmp->lookup_map_element (struct_elts, 0, 1);
 
 	      if (ult.is_defined ())
 		retval = 1.0;
@@ -902,7 +902,7 @@
 
   if (defn)
     {
-      tree_constant val = defn->eval (0);
+      octave_value val = defn->eval (0);
 
       if (! error_state && val.is_string ())
 	retval = val.string_value ();
@@ -929,7 +929,7 @@
 
   if (defn)
     {
-      tree_constant val = defn->eval (0);
+      octave_value val = defn->eval (0);
 
       if (! error_state && val.is_scalar_type ())
 	{
@@ -943,10 +943,10 @@
 
 // Look for the given name in the global symbol table.
 
-tree_constant
+octave_value
 builtin_any_variable (const string& name)
 {
-  tree_constant retval;
+  octave_value retval;
 
   symbol_record *sr = global_sym_tab->lookup (name, 0, 0);
 
@@ -990,11 +990,11 @@
     {
       // Would be nice not to have this cast.  XXX FIXME XXX
 
-      tree_constant *tmp = (tree_constant *) sr->def ();
+      octave_value *tmp = (octave_value *) sr->def ();
       if (tmp)
-	tmp = new tree_constant (*tmp);
+	tmp = new octave_value (*tmp);
       else
-	tmp = new tree_constant ();
+	tmp = new octave_value ();
       gsr->define (tmp);
     }
   else
@@ -1004,7 +1004,7 @@
   // to hide it with a variable.
 
   if (gsr->is_function ())
-    gsr->define ((tree_constant *) 0);
+    gsr->define ((octave_value *) 0);
 
   sr->alias (gsr, 1);
   sr->mark_as_linked_to_global ();
@@ -1195,7 +1195,7 @@
 \n\
 Associate a cryptic message with a variable name.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -1230,10 +1230,10 @@
 // XXX FIXME XXX -- this should take a list of regular expressions
 // naming the variables to look for.
 
-static Octave_object
+static octave_value_list
 do_who (int argc, const string_vector& argv)
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int show_builtins = 0;
   int show_functions = (curr_sym_tab == top_level_sym_tab);
@@ -1338,7 +1338,7 @@
 List currently defined symbol(s).  Options may be shortened to one\n\
 character, but may not be combined.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
@@ -1358,11 +1358,11 @@
 List currently defined symbol(s).  Options may be shortened to one\n\
 character, but may not be combined.")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int nargin = args.length ();
 
-  Octave_object tmp_args;
+  octave_value_list tmp_args;
   for (int i = nargin; i > 0; i--)
     tmp_args(i) = args(i-1);
   tmp_args(0) = "-long";
@@ -1433,7 +1433,7 @@
 }
 
 void
-install_builtin_variable_as_function (const string& name, tree_constant *val,
+install_builtin_variable_as_function (const string& name, octave_value *val,
 				      int protect, int eternal,
 				      const string& help)
 {
@@ -1476,28 +1476,28 @@
 void
 bind_nargin_and_nargout (symbol_table *sym_tab, int nargin, int nargout)
 {
-  tree_constant *tmp;
+  octave_value *tmp;
   symbol_record *sr;
 
   sr = sym_tab->lookup ("nargin", 1, 0);
   sr->unprotect ();
-  tmp = new tree_constant (nargin);
+  tmp = new octave_value (nargin);
   sr->define (tmp);
 
   sr = sym_tab->lookup ("nargout", 1, 0);
   sr->unprotect ();
-  tmp = new tree_constant (nargout);
+  tmp = new octave_value (nargout);
   sr->define (tmp);
 }
 #endif
 
 void
-bind_ans (const tree_constant& val, int print)
+bind_ans (const octave_value& val, int print)
 {
   static symbol_record *sr = global_sym_tab->lookup ("ans", 1, 0);
 
   tree_identifier *ans_id = new tree_identifier (sr);
-  tree_constant *tmp = new tree_constant (val);
+  octave_value *tmp = new octave_value (val);
 
   // XXX FIXME XXX -- making ans_id static, passing its address to
   // tree_simple_assignment_expression along with a flag to not delete
@@ -1540,7 +1540,7 @@
 // functions needed?
 
 void
-bind_builtin_variable (const string& varname, tree_constant *val,
+bind_builtin_variable (const string& varname, octave_value *val,
 		       int protect, int eternal, sv_Function sv_fcn,
 		       const string& help)
 {
@@ -1572,11 +1572,11 @@
 }
 
 void
-bind_builtin_variable (const string& varname, const tree_constant& val,
+bind_builtin_variable (const string& varname, const octave_value& val,
 		       int protect, int eternal, sv_Function sv_fcn,
 		       const string& help)
 {
-  tree_constant *tc = new tree_constant (val);
+  octave_value *tc = new octave_value (val);
   bind_builtin_variable (varname, tc, protect, eternal, sv_fcn, help);
 }
 
@@ -1899,7 +1899,7 @@
 \n\
 With -x, exclude the named variables")
 {
-  Octave_object retval;
+  octave_value_list retval;
 
   int argc = args.length () + 1;
 
diff --git a/src/variables.h b/src/variables.h
--- a/src/variables.h
+++ b/src/variables.h
@@ -27,8 +27,8 @@
 class symbol_table;
 
 class tree_fvc;
-class tree_constant;
-class Octave_object;
+class octave_value;
+class octave_value_list;
 class string_vector;
 
 #include <string>
@@ -39,13 +39,13 @@
 
 struct builtin_variable
 {
-  builtin_variable (const string& n, tree_constant *v, int iaf, int p,
+  builtin_variable (const string& n, octave_value *v, int iaf, int p,
 		    int e, sv_Function svf, const string& h)
     : name (n), value (v), install_as_function (iaf), protect (p),
       eternal (e), sv_function (svf), help_string (h) { }
 
   string name;
-  tree_constant *value;
+  octave_value *value;
   int install_as_function;
   int protect;
   int eternal;
@@ -53,7 +53,7 @@
   string help_string;
 };
 
-typedef Octave_object (*Octave_builtin_fcn)(const Octave_object&, int);
+typedef octave_value_list (*Octave_builtin_fcn)(const octave_value_list&, int);
 
 struct builtin_function
 {
@@ -77,7 +77,7 @@
 
 extern string builtin_string_variable (const string&);
 extern int builtin_real_scalar_variable (const string&, double&);
-extern tree_constant builtin_any_variable (const string&);
+extern octave_value builtin_any_variable (const string&);
 
 extern void link_to_global_variable (symbol_record *sr);
 extern void link_to_builtin_variable (symbol_record *sr);
@@ -89,7 +89,7 @@
 extern bool is_text_function_name (const string&);
 extern bool is_globally_visible (const string&);
 
-extern tree_fvc *is_valid_function (const tree_constant&, const string&,
+extern tree_fvc *is_valid_function (const octave_value&, const string&,
 				    int warn = 0); 
 
 extern string_vector make_name_list (void);
@@ -102,7 +102,7 @@
 
 extern void
 install_builtin_variable_as_function
-  (const string& name, tree_constant *val, int protect = 0,
+  (const string& name, octave_value *val, int protect = 0,
    int eternal = 0, const string& help = string ());
 
 extern void alias_builtin (const string& alias, const string& name);
@@ -112,18 +112,18 @@
 				     int nargin, int nargout);
 #endif
 
-extern void bind_ans (const tree_constant& val, int print);
+extern void bind_ans (const octave_value& val, int print);
 
 extern void bind_global_error_variable (void);
 
 extern void clear_global_error_variable (void *);
 
-extern void bind_builtin_variable (const string&, tree_constant *,
+extern void bind_builtin_variable (const string&, octave_value *,
 				   int protect = 0, int eternal = 0,
 				   sv_Function f = (sv_Function) 0,
 				   const string& help = string ());
 
-extern void bind_builtin_variable (const string&, const tree_constant&,
+extern void bind_builtin_variable (const string&, const octave_value&,
 				   int protect = 0, int eternal = 0,
 				   sv_Function f = (sv_Function) 0,
 				   const string& help = string ());
diff --git a/src/xpow.cc b/src/xpow.cc
--- a/src/xpow.cc
+++ b/src/xpow.cc
@@ -79,7 +79,7 @@
 //   E -> error, trapped in arith-ops.cc.
 
 // -*- 1 -*-
-tree_constant
+octave_value
 xpow (double a, double b)
 {
   if (a < 0.0 && (int) b != b)
@@ -92,10 +92,10 @@
 }
 
 // -*- 2 -*-
-tree_constant
+octave_value
 xpow (double a, const Matrix& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = b.rows ();
   int nc = b.columns ();
@@ -125,7 +125,7 @@
 }
 
 // -*- 3 -*-
-tree_constant
+octave_value
 xpow (double a, const Complex& b)
 {
   Complex result;
@@ -135,10 +135,10 @@
 }
 
 // -*- 4 -*-
-tree_constant
+octave_value
 xpow (double a, const ComplexMatrix& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = b.rows ();
   int nc = b.columns ();
@@ -170,10 +170,10 @@
 }
 
 // -*- 5 -*-
-tree_constant
+octave_value
 xpow (const Matrix& a, double b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = a.rows ();
   int nc = a.columns ();
@@ -240,10 +240,10 @@
 }
 
 // -*- 6 -*-
-tree_constant
+octave_value
 xpow (const Matrix& a, const Complex& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = a.rows ();
   int nc = a.columns ();
@@ -270,7 +270,7 @@
 }
 
 // -*- 7 -*-
-tree_constant
+octave_value
 xpow (const Complex& a, double b)
 {
   Complex result;
@@ -284,10 +284,10 @@
 }
 
 // -*- 8 -*-
-tree_constant
+octave_value
 xpow (const Complex& a, const Matrix& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = b.rows ();
   int nc = b.columns ();
@@ -319,7 +319,7 @@
 }
 
 // -*- 9 -*-
-tree_constant
+octave_value
 xpow (const Complex& a, const Complex& b)
 {
   Complex result;
@@ -328,10 +328,10 @@
 }
 
 // -*- 10 -*-
-tree_constant
+octave_value
 xpow (const Complex& a, const ComplexMatrix& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = b.rows ();
   int nc = b.columns ();
@@ -363,10 +363,10 @@
 }
 
 // -*- 11 -*-
-tree_constant
+octave_value
 xpow (const ComplexMatrix& a, double b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = a.rows ();
   int nc = a.columns ();
@@ -433,10 +433,10 @@
 }
 
 // -*- 12 -*-
-tree_constant
+octave_value
 xpow (const ComplexMatrix& a, const Complex& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = a.rows ();
   int nc = a.columns ();
@@ -478,10 +478,10 @@
 //   * -> not needed.
 
 // -*- 1 -*-
-tree_constant
+octave_value
 elem_xpow (double a, const Matrix& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = b.rows ();
   int nc = b.columns ();
@@ -512,7 +512,7 @@
 }
 
 // -*- 2 -*-
-tree_constant
+octave_value
 elem_xpow (double a, const ComplexMatrix& b)
 {
   int nr = b.rows ();
@@ -527,10 +527,10 @@
 }
 
 // -*- 3 -*-
-tree_constant
+octave_value
 elem_xpow (const Matrix& a, double b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = a.rows ();
   int nc = a.columns ();
@@ -561,10 +561,10 @@
 }
 
 // -*- 4 -*-
-tree_constant
+octave_value
 elem_xpow (const Matrix& a, const Matrix& b)
 {
-  tree_constant retval;
+  octave_value retval;
 
   int nr = a.rows ();
   int nc = a.columns ();
@@ -615,7 +615,7 @@
 }
 
 // -*- 5 -*-
-tree_constant
+octave_value
 elem_xpow (const Matrix& a, const Complex& b)
 {
   int nr = a.rows ();
@@ -630,7 +630,7 @@
 }
 
 // -*- 6 -*-
-tree_constant
+octave_value
 elem_xpow (const Matrix& a, const ComplexMatrix& b)
 {
   int nr = a.rows ();
@@ -647,7 +647,7 @@
 }
 
 // -*- 7 -*-
-tree_constant
+octave_value
 elem_xpow (const Complex& a, const Matrix& b)
 {
   int nr = b.rows ();
@@ -668,7 +668,7 @@
 }
 
 // -*- 8 -*-
-tree_constant
+octave_value
 elem_xpow (const Complex& a, const ComplexMatrix& b)
 {
   int nr = b.rows ();
@@ -683,7 +683,7 @@
 }
 
 // -*- 9 -*-
-tree_constant
+octave_value
 elem_xpow (const ComplexMatrix& a, double b)
 {
   int nr = a.rows ();
@@ -708,7 +708,7 @@
 }
 
 // -*- 10 -*-
-tree_constant
+octave_value
 elem_xpow (const ComplexMatrix& a, const Matrix& b)
 {
   int nr = a.rows ();
@@ -731,7 +731,7 @@
 }
 
 // -*- 11 -*-
-tree_constant
+octave_value
 elem_xpow (const ComplexMatrix& a, const Complex& b)
 {
   int nr = a.rows ();
@@ -746,7 +746,7 @@
 }
 
 // -*- 12 -*-
-tree_constant
+octave_value
 elem_xpow (const ComplexMatrix& a, const ComplexMatrix& b)
 {
   int nr = a.rows ();
diff --git a/src/xpow.h b/src/xpow.h
--- a/src/xpow.h
+++ b/src/xpow.h
@@ -27,39 +27,39 @@
 
 class Matrix;
 class ComplexMatrix;
-class tree_constant;
+class octave_value;
 
-extern tree_constant xpow (double a, double b);
-extern tree_constant xpow (double a, const Matrix& b);
-extern tree_constant xpow (double a, const Complex& b);
-extern tree_constant xpow (double a, const ComplexMatrix& b);
+extern octave_value xpow (double a, double b);
+extern octave_value xpow (double a, const Matrix& b);
+extern octave_value xpow (double a, const Complex& b);
+extern octave_value xpow (double a, const ComplexMatrix& b);
 
-extern tree_constant xpow (const Matrix& a, double b);
-extern tree_constant xpow (const Matrix& a, const Complex& b);
+extern octave_value xpow (const Matrix& a, double b);
+extern octave_value xpow (const Matrix& a, const Complex& b);
 
-extern tree_constant xpow (const Complex& a, double b);
-extern tree_constant xpow (const Complex& a, const Matrix& b);
-extern tree_constant xpow (const Complex& a, const Complex& b);
-extern tree_constant xpow (const Complex& a, const ComplexMatrix& b);
+extern octave_value xpow (const Complex& a, double b);
+extern octave_value xpow (const Complex& a, const Matrix& b);
+extern octave_value xpow (const Complex& a, const Complex& b);
+extern octave_value xpow (const Complex& a, const ComplexMatrix& b);
 
-extern tree_constant xpow (const ComplexMatrix& a, double b);
-extern tree_constant xpow (const ComplexMatrix& a, const Complex& b);
+extern octave_value xpow (const ComplexMatrix& a, double b);
+extern octave_value xpow (const ComplexMatrix& a, const Complex& b);
 
-extern tree_constant elem_xpow (double a, const Matrix& b);
-extern tree_constant elem_xpow (double a, const ComplexMatrix& b);
+extern octave_value elem_xpow (double a, const Matrix& b);
+extern octave_value elem_xpow (double a, const ComplexMatrix& b);
 
-extern tree_constant elem_xpow (const Matrix& a, double b);
-extern tree_constant elem_xpow (const Matrix& a, const Matrix& b);
-extern tree_constant elem_xpow (const Matrix& a, const Complex& b);
-extern tree_constant elem_xpow (const Matrix& a, const ComplexMatrix& b);
+extern octave_value elem_xpow (const Matrix& a, double b);
+extern octave_value elem_xpow (const Matrix& a, const Matrix& b);
+extern octave_value elem_xpow (const Matrix& a, const Complex& b);
+extern octave_value elem_xpow (const Matrix& a, const ComplexMatrix& b);
 
-extern tree_constant elem_xpow (const Complex& a, const Matrix& b);
-extern tree_constant elem_xpow (const Complex& a, const ComplexMatrix& b);
+extern octave_value elem_xpow (const Complex& a, const Matrix& b);
+extern octave_value elem_xpow (const Complex& a, const ComplexMatrix& b);
 
-extern tree_constant elem_xpow (const ComplexMatrix& a, double b);
-extern tree_constant elem_xpow (const ComplexMatrix& a, const Matrix& b);
-extern tree_constant elem_xpow (const ComplexMatrix& a, const Complex& b);
-extern tree_constant elem_xpow (const ComplexMatrix& a,
+extern octave_value elem_xpow (const ComplexMatrix& a, double b);
+extern octave_value elem_xpow (const ComplexMatrix& a, const Matrix& b);
+extern octave_value elem_xpow (const ComplexMatrix& a, const Complex& b);
+extern octave_value elem_xpow (const ComplexMatrix& a,
 				const ComplexMatrix& b);
 
 #endif