--- a/src/pt-exp.h
+++ b/src/pt-exp.h
@@ -20,421 +20,119 @@
 
 */
 
-#if !defined (octave_tree_expr2_h)
-#define octave_tree_expr2_h 1
+#if !defined (octave_tree_expr_h)
+#define octave_tree_expr_h 1
 
 #if defined (__GNUG__)
 #pragma interface
 #endif
 
-class ostream;
-
-class tree_identifier;
-class tree_index_expression;
-class tree_indirect_ref;
-class tree_argument_list;
-class tree_assignment_lhs;
-
-class tree_walker;
+#include <string>
 
 class octave_value;
-class octave_value_list;
 class octave_lvalue;
 
-#include "oct-obj.h"
-#include "pt-exp-base.h"
-
-// Unary expressions.
-
-class
-tree_unary_expression : public tree_expression
-{
-public:
-
-  tree_unary_expression (int l = -1, int c = -1)
-    : tree_expression (l, c), op (0)  { }
-
-  tree_unary_expression (tree_expression *e, int l = -1, int c = -1)
-    : tree_expression (l, c), op (e) { }
-
-  ~tree_unary_expression (void) { delete op; }
-
-  tree_expression *operand (void) { return op; }
-
-protected:
-
-  // The operand for the expression.
-  tree_expression *op;
-};
-
-// Prefix expressions.
-
-class
-tree_prefix_expression : public tree_unary_expression
-{
-public:
+#include "pt-base.h"
 
-  enum type
-    {
-      unknown,
-      unot,
-      uminus,
-      increment,
-      decrement
-    };
-
-  tree_prefix_expression (int l = -1, int c = -1)
-    : tree_unary_expression (l, c), etype (unknown) { }
-
-  tree_prefix_expression (type t = unknown, tree_expression *e,
-			  int l = -1, int c = -1)
-    : tree_unary_expression (e, l, c), etype (t) { }
-
-  ~tree_prefix_expression (void) { }
-
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
-
-  octave_value_list rvalue (int nargou);
-
-  void eval_error (void);
-
-  string oper (void) const;
-
-  void accept (tree_walker& tw);
-
-private:
-
-  // The type of the expression.
-  type etype;
-};
-
-// Postfix expressions.
+// A base class for expressions.
 
 class
-tree_postfix_expression : public tree_unary_expression
-{
-public:
-
-  enum type
-    {
-      unknown,
-      hermitian,
-      transpose,
-      increment,
-      decrement
-    };
-
-  tree_postfix_expression (int l = -1, int c = -1)
-    : tree_unary_expression (l, c), etype (unknown) { }
-
-  tree_postfix_expression (type t = unknown, tree_expression *e,
-			   int l = -1, int c = -1)
-    : tree_unary_expression (e, l, c), etype (t) { }
-
-  ~tree_postfix_expression (void) { }
-
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
-
-  octave_value_list rvalue (int nargout);
-
-  void eval_error (void);
-
-  string oper (void) const;
-
-  void accept (tree_walker& tw);
-
-private:
-
-  // The type of the expression.
-  type etype;
-};
-
-// Binary expressions.
-
-class
-tree_binary_expression : public tree_expression
-{
-public:
-
-  tree_binary_expression (int l = -1, int c = -1,
-			  octave_value::binary_op t
-			    = octave_value::unknown_binary_op)
-    : tree_expression (l, c), op_lhs (0), op_rhs (0), etype (t) { }
-
-  tree_binary_expression (tree_expression *a, tree_expression *b,
-			  int l = -1, int c = -1,
-			  octave_value::binary_op t
-			    = octave_value::unknown_binary_op)
-    : tree_expression (l, c), op_lhs (a), op_rhs (b), etype (t) { }
-
-  ~tree_binary_expression (void)
-    {
-      delete op_lhs;
-      delete op_rhs;
-    }
-
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
-
-  octave_value_list rvalue (int nargou);
-
-  void eval_error (void);
-
-  string oper (void) const;
-
-  tree_expression *lhs (void) { return op_lhs; }
-  tree_expression *rhs (void) { return op_rhs; }
-
-  void accept (tree_walker& tw);
-
-protected:
-
-  // The operands for the expression.
-  tree_expression *op_lhs;
-  tree_expression *op_rhs;
-
-private:
-
-  // The type of the expression.
-  octave_value::binary_op etype;
-};
-
-// Boolean expressions.
-
-class
-tree_boolean_expression : public tree_binary_expression
+tree_expression : public tree
 {
 public:
 
-  enum type
-    {
-      unknown,
-      bool_and,
-      bool_or
-    };
+  tree_expression (int l = -1, int c = -1)
+    : tree (l, c), num_parens (0), postfix_indexed (false),
+      print_flag (false) { }
 
-  tree_boolean_expression (int l = -1, int c = -1, type t = unknown)
-    : tree_binary_expression (l, c), etype (t) { }
+  virtual ~tree_expression (void) { }
 
-  tree_boolean_expression (tree_expression *a, tree_expression *b,
-			   int l = -1, int c = -1, type t = unknown)
-    : tree_binary_expression (a, b, l, c), etype (t) { }
-
-  ~tree_boolean_expression (void) { }
+  virtual bool is_constant (void) const
+    { return false; }
 
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
-
-  octave_value_list rvalue (int nargout);
-
-  string oper (void) const;
-
-private:
+  virtual bool is_matrix_constant (void) const
+    { return false; }
 
-  // The type of the expression.
-  type etype;
-};
+  virtual bool is_identifier (void) const
+    { return false; }
 
-// Simple assignment expressions.
-
-class
-tree_simple_assignment : public tree_expression
-{
-public:
+  virtual bool is_index_expression (void) const
+    { return false; }
 
-  tree_simple_assignment (bool plhs = false, int l = -1, int c = -1,
-			  octave_value::assign_op t = octave_value::asn_eq)
-    : tree_expression (l, c), lhs (0), rhs (0), preserve (plhs), etype (t) { }
+  virtual bool is_indirect_ref (void) const
+    { return false; }
 
-  tree_simple_assignment (tree_expression *le, tree_expression *re,
-			  bool plhs = false, int l = -1, int c = -1,
-			  octave_value::assign_op t = octave_value::asn_eq)
-    : tree_expression (l, c), lhs (le), rhs (re), preserve (plhs),
-      etype (t) { }
+  virtual bool is_assignment_expression (void) const
+    { return false; }
 
-  ~tree_simple_assignment (void);
+  virtual bool is_prefix_expression (void) const
+    { return false; }
 
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
+  virtual bool is_logically_true (const char *);
 
-  octave_value_list rvalue (int nargout);
-
-  bool is_assignment_expression (void) const
-    { return true; }
+  virtual bool lvalue_ok (void) const
+    { return false; }
 
-  void eval_error (void);
-
-  string oper (void) const;
-
-  tree_expression *left_hand_side (void) { return lhs; }
-
-  tree_expression *right_hand_side (void) { return rhs; }
+  virtual bool rvalue_ok (void) const
+    { return false; }
 
-  void accept (tree_walker& tw);
+  virtual octave_value rvalue (void);
 
-private:
-
-  void do_assign (octave_lvalue& ult, const octave_value_list& args,
-		  const octave_value& rhs_val);
+  virtual octave_value_list rvalue (int nargout);
 
-  void do_assign (octave_lvalue& ult, const octave_value& rhs_val);
+  virtual octave_lvalue lvalue (void);
 
-  // The left hand side of the assignment.
-  tree_expression *lhs;
-
-  // The right hand side of the assignment.
-  tree_expression *rhs;
+  int paren_count (void) const
+    { return num_parens; }
 
-  // True if we should not delete the lhs.
-  bool preserve;
-
-  // True if this is an assignment to the built-in variable ans.
-  bool ans_ass;
+  bool is_postfix_indexed (void) const
+    { return postfix_indexed; }
 
-  // The type of the expression.
-  octave_value::assign_op etype;
-};
+  bool print_result (void) const
+    { return print_flag; }
 
-// Colon expressions.
+  virtual string oper (void) const
+    { return "<unknown>"; }
 
-class
-tree_colon_expression : public tree_expression
-{
-public:
+  virtual string name (void) const
+    { return "<unknown>"; }
 
-  tree_colon_expression (int l = -1, int c = -1)
-    : tree_expression (l, c), op_base (0), op_limit (0), op_increment (0) { }
+  virtual string original_text (void) const;
 
-  tree_colon_expression (tree_expression *e, int l = -1, int c = -1)
-    : tree_expression (l, c), op_base (e), op_limit (0), op_increment (0) { }
-
-  ~tree_colon_expression (void)
+  tree_expression *mark_in_parens (void)
     {
-      delete op_base;
-      delete op_limit;
-      delete op_increment;
+      num_parens++;
+      return this;
     }
 
-  tree_colon_expression *append (tree_expression *t);
-
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
-
-  octave_value_list rvalue (int nargout);
-
-  void eval_error (const string& s = string ());
-
-  tree_expression *base (void) { return op_base; }
-  tree_expression *limit (void) { return op_limit; }
-  tree_expression *increment (void) { return op_increment; }
-
-  void accept (tree_walker& tw);
-
-private:
-
-  // The components of the expression.
-  tree_expression *op_base;
-  tree_expression *op_limit;
-  tree_expression *op_increment;
-};
-
-// Index expressions.
+  tree_expression *mark_postfix_indexed (void)
+    {
+      postfix_indexed = true;
+      return this;
+    }
 
-class
-tree_index_expression : public tree_expression
-{
-public:
-
-  tree_index_expression (tree_expression *e = 0, tree_argument_list *lst = 0,
-			 int l = -1, int c = -1)
-    : tree_expression (l, c), expr (e), list (lst), arg_nm () { }
-
-  ~tree_index_expression (void);
+  tree_expression *set_print_flag (bool print)
+    {
+      print_flag = print;
+      return this;
+    }
 
-  bool is_index_expression (void) const
-    { return true; }
-
-  tree_expression *expression (void)
-    { return expr; }
-
-  tree_argument_list *arg_list (void)
-    { return list; }
-
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
-
-  octave_value_list rvalue (int nargout);
+protected:
 
-  octave_lvalue lvalue (void);
-
-  void eval_error (void);
-
-  void accept (tree_walker& tw);
-
-private:
-
-  tree_expression *expr;
-
-  tree_argument_list *list;
-
-  string_vector arg_nm;
-};
-
-// Multi-valued assignment expressions.
-
-class
-tree_multi_assignment : public tree_expression
-{
-public:
-
-  tree_multi_assignment (bool plhs = false, int l = -1, int c = -1)
-    : tree_expression (l, c), preserve (plhs), lhs (0), rhs (0) { }
+  // A count of the number of times this expression appears directly
+  // inside a set of parentheses.
+  //
+  //   (((e1)) + e2)  ==> 2 for expression e1
+  //                  ==> 1 for expression ((e1)) + e2
+  //                  ==> 0 for expression e2
+  int num_parens;
 
-  tree_multi_assignment (tree_argument_list *lst, tree_expression *r,
-			 bool plhs = false, int l = -1, int c = -1)
-    : tree_expression (l, c), preserve (plhs), lhs (lst), rhs (r) { }
-
-  ~tree_multi_assignment (void);
-
-  bool is_assignment_expression (void) const
-    { return true; }
-
-  bool rvalue_ok (void) const
-    { return true; }
-
-  octave_value rvalue (void);
+  // A flag that says whether this expression has an index associated
+  // with it.  See the code in tree_identifier::rvalue for the rationale.
+  bool postfix_indexed;
 
-  octave_value_list rvalue (int nargout);
-
-  void eval_error (void);
-
-  tree_argument_list *left_hand_side (void) { return lhs; }
-
-  tree_expression *right_hand_side (void) { return rhs; }
-
-  void accept (tree_walker& tw);
-
-private:
-
-  bool preserve;
-  tree_argument_list *lhs;
-  tree_expression *rhs;
+  // Print result of rvalue for this expression?
+  bool print_flag;
 };
 
 #endif