Mercurial > octave-nkf
annotate src/pt-idx.cc @ 10206:37a08e0ce2dc
support Matlab-style empty output/input arguments
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Wed, 27 Jan 2010 12:41:49 +0100 |
| parents | cd96d29c5efa |
| children | 57a59eae83cc |
| rev | line source |
|---|---|
| 2980 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2006, |
| 8920 | 4 2007, 2008, 2009 John W. Eaton |
| 2980 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 2980 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 2980 | 21 |
| 22 */ | |
| 23 | |
| 24 #ifdef HAVE_CONFIG_H | |
| 25 #include <config.h> | |
| 26 #endif | |
| 27 | |
| 3933 | 28 #include "Cell.h" |
| 2980 | 29 #include "error.h" |
| 3930 | 30 #include "oct-map.h" |
| 2980 | 31 #include "oct-obj.h" |
| 32 #include "oct-lvalue.h" | |
| 33 #include "ov.h" | |
| 3930 | 34 #include "pager.h" |
| 2982 | 35 #include "pt-arg-list.h" |
| 3930 | 36 #include "pt-bp.h" |
| 7336 | 37 #include "pt-id.h" |
| 2980 | 38 #include "pt-idx.h" |
| 39 #include "pt-walk.h" | |
| 3930 | 40 #include "utils.h" |
| 41 #include "variables.h" | |
|
8579
7e0f36dfefbe
implement octave_value_list using Array
Jaroslav Hajek <highegg@gmail.com>
parents:
8564
diff
changeset
|
42 #include "gripes.h" |
| 2980 | 43 |
| 44 // Index expressions. | |
| 45 | |
| 5861 | 46 tree_index_expression::tree_index_expression (int l, int c) |
|
7791
975e9540be2c
pt-idx.cc: initialize fields in constructors
John W. Eaton <jwe@octave.org>
parents:
7790
diff
changeset
|
47 : tree_expression (l, c), expr (0), args (0), type (), |
| 5861 | 48 arg_nm (), dyn_field () { } |
| 49 | |
| 3546 | 50 tree_index_expression::tree_index_expression (tree_expression *e, |
| 51 tree_argument_list *lst, | |
| 3933 | 52 int l, int c, char t) |
|
7791
975e9540be2c
pt-idx.cc: initialize fields in constructors
John W. Eaton <jwe@octave.org>
parents:
7790
diff
changeset
|
53 : tree_expression (l, c), expr (e), args (0), type (), |
| 4131 | 54 arg_nm (), dyn_field () |
| 3933 | 55 { |
| 56 append (lst, t); | |
| 57 } | |
| 3215 | 58 |
| 3930 | 59 tree_index_expression::tree_index_expression (tree_expression *e, |
| 60 const std::string& n, | |
| 3944 | 61 int l, int c) |
|
7791
975e9540be2c
pt-idx.cc: initialize fields in constructors
John W. Eaton <jwe@octave.org>
parents:
7790
diff
changeset
|
62 : tree_expression (l, c), expr (e), args (0), type (), |
| 4131 | 63 arg_nm (), dyn_field () |
| 3933 | 64 { |
| 65 append (n); | |
| 66 } | |
| 67 | |
| 4131 | 68 tree_index_expression::tree_index_expression (tree_expression *e, |
| 69 tree_expression *df, | |
| 70 int l, int c) | |
|
7791
975e9540be2c
pt-idx.cc: initialize fields in constructors
John W. Eaton <jwe@octave.org>
parents:
7790
diff
changeset
|
71 : tree_expression (l, c), expr (e), args (0), type (), |
| 4131 | 72 arg_nm (), dyn_field () |
| 73 { | |
| 74 append (df); | |
| 75 } | |
| 76 | |
| 3933 | 77 void |
| 78 tree_index_expression::append (tree_argument_list *lst, char t) | |
| 79 { | |
| 4219 | 80 args.push_back (lst); |
| 3933 | 81 type.append (1, t); |
| 4219 | 82 arg_nm.push_back (lst ? lst->get_arg_names () : string_vector ()); |
| 83 dyn_field.push_back (static_cast<tree_expression *> (0)); | |
|
10206
37a08e0ce2dc
support Matlab-style empty output/input arguments
Jaroslav Hajek <highegg@gmail.com>
parents:
10160
diff
changeset
|
84 |
|
37a08e0ce2dc
support Matlab-style empty output/input arguments
Jaroslav Hajek <highegg@gmail.com>
parents:
10160
diff
changeset
|
85 if (lst && lst->has_magic_tilde ()) |
|
37a08e0ce2dc
support Matlab-style empty output/input arguments
Jaroslav Hajek <highegg@gmail.com>
parents:
10160
diff
changeset
|
86 error ("invalid use of empty argument (~) in index expression"); |
| 3933 | 87 } |
| 88 | |
| 89 void | |
| 90 tree_index_expression::append (const std::string& n) | |
| 91 { | |
| 4219 | 92 args.push_back (static_cast<tree_argument_list *> (0)); |
| 3933 | 93 type.append ("."); |
| 4219 | 94 arg_nm.push_back (n); |
| 95 dyn_field.push_back (static_cast<tree_expression *> (0)); | |
| 4131 | 96 } |
| 97 | |
| 98 void | |
| 99 tree_index_expression::append (tree_expression *df) | |
| 100 { | |
| 4219 | 101 args.push_back (static_cast<tree_argument_list *> (0)); |
| 4131 | 102 type.append ("."); |
| 4219 | 103 arg_nm.push_back (""); |
| 104 dyn_field.push_back (df); | |
| 3933 | 105 } |
| 3930 | 106 |
| 2980 | 107 tree_index_expression::~tree_index_expression (void) |
| 108 { | |
| 109 delete expr; | |
| 3933 | 110 |
| 111 while (! args.empty ()) | |
| 112 { | |
| 4219 | 113 std::list<tree_argument_list *>::iterator p = args.begin (); |
| 114 delete *p; | |
| 115 args.erase (p); | |
| 3933 | 116 } |
| 2980 | 117 } |
| 118 | |
| 5099 | 119 bool |
| 120 tree_index_expression::has_magic_end (void) const | |
| 121 { | |
| 122 for (std::list<tree_argument_list *>::const_iterator p = args.begin (); | |
| 123 p != args.end (); | |
| 124 p++) | |
| 125 { | |
| 126 tree_argument_list *elt = *p; | |
| 127 | |
| 128 if (elt && elt->has_magic_end ()) | |
| 129 return true; | |
| 130 } | |
| 131 | |
| 132 return false; | |
| 133 } | |
| 134 | |
| 2991 | 135 // This is useful for printing the name of the variable in an indexed |
| 136 // assignment. | |
| 137 | |
| 3536 | 138 std::string |
| 2991 | 139 tree_index_expression::name (void) const |
| 140 { | |
| 4131 | 141 return expr->name (); |
| 3933 | 142 } |
| 143 | |
| 144 static Cell | |
| 145 make_subs_cell (tree_argument_list *args, const string_vector& arg_nm) | |
| 146 { | |
| 147 Cell retval; | |
| 148 | |
| 149 octave_value_list arg_values; | |
| 150 | |
| 151 if (args) | |
| 152 arg_values = args->convert_to_const_vector (); | |
| 153 | |
| 154 if (! error_state) | |
| 155 { | |
| 156 int n = arg_values.length (); | |
| 157 | |
| 158 if (n > 0) | |
| 159 { | |
| 160 arg_values.stash_name_tags (arg_nm); | |
| 161 | |
| 4548 | 162 retval.resize (dim_vector (1, n)); |
| 3933 | 163 |
| 164 for (int i = 0; i < n; i++) | |
| 165 retval(0,i) = arg_values(i); | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 return retval; | |
| 170 } | |
| 171 | |
| 172 static inline octave_value_list | |
| 4234 | 173 make_value_list (tree_argument_list *args, const string_vector& arg_nm, |
| 174 const octave_value *object) | |
| 3933 | 175 { |
| 176 octave_value_list retval; | |
| 177 | |
| 178 if (args) | |
|
9125
8ab1e6f63cdc
gripe on magic end query for undefined variable
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
179 { |
|
8ab1e6f63cdc
gripe on magic end query for undefined variable
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
180 if (object && args->has_magic_end () && object->is_undefined ()) |
|
8ab1e6f63cdc
gripe on magic end query for undefined variable
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
181 gripe_invalid_inquiry_subscript (); |
|
8ab1e6f63cdc
gripe on magic end query for undefined variable
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
182 else |
|
8ab1e6f63cdc
gripe on magic end query for undefined variable
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
183 retval = args->convert_to_const_vector (object); |
|
8ab1e6f63cdc
gripe on magic end query for undefined variable
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
184 } |
| 3933 | 185 |
| 186 if (! error_state) | |
| 187 { | |
| 188 int n = retval.length (); | |
| 189 | |
| 190 if (n > 0) | |
| 191 retval.stash_name_tags (arg_nm); | |
| 192 } | |
| 193 | |
| 194 return retval; | |
| 195 } | |
| 196 | |
| 4131 | 197 std::string |
| 4219 | 198 tree_index_expression::get_struct_index |
| 199 (std::list<string_vector>::const_iterator p_arg_nm, | |
| 200 std::list<tree_expression *>::const_iterator p_dyn_field) const | |
| 4131 | 201 { |
| 4219 | 202 std::string fn = (*p_arg_nm)(0); |
| 4131 | 203 |
| 204 if (fn.empty ()) | |
| 205 { | |
| 4219 | 206 tree_expression *df = *p_dyn_field; |
| 4131 | 207 |
| 208 if (df) | |
| 209 { | |
|
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
8580
diff
changeset
|
210 octave_value t = df->rvalue1 (); |
| 4131 | 211 |
| 212 if (! error_state) | |
| 4143 | 213 { |
| 214 fn = t.string_value (); | |
| 215 | |
| 216 if (! valid_identifier (fn)) | |
| 6811 | 217 ::error ("invalid structure field name `%s'", fn.c_str ()); |
| 4143 | 218 } |
| 4131 | 219 } |
| 220 else | |
| 221 panic_impossible (); | |
| 222 } | |
| 223 | |
| 224 return fn; | |
| 225 } | |
| 226 | |
| 3933 | 227 Octave_map |
| 228 tree_index_expression::make_arg_struct (void) const | |
| 229 { | |
| 4219 | 230 int n = args.size (); |
| 3933 | 231 |
| 7336 | 232 Cell type_field (n, 1); |
| 233 Cell subs_field (n, 1); | |
| 3933 | 234 |
| 4219 | 235 std::list<tree_argument_list *>::const_iterator p_args = args.begin (); |
| 236 std::list<string_vector>::const_iterator p_arg_nm = arg_nm.begin (); | |
| 237 std::list<tree_expression *>::const_iterator p_dyn_field = dyn_field.begin (); | |
| 3933 | 238 |
| 239 Octave_map m; | |
| 240 | |
| 241 for (int i = 0; i < n; i++) | |
| 242 { | |
| 243 switch (type[i]) | |
| 244 { | |
| 245 case '(': | |
| 7336 | 246 subs_field(i) = make_subs_cell (*p_args, *p_arg_nm); |
| 3933 | 247 break; |
| 248 | |
| 249 case '{': | |
| 7336 | 250 subs_field(i) = make_subs_cell (*p_args, *p_arg_nm); |
| 3933 | 251 break; |
| 252 | |
| 253 case '.': | |
|
8011
3100283874d7
improve backtrace error messages
John W. Eaton <jwe@octave.org>
parents:
7791
diff
changeset
|
254 subs_field(i) = get_struct_index (p_arg_nm, p_dyn_field); |
| 3933 | 255 break; |
| 256 | |
| 257 default: | |
| 258 panic_impossible (); | |
| 259 } | |
| 260 | |
| 261 if (error_state) | |
| 262 return m; | |
| 263 | |
| 4219 | 264 p_args++; |
| 265 p_arg_nm++; | |
| 266 p_dyn_field++; | |
| 3933 | 267 } |
| 268 | |
| 7336 | 269 m.assign ("type", type_field); |
| 270 m.assign ("subs", subs_field); | |
| 3933 | 271 |
| 272 return m; | |
| 2991 | 273 } |
| 274 | |
| 2980 | 275 octave_value_list |
| 276 tree_index_expression::rvalue (int nargout) | |
| 277 { | |
| 278 octave_value_list retval; | |
| 279 | |
| 280 if (error_state) | |
| 281 return retval; | |
| 282 | |
| 7336 | 283 octave_value first_expr_val; |
| 284 | |
| 285 octave_value_list first_args; | |
| 286 | |
| 287 bool have_args = false; | |
| 288 | |
| 289 if (expr->is_identifier () && type[0] == '(') | |
| 290 { | |
| 291 tree_identifier *id = dynamic_cast<tree_identifier *> (expr); | |
| 292 | |
| 293 if (! (id->is_variable () || args.empty ())) | |
| 294 { | |
| 295 tree_argument_list *al = *(args.begin ()); | |
| 296 | |
| 297 size_t n = al ? al->length () : 0; | |
| 298 | |
| 299 if (n > 0) | |
| 300 { | |
| 301 string_vector anm = *(arg_nm.begin ()); | |
|
9445
c5f03874ea2a
simplify symbol_table::find and associated functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
302 have_args = true; |
|
c5f03874ea2a
simplify symbol_table::find and associated functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
303 first_args = al -> convert_to_const_vector (); |
|
c5f03874ea2a
simplify symbol_table::find and associated functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
304 first_args.stash_name_tags (anm); |
| 7336 | 305 |
|
9445
c5f03874ea2a
simplify symbol_table::find and associated functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
306 if (! error_state) |
|
c5f03874ea2a
simplify symbol_table::find and associated functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
307 first_expr_val = id->do_lookup (first_args); |
| 7336 | 308 } |
| 309 } | |
| 310 } | |
| 2980 | 311 |
| 312 if (! error_state) | |
| 313 { | |
| 7336 | 314 if (first_expr_val.is_undefined ()) |
|
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
8580
diff
changeset
|
315 first_expr_val = expr->rvalue1 (); |
| 7336 | 316 |
| 317 octave_value tmp = first_expr_val; | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
318 octave_idx_type tmpi = 0; |
| 7336 | 319 |
| 4219 | 320 std::list<octave_value_list> idx; |
| 3930 | 321 |
| 4219 | 322 int n = args.size (); |
| 3933 | 323 |
| 4219 | 324 std::list<tree_argument_list *>::iterator p_args = args.begin (); |
| 325 std::list<string_vector>::iterator p_arg_nm = arg_nm.begin (); | |
| 326 std::list<tree_expression *>::iterator p_dyn_field = dyn_field.begin (); | |
| 3930 | 327 |
| 3933 | 328 for (int i = 0; i < n; i++) |
| 329 { | |
| 4432 | 330 if (i > 0) |
| 331 { | |
| 332 tree_argument_list *al = *p_args; | |
| 333 | |
|
9692
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
334 // In Matlab, () can only be followed by . In Octave, we do not |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
335 // enforce this for rvalue expressions, but we'll split the |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
336 // evaluation at this point. This will, hopefully, allow Octave's |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
337 // looser rules apply smoothly for Matlab overloaded subsref |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
338 // codes. |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
339 bool force_split = type[i-1] == '(' && type[i] != '.'; |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
340 |
|
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
341 if (force_split || (al && al->has_magic_end ())) |
| 4432 | 342 { |
| 343 // We have an expression like | |
| 344 // | |
| 345 // x{end}.a(end) | |
| 346 // | |
| 347 // and we are looking at the argument list that | |
| 348 // contains the second (or third, etc.) "end" token, | |
| 349 // so we must evaluate everything up to the point of | |
| 7336 | 350 // that argument list so we can pass the appropriate |
| 4432 | 351 // value to the built-in __end__ function. |
| 352 | |
|
8580
188d38a553c7
further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents:
8579
diff
changeset
|
353 const octave_value_list tmp_list |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
354 = tmp.subsref (type.substr (tmpi, i - tmpi), idx, nargout); |
| 4432 | 355 |
|
9692
126b49caba0d
smart splitting of index chains
Jaroslav Hajek <highegg@gmail.com>
parents:
9445
diff
changeset
|
356 tmp = tmp_list.length () ? tmp_list(0) : octave_value (); |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
357 tmpi = i; |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
358 idx.clear (); |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
359 |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
360 if (tmp.is_cs_list ()) |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
361 gripe_indexed_cs_list (); |
| 4432 | 362 |
| 363 if (error_state) | |
| 364 break; | |
| 365 } | |
| 366 } | |
| 367 | |
| 3933 | 368 switch (type[i]) |
| 369 { | |
| 370 case '(': | |
| 7336 | 371 if (have_args) |
| 372 { | |
| 373 idx.push_back (first_args); | |
| 374 have_args = false; | |
| 375 } | |
| 376 else | |
| 377 idx.push_back (make_value_list (*p_args, *p_arg_nm, &tmp)); | |
| 3933 | 378 break; |
| 3930 | 379 |
| 3933 | 380 case '{': |
| 4234 | 381 idx.push_back (make_value_list (*p_args, *p_arg_nm, &tmp)); |
| 3933 | 382 break; |
| 2980 | 383 |
| 3933 | 384 case '.': |
|
8011
3100283874d7
improve backtrace error messages
John W. Eaton <jwe@octave.org>
parents:
7791
diff
changeset
|
385 idx.push_back (octave_value (get_struct_index (p_arg_nm, p_dyn_field))); |
| 3933 | 386 break; |
| 3930 | 387 |
| 3933 | 388 default: |
| 389 panic_impossible (); | |
| 390 } | |
| 3930 | 391 |
| 3933 | 392 if (error_state) |
| 393 break; | |
| 394 | |
| 4219 | 395 p_args++; |
| 396 p_arg_nm++; | |
| 397 p_dyn_field++; | |
| 2980 | 398 } |
| 3933 | 399 |
| 400 if (! error_state) | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
401 retval = tmp.subsref (type.substr (tmpi, n - tmpi), idx, nargout); |
| 2980 | 402 } |
| 403 | |
| 404 return retval; | |
| 405 } | |
| 406 | |
| 407 octave_value | |
|
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
8580
diff
changeset
|
408 tree_index_expression::rvalue1 (int nargout) |
| 2980 | 409 { |
| 410 octave_value retval; | |
| 411 | |
|
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
8580
diff
changeset
|
412 const octave_value_list tmp = rvalue (nargout); |
| 2980 | 413 |
| 414 if (! tmp.empty ()) | |
| 415 retval = tmp(0); | |
| 416 | |
| 417 return retval; | |
| 418 } | |
| 419 | |
| 420 octave_lvalue | |
| 421 tree_index_expression::lvalue (void) | |
| 422 { | |
| 423 octave_lvalue retval; | |
| 424 | |
| 4219 | 425 std::list<octave_value_list> idx; |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
426 std::string tmp_type; |
| 3933 | 427 |
| 4219 | 428 int n = args.size (); |
| 3933 | 429 |
| 4219 | 430 std::list<tree_argument_list *>::iterator p_args = args.begin (); |
| 431 std::list<string_vector>::iterator p_arg_nm = arg_nm.begin (); | |
| 432 std::list<tree_expression *>::iterator p_dyn_field = dyn_field.begin (); | |
| 3933 | 433 |
| 4234 | 434 retval = expr->lvalue (); |
| 3933 | 435 |
| 2980 | 436 if (! error_state) |
| 437 { | |
| 4432 | 438 const octave_value *tro = retval.object (); |
| 439 | |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
440 octave_value tmp; |
| 4432 | 441 |
| 442 if (tro) | |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
443 tmp = *tro; |
| 4432 | 444 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
445 octave_idx_type tmpi = 0; |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
446 std::list<octave_value_list> tmpidx; |
| 4234 | 447 |
| 448 for (int i = 0; i < n; i++) | |
| 449 { | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
450 if (retval.numel () != 1) |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
451 gripe_indexed_cs_list (); |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
452 else if (tmpi < i) |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
453 { |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
454 tmp = tmp.subsref (type.substr (tmpi, i - tmpi), tmpidx, true); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
455 tmpidx.clear (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
456 } |
| 4432 | 457 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
458 if (error_state) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
459 break; |
| 4432 | 460 |
| 4234 | 461 switch (type[i]) |
| 462 { | |
| 463 case '(': | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
464 { |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
465 octave_value_list tidx |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
466 = make_value_list (*p_args, *p_arg_nm, &tmp); |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
467 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
468 idx.push_back (tidx); |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
469 |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
470 if (i < n - 1) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
471 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
472 if (type[i+1] == '.') |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
473 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
474 tmpidx.push_back (tidx); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
475 tmpi = i+1; |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
476 } |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
477 else |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
478 error ("() must be followed by . or close the index chain"); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
479 } |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
480 } |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
481 break; |
| 4234 | 482 |
| 483 case '{': | |
| 5846 | 484 { |
| 485 octave_value_list tidx | |
| 486 = make_value_list (*p_args, *p_arg_nm, &tmp); | |
| 487 | |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
488 if (tmp.is_undefined ()) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
489 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
490 if (tidx.has_magic_colon ()) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
491 gripe_invalid_inquiry_subscript (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
492 else |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
493 tmp = Cell (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
494 } |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
495 else if (tmp.is_zero_by_zero () |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
496 && (tmp.is_matrix_type () || tmp.is_string ())) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
497 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
498 tmp = Cell (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
499 } |
| 5846 | 500 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
501 retval.numel (tmp.numel (tidx)); |
| 5846 | 502 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
503 if (error_state) |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
504 break; |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
505 |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
506 idx.push_back (tidx); |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
507 tmpidx.push_back (tidx); |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
508 tmpi = i; |
| 5846 | 509 } |
| 4234 | 510 break; |
| 511 | |
| 512 case '.': | |
| 513 { | |
| 6833 | 514 octave_value tidx = get_struct_index (p_arg_nm, p_dyn_field); |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
515 if (error_state) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
516 break; |
| 6833 | 517 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
518 bool autoconv = (tmp.is_zero_by_zero () |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
519 && (tmp.is_matrix_type () || tmp.is_string () |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
520 || tmp.is_cell ())); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
521 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
522 if (i > 0 && type [i-1] == '(') |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
523 { |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
524 octave_value_list pidx = idx.back (); |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
525 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
526 if (tmp.is_undefined ()) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
527 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
528 if (pidx.has_magic_colon ()) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
529 gripe_invalid_inquiry_subscript (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
530 else |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
531 tmp = Octave_map (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
532 } |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
533 else if (autoconv) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
534 tmp = Octave_map (); |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
535 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
536 retval.numel (tmp.numel (pidx)); |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
537 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
538 tmpi = i-1; |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
539 tmpidx.push_back (tidx); |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
540 } |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
541 else |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
542 { |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
543 if (tmp.is_undefined () || autoconv) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
544 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
545 tmpi = i+1; |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
546 tmp = octave_value (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
547 } |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
548 else |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
549 { |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
550 retval.numel (tmp.numel (octave_value_list ())); |
| 7099 | 551 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
552 tmpi = i; |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
553 tmpidx.push_back (tidx); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
554 } |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
555 } |
| 7057 | 556 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
557 if (error_state) |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
558 break; |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
559 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
560 idx.push_back (tidx); |
| 4234 | 561 } |
| 562 break; | |
| 563 | |
| 564 default: | |
| 565 panic_impossible (); | |
| 566 } | |
| 567 | |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
568 if (idx.back ().empty ()) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
569 error ("invalid empty index list"); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9125
diff
changeset
|
570 |
| 4234 | 571 if (error_state) |
| 572 break; | |
| 573 | |
| 574 p_args++; | |
| 575 p_arg_nm++; | |
| 576 p_dyn_field++; | |
| 577 } | |
| 3930 | 578 |
| 3933 | 579 if (! error_state) |
| 580 retval.set_index (type, idx); | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
581 |
| 2980 | 582 } |
| 583 | |
| 584 return retval; | |
| 585 } | |
| 586 | |
| 7099 | 587 /* |
| 588 %!test | |
| 589 %! x = {1, 2, 3}; | |
| 590 %! [x{:}] = deal (4, 5, 6); | |
| 591 %! assert (x, {4, 5, 6}); | |
| 592 | |
| 593 %!test | |
| 594 %! [x.a, x.b.c] = deal (1, 2); | |
| 595 %! assert (x.a == 1 && x.b.c == 2); | |
| 596 | |
| 597 %!test | |
| 598 %! [x.a, x(2).b] = deal (1, 2); | |
| 599 %! assert (x(1).a == 1 && isempty (x(2).a) && isempty (x(1).b) && x(2).b == 2); | |
| 600 | |
| 601 %!test | |
| 602 %! x = struct (zeros (0, 1), {"a", "b"}); | |
| 603 %! x(2).b = 1; | |
| 604 %! assert (x(2).b == 1); | |
| 605 | |
| 606 %!test | |
| 607 %! x = struct (zeros (0, 1), {"a", "b"}); | |
| 608 %! x(2).b = 1; | |
| 609 %! assert (x(2).b == 1); | |
| 610 */ | |
| 611 | |
| 5861 | 612 tree_index_expression * |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
613 tree_index_expression::dup (symbol_table::scope_id scope, |
|
8913
35cd375d4bb3
make tree::dup functions const
John W. Eaton <jwe@octave.org>
parents:
8658
diff
changeset
|
614 symbol_table::context_id context) const |
| 5861 | 615 { |
| 616 tree_index_expression *new_idx_expr | |
| 617 = new tree_index_expression (line (), column ()); | |
| 618 | |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
619 new_idx_expr->expr = expr ? expr->dup (scope, context) : 0; |
| 5861 | 620 |
| 621 std::list<tree_argument_list *> new_args; | |
| 622 | |
|
8913
35cd375d4bb3
make tree::dup functions const
John W. Eaton <jwe@octave.org>
parents:
8658
diff
changeset
|
623 for (std::list<tree_argument_list *>::const_iterator p = args.begin (); |
| 5861 | 624 p != args.end (); |
| 625 p++) | |
| 626 { | |
|
8913
35cd375d4bb3
make tree::dup functions const
John W. Eaton <jwe@octave.org>
parents:
8658
diff
changeset
|
627 const tree_argument_list *elt = *p; |
| 5861 | 628 |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
629 new_args.push_back (elt ? elt->dup (scope, context) : 0); |
| 5861 | 630 } |
| 631 | |
| 632 new_idx_expr->args = new_args; | |
| 633 | |
| 634 new_idx_expr->type = type; | |
| 635 | |
| 636 new_idx_expr->arg_nm = arg_nm; | |
| 637 | |
| 638 std::list<tree_expression *> new_dyn_field; | |
| 639 | |
|
8913
35cd375d4bb3
make tree::dup functions const
John W. Eaton <jwe@octave.org>
parents:
8658
diff
changeset
|
640 for (std::list<tree_expression *>::const_iterator p = dyn_field.begin (); |
| 5861 | 641 p != dyn_field.end (); |
| 642 p++) | |
| 643 { | |
|
8913
35cd375d4bb3
make tree::dup functions const
John W. Eaton <jwe@octave.org>
parents:
8658
diff
changeset
|
644 const tree_expression *elt = *p; |
| 5861 | 645 |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
646 new_dyn_field.push_back (elt ? elt->dup (scope, context) : 0); |
| 5861 | 647 } |
| 648 | |
| 649 new_idx_expr->dyn_field = new_dyn_field; | |
| 650 | |
| 651 new_idx_expr->copy_base (*this); | |
| 652 | |
| 653 return new_idx_expr; | |
| 654 } | |
| 655 | |
| 2980 | 656 void |
| 657 tree_index_expression::accept (tree_walker& tw) | |
| 658 { | |
| 659 tw.visit_index_expression (*this); | |
| 660 } |