Mercurial > octave-nkf

diff libinterp/parse-tree/pt-assign.cc @ 20574:dd6345fd8a97

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use exceptions for better invalid index error reporting (bug #45957) * lo-array-gripes.h, lo-array-gripes.cc (index_exception): New base class for indexing errors. (invalid_index, out_of_range): New classes. (gripe_index_out_of_range): New overloaded function. (gripe_invalid_index): New overloaded functions. Delete version with no arguments. (gripe_invalid_assignment_size, gripe_assignment_dimension_mismatch): Delete. Change uses of gripe functions as needed. * Cell.cc (Cell::index, Cell::assign, Cell::delete_elements): Use exceptions to collect error info about and handle indexing errors. * data.cc (Fnth_element, do_accumarray_sum, F__accumarray_sum__, do_accumarray_minmax, do_accumarray_minmax_fun, F__accumdim_sum__): Likewise. * oct-map.cc (octave_map::index, octave_map::assign, octave_map::delete_elements): Likewise. * sparse.cc (Fsparse): Likewise. * sub2ind.cc (Fsub2ind, Find2sub): Likewise. New tests. * utils.cc (dims_to_numel): Likewise. * ov-base-diag.cc (octave_base_diag<DMT, MT>::do_index_op, octave_base_diag<DMT, MT>::subsasgn): Likewise. * ov-base-mat.cc (octave_base_matrix<MT>::subsref, octave_base_matrix<MT>::assign): Likewise. * ov-base-sparse.cc (octave_base_sparse<T>::do_index_op, octave_base_sparse<T>::assign, octave_base_sparse<MT>::delete_elements): Likewise. * ov-classdef.cc (cdef_object_array::subsref, cdef_object_array::subsasgn): Likewise. * ov-java.cc (make_java_index): Likewise. * ov-perm.cc (octave_perm_matrix::do_index_op): Likewise. * ov-range.cc (octave_range::do_index_op): Likewise. * ov-re-diag.cc (octave_diag_matrix::do_index_op): Likewise. * ov-str-mat.cc (octave_char_matrix_str::do_index_op_internal): Likewise. * pt-assign.cc (tree_simple_assignment::rvalue1): Likewise. * pt-idx.cc (tree_index_expression::rvalue, tree_index_expression::lvalue): Likewise. * Array-util.cc (sub2ind): Likewise. * toplev.cc (main_loop): Also catch unhandled index_exception exceptions. * ov-base.cc (octave_base_value::index_vector): Improve error message. * ov-re-sparse.cc (octave_sparse_matrix::index_vector): Likewise. * ov-complex.cc (complex_index): New class. (gripe_complex_index): New function. (octave_complex::index_vector): Use it. * pt-id.h, pt-id.cc (tree_identifier::is_variable, tree_black_hole::is_variable): Now const. * pt-idx.cc (final_index_error): New static function. (tree_index_expression::rvalue, tree_index_expression::lvalue): Use it. * index.tst: New tests.
author Lachlan Andrew <lachlanbis@gmail.com>
date Fri, 02 Oct 2015 15:07:37 -0400
parents 011a364b4d78
children b10432a40432
line wrap: on
line diff
--- a/libinterp/parse-tree/pt-assign.cc	Fri Oct 02 12:25:39 2015 -0400
+++ b/libinterp/parse-tree/pt-assign.cc	Fri Oct 02 15:07:37 2015 -0400
@@ -106,41 +106,49 @@
                     }
                 }
 
-              octave_lvalue ult = lhs->lvalue ();
+              try
+                {
+                  octave_lvalue ult = lhs->lvalue ();
 
-              if (ult.numel () != 1)
-                gripe_nonbraced_cs_list_assignment ();
-
-              if (! error_state)
-                {
-                  ult.assign (etype, rhs_val);
+                  if (ult.numel () != 1)
+                    gripe_nonbraced_cs_list_assignment ();
 
                   if (! error_state)
                     {
-                      if (etype == octave_value::op_asn_eq)
-                        retval = rhs_val;
-                      else
-                        retval = ult.value ();
+                      ult.assign (etype, rhs_val);
 
-                      if (print_result ()
-                          && tree_evaluator::statement_printing_enabled ())
+                      if (! error_state)
                         {
-                          // We clear any index here so that we can
-                          // get the new value of the referenced
-                          // object below, instead of the indexed
-                          // value (which should be the same as the
-                          // right hand side value).
+                          if (etype == octave_value::op_asn_eq)
+                            retval = rhs_val;
+                          else
+                            retval = ult.value ();
 
-                          ult.clear_index ();
-
-                          octave_value lhs_val = ult.value ();
+                          if (print_result ()
+                              && tree_evaluator::statement_printing_enabled ())
+                            {
+                              // We clear any index here so that we can
+                              // get the new value of the referenced
+                              // object below, instead of the indexed
+                              // value (which should be the same as the
+                              // right hand side value).
 
-                          if (! error_state)
-                            lhs_val.print_with_name (octave_stdout,
-                                                     lhs->name ());
+                              ult.clear_index ();
+
+                              octave_value lhs_val = ult.value ();
+
+                              if (! error_state)
+                                lhs_val.print_with_name (octave_stdout,
+                                                         lhs->name ());
+                            }
                         }
                     }
                 }
+              catch (index_exception& e)
+                {       // problems with range, invalid index type etc.
+                  e.set_var (lhs->name ());
+                  (*current_liboctave_error_with_id_handler) (e.id(), e.err());
+                }
             }
         }
     }