# HG changeset patch
# User jwe
# Date 831885396 0
# Node ID ee55d81f585ad20a403c93843fa259a1e76edb1a
# Parent  91d802f774565bf0a2344bf28d11a55a95524077
[project @ 1996-05-12 07:16:36 by jwe]
Initial revision

diff -r 91d802f77456 -r ee55d81f585a src/pt-pr-code.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/pt-pr-code.cc	Sun May 12 07:16:36 1996 +0000
@@ -0,0 +1,1174 @@
+/*
+
+Copyright (C) 1996 John W. Eaton
+
+This file is part of Octave.
+
+Octave is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+Octave is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Octave; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#if defined (__GNUG__)
+#pragma implementation
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <iostream.h>
+
+#include "error.h"
+#include "pr-output.h"
+#include "pt-pr-code.h"
+#include "user-prefs.h"
+
+void
+tree_print_code::visit_argument_list (tree_argument_list& lst)
+{
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      tree_expression *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << ", ";
+	}
+    }
+}
+
+void
+tree_print_code::visit_binary_expression (tree_binary_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  tree_expression *op1 = expr.lhs ();
+
+  if (op1)
+    op1->accept (*this);
+
+  os << " " << expr.oper () << " ";
+
+  tree_expression *op2 = expr.rhs ();
+
+  if (op2)
+    op2->accept (*this);
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_break_command (tree_break_command&)
+{
+  indent ();
+
+  os << "break";
+}
+
+void
+tree_print_code::visit_builtin (tree_builtin& fcn)
+{
+  os << fcn.name ()
+     << " can't be printed because it is a built-in function\n";
+}
+
+void
+tree_print_code::visit_colon_expression (tree_colon_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  tree_expression *op1 = expr.base ();
+
+  if (op1)
+    op1->accept (*this);
+
+  // Stupid syntax.
+
+  tree_expression *op3 = expr.increment ();
+
+  if (op3)
+    {
+      os << ":";
+      op3->accept (*this);
+    }
+
+  tree_expression *op2 = expr.limit ();
+
+  if (op2)
+    {
+      os << ":";
+      op2->accept (*this);
+    }
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_continue_command (tree_continue_command&)
+{
+  indent ();
+
+  os << "continue";
+}
+
+void
+tree_print_code::visit_for_command (tree_for_command& cmd)
+{
+  indent ();
+
+  os << "for ";
+
+  tree_index_expression *id = cmd.ident ();
+
+  if (id)
+    id->accept (*this);
+
+  os << " = ";
+
+  tree_expression *expr = cmd.control_expr ();
+
+  if (expr)
+    expr->accept (*this);
+
+  newline ();
+
+  tree_statement_list *list = cmd.body ();
+
+  if (list)
+    {
+      increment_indent_level ();
+      list->accept (*this);
+      decrement_indent_level ();
+    }
+
+  indent ();
+
+  os << "endfor";
+}
+
+void
+tree_print_code::visit_function (tree_function& fcn)
+{
+  reset ();
+
+  visit_function_header (fcn);
+
+  tree_statement_list *cmd_list = fcn.body ();
+
+  if (cmd_list)
+    {
+      increment_indent_level ();
+      cmd_list->accept (*this);
+      decrement_indent_level ();
+    }
+
+  visit_function_trailer (fcn);
+}
+
+void
+tree_print_code::visit_function_header (tree_function& fcn)
+{
+  indent ();
+
+  os << "function ";
+
+  tree_parameter_list *ret_list = fcn.return_list ();
+
+  if (ret_list)
+    {
+      bool takes_var_return = fcn.takes_var_return ();
+
+      int len = ret_list->length ();
+
+      if (len > 1 || takes_var_return)
+	os << "[";
+
+      ret_list->accept (*this);
+
+      if (takes_var_return)
+	{
+	  if (len > 0)
+	    os << ", ";
+
+	  os << "...";
+	}
+
+      if (len > 1 || takes_var_return)
+	os << "]";
+
+      os << " = ";
+    }
+
+  string fcn_name = fcn.function_name ();
+
+  os << (fcn_name.empty () ? string ("(empty)") : fcn_name) << " ";
+
+  tree_parameter_list *param_list = fcn.parameter_list ();
+
+  if (param_list)
+    {
+      bool takes_varargs = fcn.takes_varargs ();
+
+      int len = param_list->length ();
+
+      if (len > 0 || takes_varargs)
+	os << "(";
+
+      param_list->accept (*this);
+
+      if (takes_varargs)
+	{
+	  if (len > 0)
+	    os << ", ";
+
+	  os << "...";
+	}
+
+      if (len > 0 || takes_varargs)
+	{
+	  os << ")";
+	  newline ();
+	}
+    }
+  else
+    {
+      os << "()";
+      newline ();
+    }
+}
+
+void
+tree_print_code::visit_function_trailer (tree_function&)
+{
+  indent ();
+
+  os << "endfunction";
+
+  newline ();
+}
+
+void
+tree_print_code::visit_global (tree_global& cmd)
+{
+  tree_identifier *id = cmd.ident ();
+
+  if (id)
+    id->accept (*this);
+
+  tree_simple_assignment_expression *ass_expr = cmd.assign_expr ();
+
+  if (ass_expr)
+    ass_expr->accept (*this);
+}
+
+void
+tree_print_code::visit_global_command (tree_global_command& cmd)
+{
+  indent ();
+
+  os << "global ";
+
+  tree_global_init_list *init_list = cmd.initializer_list ();
+
+  if (init_list)
+    init_list->accept (*this);
+}
+
+void
+tree_print_code::visit_global_init_list (tree_global_init_list& lst)
+{
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      tree_global *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << ", ";
+	}
+    }
+}
+
+void
+tree_print_code::visit_identifier (tree_identifier& id)
+{
+  indent ();
+
+  bool in_parens = id.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  string nm = id.name ();
+  os << (nm.empty () ? string ("(empty)") : nm);
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_if_clause (tree_if_clause& cmd)
+{
+  tree_expression *expr = cmd.condition ();
+
+  if (expr)
+    expr->accept (*this);
+
+  newline ();
+
+  increment_indent_level ();
+
+  tree_statement_list *list = cmd.commands ();
+
+  if (list)
+    {
+      list->accept (*this);
+
+      decrement_indent_level ();
+    }
+}
+
+void
+tree_print_code::visit_if_command (tree_if_command& cmd)
+{
+  indent ();
+
+  os << "if ";
+
+  tree_if_command_list *list = cmd.cmd_list ();
+
+  if (list)
+    list->accept (*this);
+
+  indent ();
+
+  os << "endif";
+}
+
+void
+tree_print_code::visit_if_command_list (tree_if_command_list& lst)
+{
+  Pix p = lst.first ();
+
+  bool first_elt = true;
+
+  while (p)
+    {
+      tree_if_clause *elt = lst (p);
+
+      if (elt)
+	{
+	  if (! first_elt)
+	    {
+	      indent ();
+
+	      if (elt->is_else_clause ())
+		os << "else";
+	      else
+		os << "elseif ";
+	    }
+
+	  elt->accept (*this);
+	}
+
+      first_elt = false;
+      lst.next (p);
+    }
+}
+
+void
+tree_print_code::visit_index_expression (tree_index_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  tree_indirect_ref *id = expr.ident ();
+
+  if (id)
+    id->accept (*this);
+
+  tree_argument_list *list = expr.arg_list ();
+
+  if (list)
+    {
+      os << " (";
+      list->accept (*this);
+      os << ")";
+    }
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_indirect_ref (tree_indirect_ref& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  // The name of the indirect ref includes the sub-elements.
+
+  string nm = expr.name ();
+  os << (nm.empty () ? string ("(empty)") : nm);
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_matrix (tree_matrix& lst)
+{
+  indent ();
+
+  bool in_parens = lst.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  os << "[";
+
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      tree_matrix_row *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << "; ";
+	}
+    }
+
+  os << "]";
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_matrix_row (tree_matrix_row& lst)
+{
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      tree_expression *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << ", ";
+	}
+    }
+}
+
+void
+tree_print_code::visit_multi_assignment_expression
+  (tree_multi_assignment_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  tree_return_list *lhs = expr.left_hand_side ();
+
+  if (lhs)
+    {
+      int len = lhs->length ();
+
+      if (len > 1)
+	os << "[";
+
+      lhs->accept (*this);
+
+      if (len > 1)
+	os << "]";
+    }
+
+  os << " = ";
+
+  tree_multi_val_ret *rhs = expr.right_hand_side ();
+
+  if (rhs)
+    rhs->accept (*this);
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_oct_obj (tree_oct_obj&)
+{
+  ::error ("visit_oct_obj: internal error");
+}
+
+void
+tree_print_code::visit_octave_value (octave_value& val)
+{
+  indent ();
+
+  bool in_parens = val.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  if (val.is_real_scalar ())
+    {
+      string orig_text = val.original_text ();
+
+      if (orig_text.empty ())
+	octave_print_internal (os, val.double_value (), 1);
+      else
+	os << orig_text;
+    }
+  else if (val.is_real_matrix ())
+    {
+      octave_print_internal (os, val.matrix_value (), 1);
+    }
+  else if (val.is_complex_scalar ())
+    {
+      Complex cs = val.complex_value ();
+
+      double re = cs.real ();
+      double im = cs.imag ();
+
+      // If we have the original text and a pure imaginary, just
+      // print the original text, because this must be a constant
+      // that was parsed as part of a function.
+
+      string orig_text = val.original_text ();
+
+      if (! orig_text.empty () && re == 0.0 && im > 0.0)
+	os << orig_text;
+      else
+	octave_print_internal (os, cs, 1);
+    }
+  else if (val.is_complex_matrix ())
+    {
+      octave_print_internal (os, val.complex_matrix_value (), 1);
+    }
+  else if (val.is_char_matrix ())
+    {
+      octave_print_internal (os, val.char_matrix_value (), 1);
+    }
+  else if (val.is_string ())
+    {
+      octave_print_internal (os, val.all_strings (), 1, 1);
+    }
+  else if (val.is_range ())
+    {
+      octave_print_internal (os, val.range_value (), 1);
+    }
+  else if (val.is_magic_colon ())
+    {
+      os << ":";
+    }
+  else if (val.is_all_va_args ())
+    {
+      os << "all_va_args";
+    }
+  else
+    {
+      panic_impossible ();
+    }
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_parameter_list (tree_parameter_list& lst)
+{
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      tree_identifier *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << ", ";
+	}
+    }
+}
+
+void
+tree_print_code::visit_plot_command (tree_plot_command& cmd)
+{
+  indent ();
+
+  int ndim = cmd.num_dimensions ();
+
+  switch (ndim)
+    {
+    case 1:
+      os << "replot";
+      break;
+
+    case 2:
+      os << "gplot";
+      break;
+
+    case 3:
+      os << "gsplot";
+      break;
+
+    default:
+      os << "<unkown plot command>";
+      break;
+    }
+
+  plot_limits *range = cmd.limits ();
+
+  if (range)
+    range->accept (*this);
+
+  subplot_list *plot_list = cmd.subplots ();
+
+  if (plot_list)
+    plot_list->accept (*this);
+}
+
+void
+tree_print_code::visit_plot_limits (plot_limits& cmd)
+{
+  plot_range *x_range = cmd.x_limits ();
+
+  if (x_range)
+    x_range->accept (*this);
+
+  plot_range *y_range = cmd.y_limits ();
+
+  if (y_range)
+    y_range->accept (*this);
+
+  plot_range *z_range = cmd.z_limits ();
+
+  if (z_range)
+    z_range->accept (*this);
+}
+
+void
+tree_print_code::visit_plot_range (plot_range& cmd)
+{
+  os << " [";
+
+  tree_expression *lower = cmd.lower_bound ();
+
+  if (lower)
+    lower->accept (*this);
+
+  os << ":";
+
+  tree_expression *upper = cmd.upper_bound ();
+
+  if (upper)
+    upper->accept (*this);
+
+  os << "]";
+}
+
+void
+tree_print_code::visit_postfix_expression (tree_postfix_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  tree_identifier *id = expr.ident ();
+
+  if (id)
+    id->accept (*this);
+
+  os << expr.oper ();
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_prefix_expression (tree_prefix_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  os << expr.oper ();
+
+  tree_identifier *id = expr.ident ();
+
+  if (id)
+    id->accept (*this);
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_return_command (tree_return_command&)
+{
+  indent ();
+
+  os << "return";
+}
+
+void
+tree_print_code::visit_return_list (tree_return_list& lst)
+{
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      tree_index_expression *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << ", ";
+	}
+    }
+}
+
+void
+tree_print_code::visit_simple_assignment_expression
+  (tree_simple_assignment_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  if (! expr.is_ans_assign ())
+    {
+      tree_indirect_ref *lhs = expr.left_hand_side ();
+
+      if (lhs)
+	lhs->accept (*this);
+
+      tree_argument_list *index = expr.lhs_index ();
+
+      if (index)
+	{
+	  os << " (";
+	  index->accept (*this);
+	  os << ")";
+	}
+
+      os << " = ";
+    }
+
+  tree_expression *rhs = expr.right_hand_side ();
+
+  if (rhs)
+    rhs->accept (*this);
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_statement (tree_statement& stmt)
+{
+  tree_command *cmd = stmt.command ();
+
+  if (cmd)
+    {
+      cmd->accept (*this);
+
+      if (! stmt.print_result ())
+	os << ";";
+
+      newline ();
+    }
+  else
+    {
+      tree_expression *expr = stmt.expression ();
+
+      if (expr)
+	{
+	  expr->accept (*this);
+
+	  if (! stmt.print_result ())
+	    os << ";";
+
+	  newline ();
+	}
+    }
+}
+
+void
+tree_print_code::visit_statement_list (tree_statement_list& lst)
+{
+  for (Pix p = lst.first (); p != 0; lst.next (p))
+    {
+      tree_statement *elt = lst (p);
+
+      if (elt)
+	elt->accept (*this);
+    }
+}
+
+void
+tree_print_code::visit_subplot (subplot& cmd)
+{
+  tree_expression *sp_plot_data = cmd.plot_data ();
+
+  if (sp_plot_data)
+    {
+      os << " ";
+
+      sp_plot_data->accept (*this);
+    }
+
+  subplot_using *sp_using_clause = cmd.using_clause ();
+
+  if (sp_using_clause)
+    sp_using_clause->accept (*this);
+
+  tree_expression *sp_title_clause = cmd.title_clause ();
+
+  if (sp_title_clause)
+    sp_title_clause->accept (*this);
+
+  subplot_style *sp_style_clause = cmd.style_clause ();
+
+  if (sp_style_clause)
+    sp_style_clause->accept (*this);
+}
+
+void
+tree_print_code::visit_subplot_list (subplot_list& lst)
+{
+  Pix p = lst.first ();
+
+  while (p)
+    {
+      subplot *elt = lst (p);
+
+      lst.next (p);
+
+      if (elt)
+	{
+	  elt->accept (*this);
+
+	  if (p)
+	    os << ",";
+	}
+    }
+}
+
+void
+tree_print_code::visit_subplot_style (subplot_style& cmd)
+{
+  os << " with " << cmd.style ();
+
+  tree_expression *sp_linetype = cmd.linetype ();
+
+  if (sp_linetype)
+    {
+      os << " ";
+
+      sp_linetype->accept (*this);
+    }
+
+  tree_expression *sp_pointtype = cmd.pointtype ();
+
+  if (sp_pointtype)
+    {
+      os << " ";
+
+      sp_pointtype->accept (*this);
+    }
+}
+
+void
+tree_print_code::visit_subplot_using (subplot_using& cmd)
+{
+  os << " using ";
+
+  int qual_count = cmd.qualifier_count ();
+
+  if (qual_count > 0)
+    {
+      tree_expression **x = cmd.qualifiers ();
+
+      for (int i = 0; i < qual_count; i++)
+	{
+	  if (i > 0)
+	    os << ":";
+
+	  if (x[i])
+	    x[i]->accept (*this);
+	}
+    }
+  else
+    {
+      tree_expression *scanf_fmt = cmd.scanf_format ();
+
+      if (scanf_fmt)
+	scanf_fmt->accept (*this);
+    }
+}
+
+void
+tree_print_code::visit_try_catch_command (tree_try_catch_command& cmd)
+{
+  indent ();
+
+  os << "try_catch";
+
+  newline ();
+
+  tree_statement_list *try_code = cmd.body ();
+
+  if (try_code)
+    {
+      increment_indent_level ();
+      try_code->accept (*this);
+      decrement_indent_level ();
+    }
+
+  indent ();
+
+  os << "catch";
+
+  newline ();
+
+  tree_statement_list *catch_code = cmd.cleanup ();
+
+  if (catch_code)
+    {
+      increment_indent_level ();
+      catch_code->accept (*this);
+      decrement_indent_level ();
+    }
+
+  indent ();
+
+  os << "end_try_catch";
+}
+
+void
+tree_print_code::visit_unary_expression (tree_unary_expression& expr)
+{
+  indent ();
+
+  bool in_parens = expr.is_in_parens ();
+
+  if (in_parens)
+    os << "(";
+
+  tree_expression *op = expr.operand ();
+
+  tree_expression::type etype = expr.expression_type ();
+
+  switch (etype)
+    {
+    case tree_expression::hermitian:
+    case tree_expression::transpose:
+      if (op)
+	op->accept (*this);
+	os << expr.oper ();
+      break;
+
+    case tree_expression::not:
+    case tree_expression::uminus:
+    default:
+      os << expr.oper ();
+      if (op)
+	op->accept (*this);
+      break;
+    }
+
+  if (in_parens)
+    os << ")";
+}
+
+void
+tree_print_code::visit_unwind_protect_command
+  (tree_unwind_protect_command& cmd)
+{
+  indent ();
+
+  os << "unwind_protect";
+
+  newline ();
+
+  tree_statement_list *unwind_protect_code = cmd.body ();
+
+  if (unwind_protect_code)
+    {
+      increment_indent_level ();
+      unwind_protect_code->accept (*this);
+      decrement_indent_level ();
+    }
+
+  indent ();
+
+  os << "cleanup_code";
+
+  newline ();
+
+  tree_statement_list *cleanup_code = cmd.cleanup ();
+
+  if (cleanup_code)
+    {
+      increment_indent_level ();
+      cleanup_code->accept (*this);
+      decrement_indent_level ();
+    }
+
+  indent ();
+
+  os << "end_unwind_protect";
+}
+
+void
+tree_print_code::visit_while_command (tree_while_command& cmd)
+{
+  indent ();
+
+  os << "while ";
+
+  tree_expression *expr = cmd.condition ();
+
+  if (expr)
+    expr->accept (*this);
+
+  newline ();
+
+  tree_statement_list *list = cmd.body ();
+
+  if (list)
+    {
+      increment_indent_level ();
+      list->accept (*this);
+      decrement_indent_level ();
+    }
+
+  indent ();
+
+  os << "endwhile";
+}
+
+// Current indentation.
+int tree_print_code::curr_print_indent_level = 0;
+
+// Nonzero means we are at the beginning of a line.
+bool tree_print_code::beginning_of_line = true;
+
+// Each print_code() function should call this before printing
+// anything.
+//
+// This doesn't need to be fast, but isn't there a better way?
+
+void
+tree_print_code::indent (void)
+{
+  assert (curr_print_indent_level >= 0);
+ 
+  if (beginning_of_line)
+    {
+      os.form ("%s%*s", user_pref.ps4.c_str (), curr_print_indent_level, "");
+      beginning_of_line = false;
+    }
+}
+
+// All print_code() functions should use this to print new lines.
+
+void
+tree_print_code::newline (void)
+{
+  os << "\n";
+
+  beginning_of_line = true;
+}
+
+// For ressetting print_code state.
+
+void
+tree_print_code::reset (void)
+{
+  beginning_of_line = true;
+  curr_print_indent_level = 0;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/
diff -r 91d802f77456 -r ee55d81f585a src/pt-pr-code.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/pt-pr-code.h	Sun May 12 07:16:36 1996 +0000
@@ -0,0 +1,168 @@
+/*
+
+Copyright (C) 1996 John W. Eaton
+
+This file is part of Octave.
+
+Octave is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+Octave is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Octave; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#if !defined (octave_tree_print_code_h)
+#define octave_tree_print_code_h 1
+
+#if defined (__GNUG__)
+#pragma interface
+#endif
+
+#include "pt-walk.h"
+
+// How to print the code that the parse trees represent.
+
+class
+tree_print_code : public tree_walker
+{
+public:
+
+  tree_print_code (ostream& os_arg) : os (os_arg) { }
+
+  ~tree_print_code (void) { }
+
+  void visit_argument_list (tree_argument_list&);
+
+  void visit_binary_expression (tree_binary_expression&);
+
+  void visit_break_command (tree_break_command&);
+
+  void visit_builtin (tree_builtin&);
+
+  void visit_colon_expression (tree_colon_expression&);
+
+  void visit_continue_command (tree_continue_command&);
+
+  void visit_for_command (tree_for_command&);
+
+  void visit_function (tree_function&);
+
+  void visit_function_header (tree_function&);
+
+  void visit_function_trailer (tree_function&);
+
+  void visit_global (tree_global&);
+
+  void visit_global_command (tree_global_command&);
+
+  void visit_global_init_list (tree_global_init_list&);
+
+  void visit_identifier (tree_identifier&);
+
+  void visit_if_clause (tree_if_clause&);
+
+  void visit_if_command (tree_if_command&);
+
+  void visit_if_command_list (tree_if_command_list&);
+
+  void visit_index_expression (tree_index_expression&);
+
+  void visit_indirect_ref (tree_indirect_ref&);
+
+  void visit_matrix (tree_matrix&);
+
+  void visit_matrix_row (tree_matrix_row&);
+
+  void visit_multi_assignment_expression (tree_multi_assignment_expression&);
+
+  void visit_oct_obj (tree_oct_obj&);
+
+  void visit_octave_value (octave_value&);
+
+  void visit_parameter_list (tree_parameter_list&);
+
+  void visit_plot_command (tree_plot_command&);
+
+  void visit_plot_limits (plot_limits&);
+
+  void visit_plot_range (plot_range&);
+
+  void visit_postfix_expression (tree_postfix_expression&);
+
+  void visit_prefix_expression (tree_prefix_expression&);
+
+  void visit_return_command (tree_return_command&);
+
+  void visit_return_list (tree_return_list&);
+
+  void visit_simple_assignment_expression (tree_simple_assignment_expression&);
+
+  void visit_statement (tree_statement&);
+
+  void visit_statement_list (tree_statement_list&);
+
+  void visit_subplot (subplot&);
+
+  void visit_subplot_list (subplot_list&);
+
+  void visit_subplot_style (subplot_style&);
+
+  void visit_subplot_using (subplot_using&);
+
+  void visit_try_catch_command (tree_try_catch_command&);
+
+  void visit_unary_expression (tree_unary_expression&);
+
+  void visit_unwind_protect_command (tree_unwind_protect_command&);
+
+  void visit_while_command (tree_while_command&);
+
+private:
+
+  ostream& os;
+
+  static int curr_print_indent_level;
+  static bool beginning_of_line;
+
+  void reset_indent_level (void)
+    { curr_print_indent_level = 0; }
+
+  void increment_indent_level (void)
+    { curr_print_indent_level += 2; }
+
+  void decrement_indent_level (void)
+    { curr_print_indent_level -= 2; }
+
+  void newline (void);
+
+  void indent (void);
+
+  void reset (void);
+
+  // Must create with an output stream!
+
+  tree_print_code (void);
+
+  // No copying!
+
+  tree_print_code (const tree_print_code&);
+
+  tree_print_code& operator = (const tree_print_code&);
+};
+
+#endif
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/
diff -r 91d802f77456 -r ee55d81f585a src/pt-walk.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/pt-walk.h	Sun May 12 07:16:36 1996 +0000
@@ -0,0 +1,185 @@
+/*
+
+Copyright (C) 1996 John W. Eaton
+
+This file is part of Octave.
+
+Octave is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+Octave is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Octave; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#if !defined (octave_tree_walker_h)
+#define octave_tree_walker_h 1
+
+#include "pt-cmd.h"
+#include "pt-const.h"
+#include "pt-exp.h"
+#include "pt-fcn.h"
+#include "pt-fvc.h"
+#include "pt-mat.h"
+#include "pt-misc.h"
+#include "pt-mvr.h"
+#include "pt-plot.h"
+
+class
+tree_walker
+{
+public:
+
+  virtual void
+  visit_argument_list (tree_argument_list&) = 0;
+
+  virtual void
+  visit_binary_expression (tree_binary_expression&) = 0;
+
+  virtual void
+  visit_break_command (tree_break_command&) = 0;
+
+  virtual void
+  visit_builtin (tree_builtin&) = 0;
+
+  virtual void
+  visit_colon_expression (tree_colon_expression&) = 0;
+
+  virtual void
+  visit_continue_command (tree_continue_command&) = 0;
+
+  virtual void
+  visit_for_command (tree_for_command&) = 0;
+
+  virtual void
+  visit_function (tree_function&) = 0;
+
+  virtual void
+  visit_global (tree_global&) = 0;
+
+  virtual void
+  visit_global_command (tree_global_command&) = 0;
+
+  virtual void
+  visit_global_init_list (tree_global_init_list&) = 0;
+
+  virtual void
+  visit_identifier (tree_identifier&) = 0;
+
+  virtual void
+  visit_if_clause (tree_if_clause&) = 0;
+
+  virtual void
+  visit_if_command (tree_if_command&) = 0;
+
+  virtual void
+  visit_if_command_list (tree_if_command_list&) = 0;
+
+  virtual void
+  visit_index_expression (tree_index_expression&) = 0;
+
+  virtual void
+  visit_indirect_ref (tree_indirect_ref&) = 0;
+
+  virtual void
+  visit_matrix (tree_matrix&) = 0;
+
+  virtual void
+  visit_matrix_row (tree_matrix_row&) = 0;
+
+  virtual void
+  visit_multi_assignment_expression (tree_multi_assignment_expression&) = 0;
+
+  virtual void
+  visit_oct_obj (tree_oct_obj&) = 0;
+
+  virtual void
+  visit_octave_value (octave_value&) = 0;
+
+  virtual void
+  visit_parameter_list (tree_parameter_list&) = 0;
+
+  virtual void
+  visit_plot_command (tree_plot_command&) = 0;
+
+  virtual void
+  visit_plot_limits (plot_limits&) = 0;
+
+  virtual void
+  visit_plot_range (plot_range&) = 0;
+
+  virtual void
+  visit_postfix_expression (tree_postfix_expression&) = 0;
+
+  virtual void
+  visit_prefix_expression (tree_prefix_expression&) = 0;
+
+  virtual void
+  visit_return_command (tree_return_command&) = 0;
+
+  virtual void
+  visit_return_list (tree_return_list&) = 0;
+
+  virtual void
+  visit_simple_assignment_expression (tree_simple_assignment_expression&) = 0;
+
+  virtual void
+  visit_statement (tree_statement&) = 0;
+
+  virtual void
+  visit_statement_list (tree_statement_list&) = 0;
+
+  virtual void
+  visit_subplot (subplot&) = 0;
+
+  virtual void
+  visit_subplot_list (subplot_list&) = 0;
+
+  virtual void
+  visit_subplot_style (subplot_style&) = 0;
+
+  virtual void
+  visit_subplot_using (subplot_using&) = 0;
+
+  virtual void
+  visit_try_catch_command (tree_try_catch_command&) = 0;
+
+  virtual void
+  visit_unary_expression (tree_unary_expression&) = 0;
+
+  virtual void
+  visit_unwind_protect_command (tree_unwind_protect_command&) = 0;
+
+  virtual void
+  visit_while_command (tree_while_command&) = 0;
+
+protected:
+
+  tree_walker (void) { }
+
+  virtual ~tree_walker (void) { }
+
+private:
+
+  // No copying!
+
+  tree_walker (const tree_walker&);
+
+  tree_walker& operator = (const tree_walker&);
+};
+
+#endif
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/