Mercurial > octave-nkf
annotate src/pt-idx.cc @ 8546:3d8a914c580e
improve parser indexed assigment code
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Tue, 20 Jan 2009 21:15:17 +0100 |
| parents | 3100283874d7 |
| children | 906f976d35a8 |
| rev | line source |
|---|---|
| 2980 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2006, |
| 4 2007 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" | |
| 2980 | 42 |
| 43 // Index expressions. | |
| 44 | |
| 5861 | 45 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
|
46 : tree_expression (l, c), expr (0), args (0), type (), |
| 5861 | 47 arg_nm (), dyn_field () { } |
| 48 | |
| 3546 | 49 tree_index_expression::tree_index_expression (tree_expression *e, |
| 50 tree_argument_list *lst, | |
| 3933 | 51 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
|
52 : tree_expression (l, c), expr (e), args (0), type (), |
| 4131 | 53 arg_nm (), dyn_field () |
| 3933 | 54 { |
| 55 append (lst, t); | |
| 56 } | |
| 3215 | 57 |
| 3930 | 58 tree_index_expression::tree_index_expression (tree_expression *e, |
| 59 const std::string& n, | |
| 3944 | 60 int l, int c) |
|
7791
975e9540be2c
pt-idx.cc: initialize fields in constructors
John W. Eaton <jwe@octave.org>
parents:
7790
diff
changeset
|
61 : tree_expression (l, c), expr (e), args (0), type (), |
| 4131 | 62 arg_nm (), dyn_field () |
| 3933 | 63 { |
| 64 append (n); | |
| 65 } | |
| 66 | |
| 4131 | 67 tree_index_expression::tree_index_expression (tree_expression *e, |
| 68 tree_expression *df, | |
| 69 int l, int c) | |
|
7791
975e9540be2c
pt-idx.cc: initialize fields in constructors
John W. Eaton <jwe@octave.org>
parents:
7790
diff
changeset
|
70 : tree_expression (l, c), expr (e), args (0), type (), |
| 4131 | 71 arg_nm (), dyn_field () |
| 72 { | |
| 73 append (df); | |
| 74 } | |
| 75 | |
| 3933 | 76 void |
| 77 tree_index_expression::append (tree_argument_list *lst, char t) | |
| 78 { | |
| 4219 | 79 args.push_back (lst); |
| 3933 | 80 type.append (1, t); |
| 4219 | 81 arg_nm.push_back (lst ? lst->get_arg_names () : string_vector ()); |
| 82 dyn_field.push_back (static_cast<tree_expression *> (0)); | |
| 3933 | 83 } |
| 84 | |
| 85 void | |
| 86 tree_index_expression::append (const std::string& n) | |
| 87 { | |
| 4219 | 88 args.push_back (static_cast<tree_argument_list *> (0)); |
| 3933 | 89 type.append ("."); |
| 4219 | 90 arg_nm.push_back (n); |
| 91 dyn_field.push_back (static_cast<tree_expression *> (0)); | |
| 4131 | 92 } |
| 93 | |
| 94 void | |
| 95 tree_index_expression::append (tree_expression *df) | |
| 96 { | |
| 4219 | 97 args.push_back (static_cast<tree_argument_list *> (0)); |
| 4131 | 98 type.append ("."); |
| 4219 | 99 arg_nm.push_back (""); |
| 100 dyn_field.push_back (df); | |
| 3933 | 101 } |
| 3930 | 102 |
| 2980 | 103 tree_index_expression::~tree_index_expression (void) |
| 104 { | |
| 105 delete expr; | |
| 3933 | 106 |
| 107 while (! args.empty ()) | |
| 108 { | |
| 4219 | 109 std::list<tree_argument_list *>::iterator p = args.begin (); |
| 110 delete *p; | |
| 111 args.erase (p); | |
| 3933 | 112 } |
| 2980 | 113 } |
| 114 | |
| 5099 | 115 bool |
| 116 tree_index_expression::has_magic_end (void) const | |
| 117 { | |
| 118 for (std::list<tree_argument_list *>::const_iterator p = args.begin (); | |
| 119 p != args.end (); | |
| 120 p++) | |
| 121 { | |
| 122 tree_argument_list *elt = *p; | |
| 123 | |
| 124 if (elt && elt->has_magic_end ()) | |
| 125 return true; | |
| 126 } | |
| 127 | |
| 128 return false; | |
| 129 } | |
| 130 | |
| 2991 | 131 // This is useful for printing the name of the variable in an indexed |
| 132 // assignment. | |
| 133 | |
| 3536 | 134 std::string |
| 2991 | 135 tree_index_expression::name (void) const |
| 136 { | |
| 4131 | 137 return expr->name (); |
| 3933 | 138 } |
| 139 | |
| 140 static Cell | |
| 141 make_subs_cell (tree_argument_list *args, const string_vector& arg_nm) | |
| 142 { | |
| 143 Cell retval; | |
| 144 | |
| 145 octave_value_list arg_values; | |
| 146 | |
| 147 if (args) | |
| 148 arg_values = args->convert_to_const_vector (); | |
| 149 | |
| 150 if (! error_state) | |
| 151 { | |
| 152 int n = arg_values.length (); | |
| 153 | |
| 154 if (n > 0) | |
| 155 { | |
| 156 arg_values.stash_name_tags (arg_nm); | |
| 157 | |
| 4548 | 158 retval.resize (dim_vector (1, n)); |
| 3933 | 159 |
| 160 for (int i = 0; i < n; i++) | |
| 161 retval(0,i) = arg_values(i); | |
| 162 } | |
| 163 } | |
| 164 | |
| 165 return retval; | |
| 166 } | |
| 167 | |
| 168 static inline octave_value_list | |
| 4234 | 169 make_value_list (tree_argument_list *args, const string_vector& arg_nm, |
| 170 const octave_value *object) | |
| 3933 | 171 { |
| 172 octave_value_list retval; | |
| 173 | |
| 174 if (args) | |
| 4234 | 175 retval = args->convert_to_const_vector (object); |
| 3933 | 176 |
| 177 if (! error_state) | |
| 178 { | |
| 179 int n = retval.length (); | |
| 180 | |
| 181 if (n > 0) | |
| 182 retval.stash_name_tags (arg_nm); | |
| 183 } | |
| 184 | |
| 185 return retval; | |
| 186 } | |
| 187 | |
| 4131 | 188 std::string |
| 4219 | 189 tree_index_expression::get_struct_index |
| 190 (std::list<string_vector>::const_iterator p_arg_nm, | |
| 191 std::list<tree_expression *>::const_iterator p_dyn_field) const | |
| 4131 | 192 { |
| 4219 | 193 std::string fn = (*p_arg_nm)(0); |
| 4131 | 194 |
| 195 if (fn.empty ()) | |
| 196 { | |
| 4219 | 197 tree_expression *df = *p_dyn_field; |
| 4131 | 198 |
| 199 if (df) | |
| 200 { | |
| 201 octave_value t = df->rvalue (); | |
| 202 | |
| 203 if (! error_state) | |
| 4143 | 204 { |
| 205 fn = t.string_value (); | |
| 206 | |
| 207 if (! valid_identifier (fn)) | |
| 6811 | 208 ::error ("invalid structure field name `%s'", fn.c_str ()); |
| 4143 | 209 } |
| 4131 | 210 } |
| 211 else | |
| 212 panic_impossible (); | |
| 213 } | |
| 214 | |
| 215 return fn; | |
| 216 } | |
| 217 | |
| 3933 | 218 Octave_map |
| 219 tree_index_expression::make_arg_struct (void) const | |
| 220 { | |
| 4219 | 221 int n = args.size (); |
| 3933 | 222 |
| 7336 | 223 Cell type_field (n, 1); |
| 224 Cell subs_field (n, 1); | |
| 3933 | 225 |
| 4219 | 226 std::list<tree_argument_list *>::const_iterator p_args = args.begin (); |
| 227 std::list<string_vector>::const_iterator p_arg_nm = arg_nm.begin (); | |
| 228 std::list<tree_expression *>::const_iterator p_dyn_field = dyn_field.begin (); | |
| 3933 | 229 |
| 230 Octave_map m; | |
| 231 | |
| 232 for (int i = 0; i < n; i++) | |
| 233 { | |
| 234 switch (type[i]) | |
| 235 { | |
| 236 case '(': | |
| 7336 | 237 subs_field(i) = make_subs_cell (*p_args, *p_arg_nm); |
| 3933 | 238 break; |
| 239 | |
| 240 case '{': | |
| 7336 | 241 subs_field(i) = make_subs_cell (*p_args, *p_arg_nm); |
| 3933 | 242 break; |
| 243 | |
| 244 case '.': | |
|
8011
3100283874d7
improve backtrace error messages
John W. Eaton <jwe@octave.org>
parents:
7791
diff
changeset
|
245 subs_field(i) = get_struct_index (p_arg_nm, p_dyn_field); |
| 3933 | 246 break; |
| 247 | |
| 248 default: | |
| 249 panic_impossible (); | |
| 250 } | |
| 251 | |
| 252 if (error_state) | |
| 253 return m; | |
| 254 | |
| 4219 | 255 p_args++; |
| 256 p_arg_nm++; | |
| 257 p_dyn_field++; | |
| 3933 | 258 } |
| 259 | |
| 7336 | 260 m.assign ("type", type_field); |
| 261 m.assign ("subs", subs_field); | |
| 3933 | 262 |
| 263 return m; | |
| 2991 | 264 } |
| 265 | |
| 2980 | 266 octave_value_list |
| 267 tree_index_expression::rvalue (int nargout) | |
| 268 { | |
| 269 octave_value_list retval; | |
| 270 | |
| 271 if (error_state) | |
| 272 return retval; | |
| 273 | |
| 7336 | 274 octave_value first_expr_val; |
| 275 | |
| 276 octave_value_list first_args; | |
| 277 | |
| 278 bool have_args = false; | |
| 279 | |
| 280 if (expr->is_identifier () && type[0] == '(') | |
| 281 { | |
| 282 tree_identifier *id = dynamic_cast<tree_identifier *> (expr); | |
| 283 | |
| 284 if (! (id->is_variable () || args.empty ())) | |
| 285 { | |
| 286 tree_argument_list *al = *(args.begin ()); | |
| 287 | |
| 288 size_t n = al ? al->length () : 0; | |
| 289 | |
| 290 if (n > 0) | |
| 291 { | |
| 292 string_vector anm = *(arg_nm.begin ()); | |
| 293 | |
| 294 first_expr_val = id->do_lookup (al, anm, first_args, have_args); | |
| 295 } | |
| 296 } | |
| 297 } | |
| 2980 | 298 |
| 299 if (! error_state) | |
| 300 { | |
| 7336 | 301 if (first_expr_val.is_undefined ()) |
| 302 first_expr_val = expr->rvalue (); | |
| 303 | |
| 304 octave_value tmp = first_expr_val; | |
| 305 | |
| 4219 | 306 std::list<octave_value_list> idx; |
| 3930 | 307 |
| 4219 | 308 int n = args.size (); |
| 3933 | 309 |
| 4219 | 310 std::list<tree_argument_list *>::iterator p_args = args.begin (); |
| 311 std::list<string_vector>::iterator p_arg_nm = arg_nm.begin (); | |
| 312 std::list<tree_expression *>::iterator p_dyn_field = dyn_field.begin (); | |
| 3930 | 313 |
| 3933 | 314 for (int i = 0; i < n; i++) |
| 315 { | |
| 4432 | 316 if (i > 0) |
| 317 { | |
| 318 tree_argument_list *al = *p_args; | |
| 319 | |
| 320 if (al && al->has_magic_end ()) | |
| 321 { | |
| 322 // We have an expression like | |
| 323 // | |
| 324 // x{end}.a(end) | |
| 325 // | |
| 326 // and we are looking at the argument list that | |
| 327 // contains the second (or third, etc.) "end" token, | |
| 328 // so we must evaluate everything up to the point of | |
| 7336 | 329 // that argument list so we can pass the appropriate |
| 4432 | 330 // value to the built-in __end__ function. |
| 331 | |
| 332 octave_value_list tmp_list | |
| 7336 | 333 = first_expr_val.subsref (type.substr (0, i), idx, nargout); |
| 4432 | 334 |
| 335 tmp = tmp_list(0); | |
| 336 | |
| 337 if (error_state) | |
| 338 break; | |
| 339 } | |
| 340 } | |
| 341 | |
| 3933 | 342 switch (type[i]) |
| 343 { | |
| 344 case '(': | |
| 7336 | 345 if (have_args) |
| 346 { | |
| 347 idx.push_back (first_args); | |
| 348 have_args = false; | |
| 349 } | |
| 350 else | |
| 351 idx.push_back (make_value_list (*p_args, *p_arg_nm, &tmp)); | |
| 3933 | 352 break; |
| 3930 | 353 |
| 3933 | 354 case '{': |
| 4234 | 355 idx.push_back (make_value_list (*p_args, *p_arg_nm, &tmp)); |
| 3933 | 356 break; |
| 2980 | 357 |
| 3933 | 358 case '.': |
|
8011
3100283874d7
improve backtrace error messages
John W. Eaton <jwe@octave.org>
parents:
7791
diff
changeset
|
359 idx.push_back (octave_value (get_struct_index (p_arg_nm, p_dyn_field))); |
| 3933 | 360 break; |
| 3930 | 361 |
| 3933 | 362 default: |
| 363 panic_impossible (); | |
| 364 } | |
| 3930 | 365 |
| 3933 | 366 if (error_state) |
| 367 break; | |
| 368 | |
| 4219 | 369 p_args++; |
| 370 p_arg_nm++; | |
| 371 p_dyn_field++; | |
| 2980 | 372 } |
| 3933 | 373 |
| 374 if (! error_state) | |
| 4432 | 375 retval = first_expr_val.subsref (type, idx, nargout); |
| 2980 | 376 } |
| 377 | |
| 378 return retval; | |
| 379 } | |
| 380 | |
| 381 octave_value | |
| 382 tree_index_expression::rvalue (void) | |
| 383 { | |
| 384 octave_value retval; | |
| 385 | |
| 386 octave_value_list tmp = rvalue (1); | |
| 387 | |
| 388 if (! tmp.empty ()) | |
| 389 retval = tmp(0); | |
| 390 | |
| 391 return retval; | |
| 392 } | |
| 393 | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
394 static void |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
395 gripe_invalid_inquiry_subscript (void) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
396 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
397 error ("invalid dimension inquiry of a non-existent value"); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
398 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
399 |
| 2980 | 400 octave_lvalue |
| 401 tree_index_expression::lvalue (void) | |
| 402 { | |
| 403 octave_lvalue retval; | |
| 404 | |
| 4219 | 405 std::list<octave_value_list> idx; |
| 3933 | 406 |
| 4219 | 407 int n = args.size (); |
| 3933 | 408 |
| 4219 | 409 std::list<tree_argument_list *>::iterator p_args = args.begin (); |
| 410 std::list<string_vector>::iterator p_arg_nm = arg_nm.begin (); | |
| 411 std::list<tree_expression *>::iterator p_dyn_field = dyn_field.begin (); | |
| 3933 | 412 |
| 4234 | 413 retval = expr->lvalue (); |
| 3933 | 414 |
| 2980 | 415 if (! error_state) |
| 416 { | |
| 7099 | 417 bool have_new_struct_field = false; |
| 418 | |
| 4432 | 419 // I think it is OK to have a copy here. |
| 420 | |
| 421 const octave_value *tro = retval.object (); | |
| 422 | |
| 423 octave_value first_retval_object; | |
| 424 | |
| 425 if (tro) | |
| 426 first_retval_object = *tro; | |
| 427 | |
| 428 octave_value tmp = first_retval_object; | |
| 4234 | 429 |
| 430 for (int i = 0; i < n; i++) | |
| 431 { | |
| 4432 | 432 if (i > 0) |
| 433 { | |
| 434 tree_argument_list *al = *p_args; | |
| 435 | |
| 436 if (al && al->has_magic_end ()) | |
| 437 { | |
| 438 // We have an expression like | |
| 439 // | |
| 440 // x{end}.a(end) | |
| 441 // | |
| 442 // and we are looking at the argument list that | |
| 443 // contains the second (or third, etc.) "end" token, | |
| 444 // so we must evaluate everything up to the point of | |
| 7336 | 445 // that argument list so we pass the appropriate |
| 4432 | 446 // value to the built-in __end__ function. |
| 447 | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
448 if (first_retval_object.is_defined ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
449 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
450 octave_value_list tmp_list |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
451 = first_retval_object.subsref (type.substr (0, i), idx, 1); |
| 4432 | 452 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
453 tmp = tmp_list(0); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
454 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
455 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
456 gripe_invalid_inquiry_subscript (); |
| 4432 | 457 |
| 458 if (error_state) | |
| 459 break; | |
| 460 } | |
| 461 } | |
| 462 | |
| 4234 | 463 switch (type[i]) |
| 464 { | |
| 465 case '(': | |
| 4432 | 466 idx.push_back (make_value_list (*p_args, *p_arg_nm, &tmp)); |
| 4234 | 467 break; |
| 468 | |
| 469 case '{': | |
| 5846 | 470 { |
| 471 octave_value_list tidx | |
| 472 = make_value_list (*p_args, *p_arg_nm, &tmp); | |
| 473 | |
| 474 idx.push_back (tidx); | |
| 475 | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
476 if (! tidx.all_scalars () && retval.numel () == 1) |
| 5846 | 477 { |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
478 // Possible cs-list. |
| 5846 | 479 |
| 480 if (tidx.has_magic_colon ()) | |
| 481 { | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
482 if (first_retval_object.is_defined ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
483 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
484 octave_value_list tmp_list |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
485 = first_retval_object.subsref (type, idx, 1); |
| 5846 | 486 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
487 if (! error_state) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
488 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
489 octave_value val = tmp_list(0); |
| 5846 | 490 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
491 if (val.is_cs_list ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
492 retval.numel (val.numel ()); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
493 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
494 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
495 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
496 gripe_invalid_inquiry_subscript (); |
| 5846 | 497 } |
| 498 else | |
| 499 { | |
| 500 octave_idx_type nel = 1; | |
| 501 | |
| 502 octave_idx_type nidx = tidx.length (); | |
| 503 | |
| 504 for (octave_idx_type j = 0; j < nidx; j++) | |
| 505 { | |
| 506 octave_value val = tidx(j); | |
| 507 | |
| 508 nel *= val.numel (); | |
| 509 } | |
| 510 | |
| 511 retval.numel (nel); | |
| 512 } | |
| 513 } | |
| 514 } | |
| 4234 | 515 break; |
| 516 | |
| 517 case '.': | |
| 518 { | |
| 6833 | 519 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
|
520 if (error_state) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
521 break; |
| 6833 | 522 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
523 if (i > 0 && type [i-1] == '(' && retval.numel () == 1 |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
524 && ! idx.back ().all_scalars ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
525 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
526 // Possible cs-list. |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
527 |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
528 std::string ttype = type.substr (0, i); |
| 6833 | 529 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
530 octave_value_list xidx = idx.back (); |
| 7099 | 531 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
532 if (xidx.has_magic_colon ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
533 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
534 if (first_retval_object.is_defined () && ! have_new_struct_field) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
535 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
536 octave_value_list tmp_list |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
537 = first_retval_object.subsref (ttype, idx, 1); |
| 7099 | 538 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
539 if (! error_state) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
540 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
541 octave_value val = tmp_list(0); |
| 7057 | 542 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
543 if (val.is_map ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
544 retval.numel (val.numel ()); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
545 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
546 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
547 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
548 gripe_invalid_inquiry_subscript (); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
549 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
550 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
551 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
552 octave_idx_type nel = 1; |
| 7099 | 553 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
554 octave_idx_type nidx = xidx.length (); |
| 7099 | 555 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
556 for (octave_idx_type j = 0; j < nidx; j++) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
557 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
558 octave_value val = xidx(j); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
559 |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
560 nel *= val.numel (); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
561 } |
| 7099 | 562 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
563 retval.numel (nel); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
564 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
565 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
566 else if (retval.numel () == 1 && first_retval_object.is_defined ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
567 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
568 octave_value tobj = first_retval_object; |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
569 |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
570 std::string ttype = type.substr (0, i); |
| 7057 | 571 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
572 if (i > 0) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
573 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
574 // Here we need to ensure that keys do exist. |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
575 |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
576 octave_value_list tmp_list |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
577 = first_retval_object.subsref (ttype, idx, 1); |
| 7099 | 578 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
579 if (tmp_list.length () > 0) tobj = tmp_list (0); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
580 } |
| 7099 | 581 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
582 |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
583 std::string key = tidx.string_value (); |
| 7100 | 584 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
585 if (! error_state) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
586 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
587 if (tobj.is_map ()) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
588 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
589 Octave_map map = tobj.map_value (); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
590 if (map.contains (key)) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
591 retval.numel (map.contents (key).numel ()); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
592 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
593 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
594 map.contents (key) = octave_value (); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
595 if (i > 0) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
596 first_retval_object = |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
597 first_retval_object.subsasgn (ttype, idx, map); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
598 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
599 first_retval_object = map; |
| 7099 | 600 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
601 have_new_struct_field = true; |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
602 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
603 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
604 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
605 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
606 Octave_map map (key, octave_value ()); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
607 if (i > 0) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
608 first_retval_object = |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
609 first_retval_object.subsasgn (ttype, idx, map); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
610 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
611 first_retval_object = map; |
| 7057 | 612 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
613 have_new_struct_field = true; |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
614 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
615 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
616 } |
| 7057 | 617 |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
618 if (! error_state) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
619 idx.push_back (tidx); |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
620 else |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
621 break; |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
622 |
| 4234 | 623 } |
| 624 break; | |
| 625 | |
| 626 default: | |
| 627 panic_impossible (); | |
| 628 } | |
| 629 | |
| 630 if (error_state) | |
| 631 break; | |
| 632 | |
| 633 p_args++; | |
| 634 p_arg_nm++; | |
| 635 p_dyn_field++; | |
| 636 } | |
| 3930 | 637 |
| 3933 | 638 if (! error_state) |
| 639 retval.set_index (type, idx); | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8011
diff
changeset
|
640 |
| 2980 | 641 } |
| 642 | |
| 643 return retval; | |
| 644 } | |
| 645 | |
| 7099 | 646 /* |
| 647 %!test | |
| 648 %! x = {1, 2, 3}; | |
| 649 %! [x{:}] = deal (4, 5, 6); | |
| 650 %! assert (x, {4, 5, 6}); | |
| 651 | |
| 652 %!test | |
| 653 %! [x.a, x.b.c] = deal (1, 2); | |
| 654 %! assert (x.a == 1 && x.b.c == 2); | |
| 655 | |
| 656 %!test | |
| 657 %! [x.a, x(2).b] = deal (1, 2); | |
| 658 %! assert (x(1).a == 1 && isempty (x(2).a) && isempty (x(1).b) && x(2).b == 2); | |
| 659 | |
| 660 %!test | |
| 661 %! x = struct (zeros (0, 1), {"a", "b"}); | |
| 662 %! x(2).b = 1; | |
| 663 %! assert (x(2).b == 1); | |
| 664 | |
| 665 %!test | |
| 666 %! x = struct (zeros (0, 1), {"a", "b"}); | |
| 667 %! x(2).b = 1; | |
| 668 %! assert (x(2).b == 1); | |
| 669 */ | |
| 670 | |
| 5861 | 671 tree_index_expression * |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
672 tree_index_expression::dup (symbol_table::scope_id scope, |
|
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
673 symbol_table::context_id context) |
| 5861 | 674 { |
| 675 tree_index_expression *new_idx_expr | |
| 676 = new tree_index_expression (line (), column ()); | |
| 677 | |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
678 new_idx_expr->expr = expr ? expr->dup (scope, context) : 0; |
| 5861 | 679 |
| 680 std::list<tree_argument_list *> new_args; | |
| 681 | |
| 682 for (std::list<tree_argument_list *>::iterator p = args.begin (); | |
| 683 p != args.end (); | |
| 684 p++) | |
| 685 { | |
| 686 tree_argument_list *elt = *p; | |
| 687 | |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
688 new_args.push_back (elt ? elt->dup (scope, context) : 0); |
| 5861 | 689 } |
| 690 | |
| 691 new_idx_expr->args = new_args; | |
| 692 | |
| 693 new_idx_expr->type = type; | |
| 694 | |
| 695 new_idx_expr->arg_nm = arg_nm; | |
| 696 | |
| 697 std::list<tree_expression *> new_dyn_field; | |
| 698 | |
| 699 for (std::list<tree_expression *>::iterator p = dyn_field.begin (); | |
| 700 p != dyn_field.end (); | |
| 701 p++) | |
| 702 { | |
| 703 tree_expression *elt = *p; | |
| 704 | |
|
7767
71f068b22fcc
scope and context fixes for function handles
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
705 new_dyn_field.push_back (elt ? elt->dup (scope, context) : 0); |
| 5861 | 706 } |
| 707 | |
| 708 new_idx_expr->dyn_field = new_dyn_field; | |
| 709 | |
| 710 new_idx_expr->copy_base (*this); | |
| 711 | |
| 712 return new_idx_expr; | |
| 713 } | |
| 714 | |
| 2980 | 715 void |
| 716 tree_index_expression::accept (tree_walker& tw) | |
| 717 { | |
| 718 tw.visit_index_expression (*this); | |
| 719 } | |
| 720 | |
| 721 /* | |
| 722 ;;; Local Variables: *** | |
| 723 ;;; mode: C++ *** | |
| 724 ;;; End: *** | |
| 725 */ |