# HG changeset patch # User jwe # Date 821444606 0 # Node ID bbfca89cb1cdd62f908ef2a74baf854d303331d2 # Parent bb9d00aa55fb6a902e55e79c7b221e740f6ebfe0 [project @ 1996-01-12 11:03:26 by jwe] Initial revision diff --git a/src/pt-exp.h b/src/pt-exp.h new file mode 100644 --- /dev/null +++ b/src/pt-exp.h @@ -0,0 +1,273 @@ +// tree-expr2.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_expr2_h) +#define octave_tree_expr2_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; + +#include "pt-exp-base.h" + +// Prefix expressions. + +class +tree_prefix_expression : public tree_expression +{ + public: + tree_prefix_expression (int l = -1, int c = -1) + : tree_expression (l, c), id (0) { } + + tree_prefix_expression (tree_identifier *t, tree_expression::type et, + int l = -1, int c = -1) + : tree_expression (l, c, et), id (t) { } + + ~tree_prefix_expression (void); + + tree_constant eval (int print); + + void eval_error (void); + + int is_prefix_expression (void) const + { return 1; } + + char *oper (void) const; + + void print_code (ostream& os); + + private: + tree_identifier *id; +}; + +// Postfix expressions. + +class +tree_postfix_expression : public tree_expression +{ + public: + tree_postfix_expression (int l = -1, int c = -1) + : tree_expression (l, c), id (0) { } + + tree_postfix_expression (tree_identifier *t, tree_expression::type et, + int l = -1, int c = -1) + : tree_expression (l, c, et), id (t) { } + + ~tree_postfix_expression (void); + + tree_constant eval (int print); + + void eval_error (void); + + char *oper (void) const; + + void print_code (ostream& os); + + private: + tree_identifier *id; +}; + +// 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 *a, tree_expression::type t, + int l = -1, int c = -1) + : tree_expression (l, c, t), op (a) { } + + ~tree_unary_expression (void) + { delete op; } + + tree_constant eval (int print); + + void eval_error (void); + + char *oper (void) const; + + void print_code (ostream& os); + + private: + tree_expression *op; +}; + +// Binary expressions. + +class +tree_binary_expression : public tree_expression +{ + public: + tree_binary_expression (int l = -1, int c = -1) + : tree_expression (l, c), op1 (0), op2 (0) { } + + tree_binary_expression (tree_expression *a, tree_expression *b, + tree_expression::type t, int l = -1, int c = -1) + : tree_expression (l, c, t), op1 (a), op2 (b) { } + + ~tree_binary_expression (void) + { + delete op1; + delete op2; + } + + tree_constant eval (int print); + + void eval_error (void); + + char *oper (void) const; + + void print_code (ostream& os); + + private: + tree_expression *op1; + tree_expression *op2; +}; + +// Simple assignment expressions. + +class +tree_simple_assignment_expression : public tree_expression +{ +private: + void init (int plhs, int ans_assign) + { + etype = tree_expression::assignment; + lhs_idx_expr = 0; + lhs = 0; + index = 0; + rhs = 0; + preserve = plhs; + ans_ass = ans_assign; + } + + public: + tree_simple_assignment_expression (int plhs = 0, int ans_assign = 0, + int l = -1, int c = -1) + : tree_expression (l, c) + { init (plhs, ans_assign); } + + tree_simple_assignment_expression (tree_identifier *i, + tree_expression *r, + int plhs = 0, int ans_assign = 0, + int l = -1, int c = -1); + + tree_simple_assignment_expression (tree_indirect_ref *i, + tree_expression *r, + int plhs = 0, int ans_assign = 0, + int l = -1, int c = -1) + : tree_expression (l, c) + { + init (plhs, ans_assign); + lhs = i; + rhs = r; + } + + tree_simple_assignment_expression (tree_index_expression *idx_expr, + tree_expression *r, + int plhs = 0, int ans_assign = 0, + int l = -1, int c = -1); + + ~tree_simple_assignment_expression (void); + + int left_hand_side_is_identifier_only (void); + + tree_identifier *left_hand_side_id (void); + + int is_ans_assign (void) + { return ans_ass; } + + tree_constant eval (int print); + + int is_assignment_expression (void) const + { return 1; } + + void eval_error (void); + + void print_code (ostream& os); + + private: + tree_index_expression *lhs_idx_expr; + tree_indirect_ref *lhs; + tree_argument_list *index; + tree_expression *rhs; + int preserve; + int ans_ass; +}; + +// Colon expressions. + +class +tree_colon_expression : public tree_expression +{ + public: + tree_colon_expression (int l = -1, int c = -1) + : tree_expression (l, c, tree_expression::colon), + op1(0), op2 (0), op3 (0) { } + + tree_colon_expression (tree_expression *a, tree_expression *b, + int l = -1, int c = -1) + : tree_expression (l, c, tree_expression::colon), + op1 (a), op2 (b), op3 (0) { } + + ~tree_colon_expression (void) + { + delete op1; + delete op2; + delete op3; + } + + int is_range_constant (void) const; + + tree_colon_expression *chain (tree_expression *t); + + tree_constant eval (int print); + + void eval_error (const char *s); + + void print_code (ostream& os); + + private: + tree_expression *op1; + tree_expression *op2; + tree_expression *op3; +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/ diff --git a/src/pt-fcn.h b/src/pt-fcn.h new file mode 100644 --- /dev/null +++ b/src/pt-fcn.h @@ -0,0 +1,164 @@ +// pt-fcn.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_fcn_h) +#define octave_tree_fcn_h 1 + +#if defined (__GNUG__) +#pragma interface +#endif + +#include + +class ostream; + +class tree_parameter_list; +class tree_statement_list; +class tree_va_return_list; + +#include "oct-obj.h" +#include "symtab.h" +#include "pt-fvc.h" + +// User defined functions. + +class +tree_function : public tree_fvc +{ +private: + void install_nargin_and_nargout (void); + + void bind_nargin_and_nargout (int nargin, int nargout); + + void init (void) + { + call_depth = 0; + param_list = 0; + ret_list = 0; + sym_tab = 0; + cmd_list = 0; + file_name = 0; + fcn_name = 0; + t_parsed = 0; + system_fcn_file = 0; + num_named_args = 0; + num_args_passed = 0; + curr_va_arg_number = 0; + vr_list = 0; + } + +public: + tree_function (int l = -1, int c = -1) : tree_fvc (l, c) + { init (); } + + tree_function (tree_statement_list *cl, symbol_table *st, + int l = -1, int c = -1) + : tree_fvc (l, c) + { + init (); + sym_tab = st; + cmd_list = cl; + install_nargin_and_nargout (); + } + + ~tree_function (void); + +// tree_function *define (tree_statement_list *t); + tree_function *define_param_list (tree_parameter_list *t); + tree_function *define_ret_list (tree_parameter_list *t); + + void stash_fcn_file_name (void); + + void stash_fcn_file_time (time_t t) + { t_parsed = t; } + + char *fcn_file_name (void) + { return file_name; } + + time_t time_parsed (void) + { return t_parsed; } + + void mark_as_system_fcn_file (void); + + int is_system_fcn_file (void) const + { return system_fcn_file; } + + int takes_varargs (void) const; + + void octave_va_start (void) + { curr_va_arg_number = num_named_args; } + + tree_constant octave_va_arg (void); + + Octave_object octave_all_va_args (void); + + int takes_var_return (void) const; + + void octave_vr_val (const tree_constant& val); + + void stash_function_name (char *s); + + char *function_name (void) + { return fcn_name; } + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + void traceback_error (void); + + void print_code (ostream& os); + +private: + int call_depth; + tree_parameter_list *param_list; + tree_parameter_list *ret_list; + symbol_table *sym_tab; + tree_statement_list *cmd_list; + char *file_name; + char *fcn_name; + time_t t_parsed; + int system_fcn_file; + int num_named_args; + Octave_object args_passed; + int num_args_passed; + int curr_va_arg_number; + tree_va_return_list *vr_list; + symbol_record *nargin_sr; + symbol_record *nargout_sr; + + void print_code_function_header (void); + void print_code_function_header (ostream& os); + + void print_code_function_trailer (void); + void print_code_function_trailer (ostream& os); +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/ diff --git a/src/pt-fvc-base.h b/src/pt-fvc-base.h new file mode 100644 --- /dev/null +++ b/src/pt-fvc-base.h @@ -0,0 +1,81 @@ +// pt-fvc.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_fvc_h) +#define octave_tree_fvc_h 1 + +#if defined (__GNUG__) +#pragma interface +#endif + +#include + +class ostream; + +#include + +class tree_constant; +class Octave_object; + +#include "pt-mvr-base.h" + +// A base class for objects that can be evaluated with argument lists. + +class +tree_fvc : public tree_multi_val_ret +{ +public: + tree_fvc (int l = -1, int c = -1) : tree_multi_val_ret (l, c) { } + + ~tree_fvc (void) { } + + virtual tree_constant assign (tree_constant& t, + const Octave_object& args); + + virtual char *name (void) const; + + virtual void bump_value (tree_expression::type); + + virtual tree_constant lookup_map_element (SLList& list, + int insert = 0, int silent = 0); + + virtual char *fcn_file_name (void) + { return 0; } + + virtual time_t time_parsed (void); + + virtual int is_system_fcn_file (void) const + { return 0; } + + virtual int save (ostream& /* os */, int /* mark_as_global */ = 0, + int /* precision */ = 17); +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/ diff --git a/src/pt-fvc.h b/src/pt-fvc.h new file mode 100644 --- /dev/null +++ b/src/pt-fvc.h @@ -0,0 +1,191 @@ +// tree-fvc2.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_fvc2_h) +#define octave_tree_fvc2_h 1 + +#if defined (__GNUG__) +#pragma interface +#endif + +class ostream; + +#include + +class symbol_record; +class tree_function; + +#include "mappers.h" +#include "pt-fvc-base.h" +#include "variables.h" + +// Symbols from the symbol table. + +class +tree_identifier : public tree_fvc +{ + friend class tree_index_expression; + +public: + tree_identifier (int l = -1, int c = -1) + : tree_fvc (l, c), sym (0), maybe_do_ans_assign (0) { } + + tree_identifier (symbol_record *s, int l = -1, int c = -1) + : tree_fvc (l, c), sym (s), maybe_do_ans_assign (0) { } + + ~tree_identifier (void) { } + + int is_identifier (void) const + { return 1; } + + char *name (void) const; + + tree_identifier *define (tree_constant *t); + tree_identifier *define (tree_function *t); + + void document (char *s); + + tree_constant assign (tree_constant& t); + tree_constant assign (tree_constant& t, const Octave_object& args); + + tree_constant assign (SLList list, tree_constant& t); + tree_constant assign (SLList list, tree_constant& t, + const Octave_object& args); + + int is_defined (void); + + void bump_value (tree_expression::type); + + tree_fvc *do_lookup (int& script_file_executed, int exec_script = 1); + + void link_to_global (void); + + void mark_as_formal_parameter (void); + + void mark_for_possible_ans_assign (void) + { maybe_do_ans_assign = 1; } + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + void eval_undefined_error (void); + + void print_code (ostream& os); + +private: + symbol_record *sym; + int maybe_do_ans_assign; +}; + +// Indirect references to values (structure references). + +class +tree_indirect_ref : public tree_fvc +{ +public: + tree_indirect_ref (int l = -1, int c = -1) + : tree_fvc (l, c), id (0), preserve_ident (0) { } + + tree_indirect_ref (tree_identifier *i, int l = -1, int c = -1) + : tree_fvc (l, c), id (i), preserve_ident (0) { } + + ~tree_indirect_ref (void); + + tree_indirect_ref *chain (const char *s); + + int is_indirect_ref (void) const + { return 1; } + + int is_identifier_only (void) const + { return (id && refs.empty ()); } + + tree_identifier *ident (void) + { return id; } + + void preserve_identifier (void) + { preserve_ident = 1; } + + char *name (void); + + tree_constant assign (tree_constant& t); + tree_constant assign (tree_constant& t, const Octave_object& args); + + void mark_for_possible_ans_assign (void) + { id->mark_for_possible_ans_assign (); } + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + void print_code (ostream& os); + +private: + tree_identifier *id; + SLList refs; + int preserve_ident; +}; + +// Builtin functions. + +class +tree_builtin : public tree_fvc +{ +public: + tree_builtin (const char *nm = 0); + + tree_builtin (Mapper_fcn& m_fcn, const char *nm = 0); + + tree_builtin (Octave_builtin_fcn f, const char *nm = 0); + + ~tree_builtin (void) { } // XXX ?? XXX + +// int is_builtin (void) const; + + int is_mapper_function (void) const + { return is_mapper; } + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + char *name (void) const + { return my_name; } + + void print_code (ostream& os); + +private: + int is_mapper; + Mapper_fcn mapper_fcn; + Octave_builtin_fcn fcn; + char *my_name; +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/ diff --git a/src/pt-mat.h b/src/pt-mat.h new file mode 100644 --- /dev/null +++ b/src/pt-mat.h @@ -0,0 +1,86 @@ +// pt-mat.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_mat_h) +#define octave_tree_mat_h 1 + +#if defined (__GNUG__) +#pragma interface +#endif + +class ostream; + +class tree_constant; +class tree_return_list; + +#include "pt-exp.h" + +// General matrices. This allows us to construct matrices from +// other matrices, variables, and functions. + +class +tree_matrix : public tree_expression +{ +public: + enum dir + { + md_none, + md_right, + md_down, + }; + + tree_matrix (void) + : tree_expression (), direction (tree_matrix::md_none), + element (0), next (0) { } + + tree_matrix (tree_expression *e, tree_matrix::dir d) + : tree_expression (), direction (d), element (e), next (0) { } + + ~tree_matrix (void); + + int is_matrix_constant (void) const; + + tree_matrix *chain (tree_expression *e, tree_matrix::dir d); + tree_matrix *reverse (void); + int length (void); + + tree_return_list *to_return_list (void); + + tree_constant eval (int print); + + void print_code (ostream& os); + +private: + tree_matrix::dir direction; // Direction from the previous element. + tree_expression *element; + tree_matrix *next; +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/ diff --git a/src/pt-mvr-base.h b/src/pt-mvr-base.h new file mode 100644 --- /dev/null +++ b/src/pt-mvr-base.h @@ -0,0 +1,65 @@ +// pt-mvr.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_mvr_h) +#define octave_tree_mvr_h 1 + +#if defined (__GNUG__) +#pragma interface +#endif + +class tree_constant; +class Octave_object; + +#include "pt-exp-base.h" + +// A base class for objects that can be return multiple values + +class +tree_multi_val_ret : public tree_expression +{ +public: + tree_multi_val_ret (int l = -1, int c = -1) : tree_expression (l, c) { } + + tree_multi_val_ret (int l = -1, int c = -1, tree_expression::type et) + : tree_expression (l, c, et) { } + + ~tree_multi_val_ret (void) { } + + int is_multi_val_ret_expression (void) const + { return 1; } + + tree_constant eval (int print); + + virtual Octave_object eval (int print, int nargout, + const Octave_object& args) = 0; +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/ diff --git a/src/pt-mvr.h b/src/pt-mvr.h new file mode 100644 --- /dev/null +++ b/src/pt-mvr.h @@ -0,0 +1,160 @@ +// tree-mvr2.h -*- C++ -*- +/* + +Copyright (C) 1992, 1993, 1994, 1995 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_mvr2_h) +#define octave_tree_mvr2_h 1 + +#if defined (__GNUG__) +#pragma interface +#endif + +class ostream; + +class Octave_object; + +class tree_argument_list; +class tree_identifier; +class tree_index_expression; +class tree_indirect_ref; +class tree_return_list; + +#include "pt-const.h" +#include "pt-mvr-base.h" +#include "oct-obj.h" + +// Used internally. + +class +tree_oct_obj : public tree_multi_val_ret +{ +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_multi_val_ret (l, c), values (v) { } + + ~tree_oct_obj (void) { } + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + void print_code (ostream&) { } + +private: + Octave_object values; +}; + +// Index expressions. + +class +tree_index_expression : public tree_multi_val_ret +{ +public: + tree_index_expression (int l = -1, int c = -1) + : tree_multi_val_ret (l, c), id (0), list (0) { } + + tree_index_expression (tree_identifier *i, int l = -1, int c = -1); + + tree_index_expression (tree_identifier *i, tree_argument_list *lst, + int l = -1, int c = -1); + + tree_index_expression (tree_indirect_ref *i, int l = -1, int c = -1) + : tree_multi_val_ret (l, c), id (i), list (0) { } + + tree_index_expression (tree_indirect_ref *i, tree_argument_list *lst, + int l = -1, int c = -1) + : tree_multi_val_ret (l, c), id (i), list (lst) { } + + ~tree_index_expression (void); + + int is_index_expression (void) const + { return 1; } + + tree_indirect_ref *ident (void) + { return id; } + + char *name (void); + + tree_argument_list *arg_list (void) + { return list; } + + void mark_for_possible_ans_assign (void); + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + void eval_error (void); + + void print_code (ostream& os); + + private: + tree_indirect_ref *id; + tree_argument_list *list; +}; + +// Multi-valued assignment expressions. + +class +tree_multi_assignment_expression : public tree_multi_val_ret +{ + public: + tree_multi_assignment_expression (int plhs = 0, int l = -1, int c = -1) + : tree_multi_val_ret (l, c, tree_expression::multi_assignment), + preserve (plhs), lhs (0), rhs (0) { } + + tree_multi_assignment_expression (tree_return_list *lst, + tree_multi_val_ret *r, + int plhs = 0, + int l = -1, int c = -1) + : tree_multi_val_ret (l, c, tree_expression::multi_assignment), + preserve (plhs), lhs (lst), rhs (r) { } + + ~tree_multi_assignment_expression (void); + + tree_constant eval (int print); + + Octave_object eval (int print, int nargout, const Octave_object& args); + + int is_assignment_expression (void) const + { return 1; } + + void eval_error (void); + + void print_code (ostream& os); + + private: + int preserve; + tree_return_list *lhs; + tree_multi_val_ret *rhs; +}; + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/