octave: libinterp/parse-tree/pt-idx.cc annotate

annotate libinterp/parse-tree/pt-idx.cc @ 29163:8f67ad8b3103

maint: Updating naming conventions for exceptions and use const where possible. * GLCanvas.cc, interpreter-qobject.cc, file-editor-tab.cc, octave-qscintilla.cc, octave-qobject.cc, Cell.cc, __eigs__.cc, __magick_read__.cc, __qp__.cc, daspk.cc, dasrt.cc, dassl.cc, data.cc, file-io.cc, graphics.cc, graphics.in.h, input.cc, interpreter.cc, ls-mat-ascii.cc, lsode.cc, oct-handle.h, oct-map.cc, quad.cc, rand.cc, sparse.cc, sub2ind.cc, toplev.cc, utils.cc, __init_gnuplot__.cc, __ode15__.cc, cdef-object.cc, ov-base-diag.cc, ov-base-mat.cc, ov-base-sparse.cc, ov-base.cc, ov-fcn-handle.cc, ov-java.cc, ov-perm.cc, ov-range.cc, ov-re-diag.cc, ov-str-mat.cc, ov.cc, pt-assign.cc, pt-eval.cc, pt-idx.cc, pt-jit.cc, pt.cc, Array-util.cc, randmtzig.cc: Update naming conventions for exceptions to use initial letter of exception type. For example, "execution_exception" is named "ee", "index_exception" is "ie". Catch "const" exceptions where possible. * gzip.cc: Add block to catch and throw interrupt_exceptions before having a catch block "(...)" for everything else.

author	Rik <rik@octave.org>
date	Tue, 08 Dec 2020 13:25:03 -0800
parents	2219b0ed8754
children	7854d5752dd2

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	3 // Copyright (C) 1996-2020 The Octave Project Developers
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	4 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	7 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	9 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	14 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	19 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ////////////////////////////////////////////////////////////////////////
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	25
21724 aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef" John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	26 #if defined (HAVE_CONFIG_H)
21301 40de9f8f23a6 Use '#include "config.h"' rather than <config.h>. Rik <rik@octave.org> parents: 21200 diff changeset	27 # include "config.h"
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	28 #endif
cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	29
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	30 #include "Cell.h"
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	31 #include "error.h"
23599 5cb3a2bb5e1e don't use singleton for symbol_table John W. Eaton <jwe@octave.org> parents: 23576 diff changeset	32 #include "interpreter-private.h"
3930 61d4427c016e [project @ 2002-05-07 00:47:31 by jwe] jwe parents: 3929 diff changeset	33 #include "oct-map.h"
20940 48b2ad5ee801 maint: Rename oct-obj.[cc\|h] to ovl.[cc\|h] for clarity. Rik <rik@octave.org> parents: 20700 diff changeset	34 #include "ovl.h"
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	35 #include "oct-lvalue.h"
cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	36 #include "ov.h"
2982 20f5cec4f11c [project @ 1997-05-16 03:29:26 by jwe] jwe parents: 2980 diff changeset	37 #include "pt-arg-list.h"
23435 c452180ab672 begin refactoring parse tree evaluator John W. Eaton <jwe@octave.org> parents: 23396 diff changeset	38 #include "pt-eval.h"
7336 745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7200 diff changeset	39 #include "pt-id.h"
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	40 #include "pt-idx.h"
3930 61d4427c016e [project @ 2002-05-07 00:47:31 by jwe] jwe parents: 3929 diff changeset	41 #include "utils.h"
61d4427c016e [project @ 2002-05-07 00:47:31 by jwe] jwe parents: 3929 diff changeset	42 #include "variables.h"
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 20977 diff changeset	43 #include "errwarn.h"
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	44
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	45 namespace octave
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	46 {
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	47 // Index expressions.
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	48
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	49 tree_index_expression::tree_index_expression (int l, int c)
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	50 : tree_expression (l, c), m_expr (nullptr), m_args (0), m_type (),
26662 05fc703b419a update handling of command-style function call syntax in eval John W. Eaton <jwe@octave.org> parents: 26660 diff changeset	51 m_arg_nm (), m_dyn_field (), m_word_list_cmd (false) { }
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	52
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	53 tree_index_expression::tree_index_expression (tree_expression *e,
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	54 tree_argument_list *lst,
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	55 int l, int c, char t)
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	56 : tree_expression (l, c), m_expr (e), m_args (0), m_type (),
26662 05fc703b419a update handling of command-style function call syntax in eval John W. Eaton <jwe@octave.org> parents: 26660 diff changeset	57 m_arg_nm (), m_dyn_field (), m_word_list_cmd (false)
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	58 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	59 append (lst, t);
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	60 }
4131 597fbc55ea40 [project @ 2002-10-29 17:12:53 by jwe] jwe parents: 4066 diff changeset	61
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	62 tree_index_expression::tree_index_expression (tree_expression *e,
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	63 const std::string& n,
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	64 int l, int c)
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	65 : tree_expression (l, c), m_expr (e), m_args (0), m_type (),
26662 05fc703b419a update handling of command-style function call syntax in eval John W. Eaton <jwe@octave.org> parents: 26660 diff changeset	66 m_arg_nm (), m_dyn_field (), m_word_list_cmd (false)
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	67 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	68 append (n);
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	69 }
3930 61d4427c016e [project @ 2002-05-07 00:47:31 by jwe] jwe parents: 3929 diff changeset	70
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	71 tree_index_expression::tree_index_expression (tree_expression *e,
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	72 tree_expression *df,
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	73 int l, int c)
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	74 : tree_expression (l, c), m_expr (e), m_args (0), m_type (),
26662 05fc703b419a update handling of command-style function call syntax in eval John W. Eaton <jwe@octave.org> parents: 26660 diff changeset	75 m_arg_nm (), m_dyn_field (), m_word_list_cmd (false)
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	76 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	77 append (df);
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	78 }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	79
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	80 void
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	81 tree_index_expression::append (tree_argument_list *lst, char t)
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	82 {
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	83 m_args.push_back (lst);
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	84 m_type.append (1, t);
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	85 m_arg_nm.push_back (lst ? lst->get_arg_names () : string_vector ());
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	86 m_dyn_field.push_back (static_cast<tree_expression *> (nullptr));
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	87
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	88 if (lst && lst->has_magic_tilde ())
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	89 error ("invalid use of empty argument (~) in index expression");
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	90 }
13970 c93b953f7d54 plug some memory leaks John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	91
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	92 void
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	93 tree_index_expression::append (const std::string& n)
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	94 {
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	95 m_args.push_back (static_cast<tree_argument_list *> (nullptr));
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	96 m_type += '.';
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	97 m_arg_nm.push_back (n);
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	98 m_dyn_field.push_back (static_cast<tree_expression *> (nullptr));
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	99 }
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	100
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	101 void
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	102 tree_index_expression::append (tree_expression *df)
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	103 {
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	104 m_args.push_back (static_cast<tree_argument_list *> (nullptr));
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	105 m_type += '.';
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	106 m_arg_nm.push_back ("");
7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	107 m_dyn_field.push_back (df);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	108 }
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	109
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	110 tree_index_expression::~tree_index_expression (void)
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	111 {
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	112 delete m_expr;
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	113
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	114 while (! m_args.empty ())
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	115 {
25337 3ff9192b676e use auto keyword to declare iterator variables where possible John W. Eaton <jwe@octave.org> parents: 25336 diff changeset	116 auto p = m_args.begin ();
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	117 delete *p;
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	118 m_args.erase (p);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	119 }
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	120
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	121 while (! m_dyn_field.empty ())
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	122 {
25337 3ff9192b676e use auto keyword to declare iterator variables where possible John W. Eaton <jwe@octave.org> parents: 25336 diff changeset	123 auto p = m_dyn_field.begin ();
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	124 delete *p;
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	125 m_dyn_field.erase (p);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	126 }
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	127 }
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4675 diff changeset	128
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	129 // This is useful for printing the name of the variable in an indexed
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	130 // assignment.
2991 fc751d2a99fd [project @ 1997-05-16 21:00:48 by jwe] jwe parents: 2984 diff changeset	131
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	132 std::string
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	133 tree_index_expression::name (void) const
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	134 {
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	135 return m_expr->name ();
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	136 }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	137
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	138 std::string
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	139 tree_index_expression::get_struct_index
25383 d3a035528c9a use reference to tree_evaluator instead of pointer John W. Eaton <jwe@octave.org> parents: 25382 diff changeset	140 (tree_evaluator& tw,
23435 c452180ab672 begin refactoring parse tree evaluator John W. Eaton <jwe@octave.org> parents: 23396 diff changeset	141 std::list<string_vector>::const_iterator p_arg_nm,
4219 23d06c9e1edd [project @ 2002-12-06 21:29:17 by jwe] jwe parents: 4192 diff changeset	142 std::list<tree_expression *>::const_iterator p_dyn_field) const
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	143 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	144 std::string fn = (*p_arg_nm)(0);
4131 597fbc55ea40 [project @ 2002-10-29 17:12:53 by jwe] jwe parents: 4066 diff changeset	145
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	146 if (fn.empty ())
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	147 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	148 tree_expression df = p_dyn_field;
4131 597fbc55ea40 [project @ 2002-10-29 17:12:53 by jwe] jwe parents: 4066 diff changeset	149
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	150 if (df)
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	151 {
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	152 octave_value t = df->evaluate (tw);
4131 597fbc55ea40 [project @ 2002-10-29 17:12:53 by jwe] jwe parents: 4066 diff changeset	153
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	154 fn = t.xstring_value ("dynamic structure field names must be strings");
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	155 }
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	156 else
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	157 panic_impossible ();
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	158 }
4131 597fbc55ea40 [project @ 2002-10-29 17:12:53 by jwe] jwe parents: 4066 diff changeset	159
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	160 return fn;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	161 }
10832 1b2fcd122c6a allow user detect ignored outputs in m-functions Jaroslav Hajek <highegg@gmail.com> parents: 10659 diff changeset	162
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	163 octave_lvalue
25383 d3a035528c9a use reference to tree_evaluator instead of pointer John W. Eaton <jwe@octave.org> parents: 25382 diff changeset	164 tree_index_expression::lvalue (tree_evaluator& tw)
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	165 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	166 std::list<octave_value_list> idx;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	167
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	168 int n = m_args.size ();
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	169
25337 3ff9192b676e use auto keyword to declare iterator variables where possible John W. Eaton <jwe@octave.org> parents: 25336 diff changeset	170 auto p_args = m_args.begin ();
3ff9192b676e use auto keyword to declare iterator variables where possible John W. Eaton <jwe@octave.org> parents: 25336 diff changeset	171 auto p_arg_nm = m_arg_nm.begin ();
3ff9192b676e use auto keyword to declare iterator variables where possible John W. Eaton <jwe@octave.org> parents: 25336 diff changeset	172 auto p_dyn_field = m_dyn_field.begin ();
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	173
26660 e4909f142491 * pt-idx.cc (tree_index_expression::lvalue): Style fix. John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	174 octave_lvalue retval = m_expr->lvalue (tw);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	175
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	176 unwind_action
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	177 act ([&tw] (const octave_value& val,
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	178 const std::string& index_type,
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	179 const std::list<octave_value_list>& index_list)
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	180 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	181 tw.set_indexed_object (val);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	182 tw.set_index_list (index_type, index_list);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	183 }, tw.indexed_object (), tw.index_type (), tw.index_list ());
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	184
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	185 tw.set_indexed_object (retval.value ());
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	186 tw.clear_index_list ();
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	187
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	188 for (int i = 0; i < n; i++)
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	189 {
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	190 switch (m_type[i])
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	191 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	192 case '(':
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10206 diff changeset	193 {
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	194 octave_value_list tidx = tw.make_value_list (p_args, p_arg_nm);
5846 db0598f94c0f [project @ 2006-06-07 18:16:16 by jwe] jwe parents: 5775 diff changeset	195
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	196 tw.append_index_list ('(', tidx);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	197 idx.push_back (tidx);
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10206 diff changeset	198 }
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	199 break;
3930 61d4427c016e [project @ 2002-05-07 00:47:31 by jwe] jwe parents: 3929 diff changeset	200
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	201 case '{':
20558 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	202 {
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	203 octave_value_list tidx = tw.make_value_list (p_args, p_arg_nm);
20558 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	204
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	205 tw.append_index_list ('{', tidx);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	206 idx.push_back (tidx);
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	207 }
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	208 break;
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	209
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	210 case '.':
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	211 {
23435 c452180ab672 begin refactoring parse tree evaluator John W. Eaton <jwe@octave.org> parents: 23396 diff changeset	212 octave_value tidx = get_struct_index (tw, p_arg_nm, p_dyn_field);
20558 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	213
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	214 tw.append_index_list ('.', tidx);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	215 idx.push_back (tidx);
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	216 }
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	217 break;
20558 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	218
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	219 default:
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	220 panic_impossible ();
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	221 }
20558 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	222
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	223 if (idx.back ().empty ())
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	224 error ("invalid empty index list");
5846 db0598f94c0f [project @ 2006-06-07 18:16:16 by jwe] jwe parents: 5775 diff changeset	225
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	226 p_args++;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	227 p_arg_nm++;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	228 p_dyn_field++;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	229 }
20558 1a0a433c8263 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	230
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	231 retval.set_index (m_type, idx);
8546 3d8a914c580e improve parser indexed assigment code Jaroslav Hajek <highegg@gmail.com> parents: 8011 diff changeset	232
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	233 return retval;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	234 }
4234 90e44267e8cf [project @ 2002-12-21 17:15:25 by jwe] jwe parents: 4233 diff changeset	235
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	236 tree_index_expression *
24270 bc3819b7cca1 don't use symbol_table:: nesting for symbol_record, symbol_scope, or fcn_info John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	237 tree_index_expression::dup (symbol_scope& scope) const
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	238 {
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	239 tree_index_expression *new_idx_expr
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	240 = new tree_index_expression (line (), column ());
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21100 diff changeset	241
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	242 new_idx_expr->m_expr = (m_expr ? m_expr->dup (scope) : nullptr);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	243
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	244 std::list<tree_argument_list *> new_args;
5846 db0598f94c0f [project @ 2006-06-07 18:16:16 by jwe] jwe parents: 5775 diff changeset	245
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	246 for (const tree_argument_list *elt : m_args)
23795 980f39c3ab90 Use C++11 nullptr rather than 0 in code (bug #51565). Rik <rik@octave.org> parents: 23696 diff changeset	247 new_args.push_back (elt ? elt->dup (scope) : nullptr);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	248
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	249 new_idx_expr->m_args = new_args;
3930 61d4427c016e [project @ 2002-05-07 00:47:31 by jwe] jwe parents: 3929 diff changeset	250
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	251 new_idx_expr->m_type = m_type;
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	252
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	253 new_idx_expr->m_arg_nm = m_arg_nm;
7099 70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	254
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	255 std::list<tree_expression *> new_dyn_field;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	256
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	257 for (const tree_expression *elt : m_dyn_field)
23795 980f39c3ab90 Use C++11 nullptr rather than 0 in code (bug #51565). Rik <rik@octave.org> parents: 23696 diff changeset	258 new_dyn_field.push_back (elt ? elt->dup (scope) : nullptr);
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	259
24846 7620f1f5290d use m_ prefix for member variables in parse tree classes John W. Eaton <jwe@octave.org> parents: 24722 diff changeset	260 new_idx_expr->m_dyn_field = new_dyn_field;
8546 3d8a914c580e improve parser indexed assigment code Jaroslav Hajek <highegg@gmail.com> parents: 8011 diff changeset	261
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	262 new_idx_expr->copy_base (*this);
4234 90e44267e8cf [project @ 2002-12-21 17:15:25 by jwe] jwe parents: 4233 diff changeset	263
23075 4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	264 return new_idx_expr;
4e3d47dc7e25 move parse tree classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 23071 diff changeset	265 }
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	266
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	267 // Unlike Matlab, which does not allow the result of a function call
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	268 // or array indexing expression to be further indexed, Octave attempts
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	269 // to handle arbitrary index expressions. For example, Octave allows
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	270 // expressions like
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	271 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	272 // svd (rand (10))(1:5)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	273 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	274 // Although octave_value objects may contain function objects, no
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	275 // indexing operation or function call is supposed to return them
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	276 // directly. Instead, the language is supposed to only allow function
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	277 // objects to be stored as function handles (named or anonymous) or as
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	278 // inline functions. The only place a function object should appear
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	279 // directly is if the symbol stored in a tree_identifier object
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	280 // resolves to a function. This means that the only place we need to
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	281 // look for functions is in the first element of the index
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	282 // expression.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	283 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	284 // Steps:
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	285 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	286 // * Obtain the initial value from the expression component of the
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	287 // tree_index_expression object. If it is a tree_identifier object
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	288 // indexed by '(args)' and the identifier is not a variable, then
27971 ec769a7ab9fb fix more spelling errors (bug #57613) John W. Eaton <jwe@octave.org> parents: 27932 diff changeset	289 // perform a function call. Use the (optional) arguments to perform
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	290 // the function lookup so we choose the correct function or class
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	291 // method to call. Otherwise, evaluate the first expression
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	292 // without any additional arguments.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	293 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	294 // * Iterate over the remaining elements of the index expression and
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	295 // call the octave_value::subsref method. If indexing a class or
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	296 // classdef object, build up a list of indices for a call to the
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	297 // subsref method for the object. Otherwise, use the result of
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	298 // each temporary evaluation for the next index element.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	299 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	300 // * If not indexing a class or classdef object and any partial
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	301 // expression evaluation produces a class or classdef object, then
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	302 // build up a complete argument list from that point on for a final
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	303 // subsref call for that object.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	304 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	305 // Multiple partial evaluations may be required. For example,
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	306 // given a class or classdef object X, then for the expression
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	307 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	308 // x.a{end}(2:end).b
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	309 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	310 // we must evaluate x.a to obtain the size for the first {end}
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	311 // expression, then we must evaluate x.a{end} to obtain the size
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	312 // for the second (2:end) expression. Finally, the complete
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	313 // expression may be evaluated.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	314 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	315 // If X is a cell array in the above expression, and none of the
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	316 // intermediate evaluations produces a class or classdef object,
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	317 // then the evaluation is performed as the following series of
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	318 // steps
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	319 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	320 // tmp = x.a
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	321 // tmp = tmp{end}
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	322 // tmp = tmp(2:end)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	323 // result = tmp.b
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	324 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	325 // If any of the partial evaluations produces a class or classdef
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	326 // object, then the subsref method for that object is called as
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	327 // described above. For example, suppose x.a produces a classdef
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	328 // object. Then the evaluation is performed as the following
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	329 // series of steps
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	330 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	331 // base_expr = tmp = x.a
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	332 // tmp = base_expr{end}
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	333 // base_expr{end}(2:end).b
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	334 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	335 // In the last two steps, the partial value computed in the
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	336 // previous step is used to determine the value of END.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	337
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	338 octave_value_list
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	339 tree_index_expression::evaluate_n (tree_evaluator& tw, int nargout)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	340 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	341 octave_value_list retval;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	342
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	343 assert (! m_args.empty ());
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	344
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	345 auto p_args = m_args.begin ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	346 auto p_arg_nm = m_arg_nm.begin ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	347 auto p_dyn_field = m_dyn_field.begin ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	348
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	349 int n = m_args.size ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	350 int beg = 0;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	351
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	352 octave_value base_expr_val;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	353
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	354 if (m_expr->is_identifier () && m_type[beg] == '(')
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	355 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	356 tree_identifier id = dynamic_cast<tree_identifier > (m_expr);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	357
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	358 bool is_var = tw.is_variable (m_expr);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	359
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	360 std::string nm = id->name ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	361
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	362 if (is_var && is_word_list_cmd ())
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	363 error ("%s used as variable and later as function", nm.c_str ());
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	364
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	365 if (! is_var)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	366 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	367 octave_value_list first_args;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	368
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	369 tree_argument_list al = p_args;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	370
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	371 if (al && al->length () > 0)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	372 {
27373 25627c524ad8 where possible, use new unwind-protect classes in evaluator John W. Eaton <jwe@octave.org> parents: 27371 diff changeset	373 unwind_action act ([&tw] (const std::list<octave_lvalue> *lvl)
25627c524ad8 where possible, use new unwind-protect classes in evaluator John W. Eaton <jwe@octave.org> parents: 27371 diff changeset	374 {
25627c524ad8 where possible, use new unwind-protect classes in evaluator John W. Eaton <jwe@octave.org> parents: 27371 diff changeset	375 tw.set_lvalue_list (lvl);
25627c524ad8 where possible, use new unwind-protect classes in evaluator John W. Eaton <jwe@octave.org> parents: 27371 diff changeset	376 }, tw.lvalue_list ());
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	377
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	378 tw.set_lvalue_list (nullptr);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	379
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	380 string_vector anm = *p_arg_nm;
28618 af302efce502 avoid some unnecessary work when evaluating index expressions John W. Eaton <jwe@octave.org> parents: 28552 diff changeset	381
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	382 first_args = tw.convert_to_const_vector (al);
28618 af302efce502 avoid some unnecessary work when evaluating index expressions John W. Eaton <jwe@octave.org> parents: 28552 diff changeset	383
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	384 first_args.stash_name_tags (anm);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	385 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	386
28618 af302efce502 avoid some unnecessary work when evaluating index expressions John W. Eaton <jwe@octave.org> parents: 28552 diff changeset	387 interpreter& interp = tw.get_interpreter ();
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	388
28618 af302efce502 avoid some unnecessary work when evaluating index expressions John W. Eaton <jwe@octave.org> parents: 28552 diff changeset	389 symbol_table& symtab = interp.get_symbol_table ();
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	390
28618 af302efce502 avoid some unnecessary work when evaluating index expressions John W. Eaton <jwe@octave.org> parents: 28552 diff changeset	391 octave_value val = symtab.find_function (nm, first_args);
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	392
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	393 octave_function *fcn = nullptr;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	394
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	395 if (val.is_function ())
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	396 fcn = val.function_value (true);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	397
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	398 if (fcn)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	399 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	400 try
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	401 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	402 retval = fcn->call (tw, nargout, first_args);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	403 }
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	404 catch (index_exception& ie)
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	405 {
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	406 tw.final_index_error (ie, m_expr);
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	407 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	408
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	409 beg++;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	410 p_args++;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	411 p_arg_nm++;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	412 p_dyn_field++;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	413
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	414 if (n > beg)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	415 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	416 // More indices to follow. Silently ignore
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	417 // extra output values.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	418
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	419 if (retval.length () == 0)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	420 error ("indexing undefined value");
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	421 else
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	422 base_expr_val = retval(0);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	423 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	424 else
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	425 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	426 // No more indices, so we are done.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	427
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	428 // See note at end of function about deleting
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	429 // temporaries prior to pushing result.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	430
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	431 base_expr_val = octave_value ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	432 first_args = octave_value_list ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	433
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	434 return retval;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	435 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	436 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	437 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	438 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	439
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	440 if (base_expr_val.is_undefined ())
27374 d171d356767b don't apply std::move to temporary values John W. Eaton <jwe@octave.org> parents: 27373 diff changeset	441 base_expr_val = m_expr->evaluate (tw);
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	442
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	443 // If we are indexing an object or looking at something like
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	444 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	445 // classname.static_function (args, ...);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	446 //
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	447 // then we'll just build a complete index list for one big subsref
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	448 // call. If the expression we are indexing is a classname then
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	449 // base_expr_val will be an octave_classdef_meta object. If we have
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	450 // files in a +packagename folder, they will also be an
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	451 // octave_classdef_meta object, but we don't want to index them.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	452
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	453 std::list<octave_value_list> idx_list;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	454
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	455 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	456 // Note: need new scope so that the following unwind action will
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	457 // happen before we perform the final indexing for objects (for
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	458 // example).
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	459
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	460 unwind_action
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	461 act ([&tw] (const octave_value& val,
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	462 const std::string& index_type,
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	463 const std::list<octave_value_list>& index_list)
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	464 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	465 tw.set_indexed_object (val);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	466 tw.set_index_list (index_type, index_list);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	467 },
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	468 tw.indexed_object (),
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	469 tw.index_type (), tw.index_list ());
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	470
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	471 tw.set_indexed_object ();
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	472 tw.clear_index_list ();
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	473
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	474 bool indexing_object = (base_expr_val.isobject ()
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	475 \|\| base_expr_val.isjava ()
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	476 \|\| (base_expr_val.is_classdef_meta ()
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	477 && ! base_expr_val.is_package ()));
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	478
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	479 octave_value partial_expr_val = base_expr_val;
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	480
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	481 for (int i = beg; i < n; i++)
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	482 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	483 if (i > beg)
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	484 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	485 if (! indexing_object)
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	486 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	487 // Evaluate what we have so far.
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	488
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	489 try
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	490 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	491 // Silently ignore extra output values.
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	492
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	493 octave_value_list tmp_list
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	494 = base_expr_val.subsref (m_type.substr (beg, i-beg),
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	495 idx_list, nargout);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	496
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	497 partial_expr_val
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	498 = tmp_list.length () ? tmp_list(0) : octave_value ();
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	499
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	500 base_expr_val = partial_expr_val;
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	501
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	502 if (partial_expr_val.is_cs_list ())
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	503 err_indexed_cs_list ();
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	504
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	505 retval = partial_expr_val;
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	506
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	507 beg = i;
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	508 idx_list.clear ();
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	509 tw.clear_index_list ();
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	510
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	511 if (partial_expr_val.isobject ()
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	512 \|\| partial_expr_val.isjava ()
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	513 \|\| (partial_expr_val.is_classdef_meta ()
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	514 && ! partial_expr_val.is_package ()))
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	515 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	516 // Found an object, so now we'll build up
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	517 // complete index list for one big subsref
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	518 // call from this point on.
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	519
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	520 // FIXME: is is also possible to have a
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	521 // static method call buried somewhere in
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	522 // the depths of a complex indexing
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	523 // expression so that we would also need to
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	524 // check for an octave_classdef_meta object
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	525 // here?
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	526
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	527 indexing_object = true;
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	528 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	529 }
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	530 catch (index_exception& ie)
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	531 {
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	532 tw.final_index_error (ie, m_expr);
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	533 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	534 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	535 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	536
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	537 tw.set_indexed_object (partial_expr_val);
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	538
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	539 switch (m_type[i])
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	540 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	541 case '(':
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	542 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	543 octave_value_list tmp = tw.make_value_list (p_args, p_arg_nm);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	544 tw.append_index_list ('(', tmp);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	545 idx_list.push_back (tmp);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	546 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	547 break;
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	548
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	549 case '{':
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	550 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	551 octave_value_list tmp = tw.make_value_list (p_args, p_arg_nm);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	552 tw.append_index_list ('{', tmp);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	553 idx_list.push_back (tmp);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	554 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	555 break;
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	556
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	557 case '.':
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	558 {
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	559 octave_value tmp = get_struct_index (tw, p_arg_nm, p_dyn_field);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	560 tw.append_index_list ('.', tmp);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	561 idx_list.push_back (tmp);
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	562 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	563 break;
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	564
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	565 default:
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	566 panic_impossible ();
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	567 }
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	568
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	569 p_args++;
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	570 p_arg_nm++;
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	571 p_dyn_field++;
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	572 }
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	573 }
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	574
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	575 // If ! idx_list.empty () that means we still have stuff to index
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	576 // otherwise they would have been dealt with and idx_list would have
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	577 // been emptied.
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	578 if (! idx_list.empty ())
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	579 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	580 // This is for +package and other classdef_meta objects
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	581 if (! base_expr_val.is_function ()
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	582 \|\| base_expr_val.is_classdef_meta ())
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	583 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	584 try
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	585 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	586 retval = base_expr_val.subsref (m_type.substr (beg, n-beg),
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	587 idx_list, nargout);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	588 beg = n;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	589 idx_list.clear ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	590 }
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	591 catch (index_exception& ie)
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	592 {
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	593 tw.final_index_error (ie, m_expr);
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	594 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	595 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	596 else
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	597 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	598 // FIXME: we want this to only be a superclass constructor
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	599 // call Should we actually make a check for this or are all
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	600 // other types of calls already dealt with?
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	601
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	602 octave_function *fcn = base_expr_val.function_value ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	603
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	604 if (fcn)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	605 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	606 try
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	607 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	608 // FIXME: is it possible for the IDX_LIST to have
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	609 // more than one element here? Do we need to check?
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	610
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	611 octave_value_list final_args;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	612
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	613 if (idx_list.size () != 1)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	614 error ("unexpected extra index at end of expression");
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	615
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	616 if (m_type[beg] != '(')
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	617 error ("invalid index type '%c' for function call",
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	618 m_type[beg]);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	619
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	620 final_args = idx_list.front ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	621
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	622 // FIXME: Do we ever need the names of the arguments
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	623 // passed to FCN here?
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	624
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	625 retval = fcn->call (tw, nargout, final_args);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	626 }
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	627 catch (index_exception& ie)
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	628 {
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28805 diff changeset	629 tw.final_index_error (ie, m_expr);
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	630 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	631 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	632 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	633 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	634
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	635 // FIXME: when can the following happen? In what case does indexing
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	636 // result in a value that is a function? Classdef method calls?
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	637 // Something else?
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	638
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	639 octave_value val = (retval.length () ? retval(0) : octave_value ());
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	640
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	641 if (val.is_function ())
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	642 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	643 octave_function *fcn = val.function_value (true);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	644
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	645 if (fcn)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	646 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	647 octave_value_list final_args;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	648
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	649 if (! idx_list.empty ())
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	650 {
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	651 if (n - beg != 1)
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	652 error ("unexpected extra index at end of expression");
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	653
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	654 if (m_type[beg] != '(')
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	655 error ("invalid index type '%c' for function call",
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	656 m_type[beg]);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	657
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	658 final_args = idx_list.front ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	659 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	660
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	661 retval = fcn->call (tw, nargout, final_args);
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	662 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	663 }
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	664
28804 3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	665 // Delete any temporary values prior to returning so that
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	666 // destructors for any temporary classdef handle objects will be
3719f5d452d4 refactor implementation of END indexing in interpreter (bug #58953) John W. Eaton <jwe@octave.org> and Fernando Alvarruiz parents: 28726 diff changeset	667 // called before we return.
27371 fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	668
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	669 idx_list.clear ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	670 base_expr_val = octave_value ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	671 val = octave_value ();
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	672
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	673 return retval;
fcaecdbc8d8a don't use visitor pattern for expression evaluation (bug #56752) John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	674 }
2980 cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	675 }
cd5ad3fd8049 [project @ 1997-05-16 01:12:13 by jwe] jwe parents: diff changeset	676
7099 70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	677 /*
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	678 %!test
14429 eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14343 diff changeset	679 %! clear x;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14343 diff changeset	680 %! clear y;
14343 acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	681 %! y = 3;
acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	682 %! x(y(end)) = 1;
acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	683 %! assert (x, [0, 0, 1]);
14429 eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14343 diff changeset	684 %! clear x;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14343 diff changeset	685 %! clear y;
14343 acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	686 %! y = {3};
acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	687 %! x(y{end}) = 1;
acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	688 %! assert (x, [0, 0, 1]);
acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	689
acc26b860afa fix indexed assignment bug (bug #35482) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	690 %!test
7099 70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	691 %! x = {1, 2, 3};
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	692 %! [x{:}] = deal (4, 5, 6);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	693 %! assert (x, {4, 5, 6});
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	694
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	695 %!test
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	696 %! [x.a, x.b.c] = deal (1, 2);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	697 %! assert (x.a == 1 && x.b.c == 2);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	698
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	699 %!test
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	700 %! [x.a, x(2).b] = deal (1, 2);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	701 %! assert (x(1).a == 1 && isempty (x(2).a) && isempty (x(1).b) && x(2).b == 2);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	702
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	703 %!test
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	704 %! x = struct (zeros (0, 1), {"a", "b"});
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	705 %! x(2).b = 1;
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	706 %! assert (x(2).b == 1);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	707
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	708 %!test
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	709 %! x = struct (zeros (0, 1), {"a", "b"});
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	710 %! x(2).b = 1;
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	711 %! assert (x(2).b == 1);
70f30a92b725 [project @ 2007-11-05 21:51:24 by jwe] jwe parents: 7057 diff changeset	712 */

Mercurial > octave

annotate libinterp/parse-tree/pt-idx.cc @ 29163:8f67ad8b3103