Mercurial > octave-nkf
view libinterp/corefcn/oct-obj.cc @ 20574:dd6345fd8a97
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 | 4197fc428c7d |
children |
line wrap: on
line source
/* Copyright (C) 1994-2015 John W. Eaton Copyright (C) 2009 VZLU Prague This file is part of Octave. Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Octave; see the file COPYING. If not, see <http://www.gnu.org/licenses/>. */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #include "error.h" #include "oct-obj.h" #include "Cell.h" // We are likely to have a lot of octave_value_list objects to allocate, // so make the grow_size large. octave_value_list::octave_value_list (const std::list<octave_value_list>& lst) { octave_idx_type n = 0; octave_idx_type nel = 0; // Determine number. for (std::list<octave_value_list>::const_iterator p = lst.begin (); p != lst.end (); p++) { n++; nel += p->length (); } // Optimize single-element case if (n == 1) data = lst.front ().data; else if (nel > 0) { data.resize (dim_vector (1, nel)); octave_idx_type k = 0; for (std::list<octave_value_list>::const_iterator p = lst.begin (); p != lst.end (); p++) { data.assign (idx_vector (k, k + p->length ()), p->data); k += p->length (); } assert (k == nel); } } octave_value_list& octave_value_list::prepend (const octave_value& val) { octave_idx_type n = length (); resize (n + 1); while (n > 0) { elem (n) = elem (n - 1); n--; } elem (0) = val; return *this; } octave_value_list& octave_value_list::append (const octave_value& val) { octave_idx_type n = length (); resize (n + 1); elem (n) = val; return *this; } octave_value_list& octave_value_list::append (const octave_value_list& lst) { octave_idx_type len = length (); octave_idx_type lst_len = lst.length (); resize (len + lst_len); for (octave_idx_type i = 0; i < lst_len; i++) elem (len + i) = lst (i); return *this; } octave_value_list& octave_value_list::reverse (void) { octave_idx_type n = length (); for (octave_idx_type i = 0; i < n / 2; i++) { octave_value tmp = elem (i); elem (i) = elem (n - i - 1); elem (n - i - 1) = tmp; } return *this; } octave_value_list octave_value_list::splice (octave_idx_type offset, octave_idx_type rep_length, const octave_value_list& lst) const { octave_value_list retval; octave_idx_type len = length (); if (offset < 0 || offset >= len) { if (! (rep_length == 0 && offset == len)) { error ("octave_value_list::splice: invalid OFFSET"); return retval; } } if (rep_length < 0 || rep_length + offset > len) { error ("octave_value_list::splice: invalid LENGTH"); return retval; } octave_idx_type lst_len = lst.length (); octave_idx_type new_len = len - rep_length + lst_len; retval.resize (new_len); octave_idx_type k = 0; for (octave_idx_type i = 0; i < offset; i++) retval(k++) = elem (i); for (octave_idx_type i = 0; i < lst_len; i++) retval(k++) = lst (i); for (octave_idx_type i = offset + rep_length; i < len; i++) retval(k++) = elem (i); return retval; } bool octave_value_list::all_strings_p (void) const { octave_idx_type n = length (); for (octave_idx_type i = 0; i < n; i++) if (! elem(i).is_string ()) return false; return true; } bool octave_value_list::all_scalars (void) const { octave_idx_type n = length (); for (octave_idx_type i = 0; i < n; i++) { dim_vector dv = elem(i).dims (); if (! dv.all_ones ()) return false; } return true; } bool octave_value_list::any_cell (void) const { octave_idx_type n = length (); for (octave_idx_type i = 0; i < n; i++) if (elem (i).is_cell ()) return true; return false; } bool octave_value_list::has_magic_colon (void) const { octave_idx_type n = length (); for (octave_idx_type i = 0; i < n; i++) if (elem(i).is_magic_colon ()) return true; return false; } string_vector octave_value_list::make_argv (const std::string& fcn_name) const { string_vector argv; if (all_strings_p ()) { octave_idx_type len = length (); octave_idx_type total_nr = 0; for (octave_idx_type i = 0; i < len; i++) { // An empty std::string ("") has zero columns and zero rows (a // change that was made for Matlab contemptibility. octave_idx_type n = elem(i).rows (); total_nr += n ? n : 1; } octave_idx_type k = 0; if (! fcn_name.empty ()) { argv.resize (total_nr+1); argv[0] = fcn_name; k = 1; } else argv.resize (total_nr); for (octave_idx_type i = 0; i < len; i++) { octave_idx_type nr = elem(i).rows (); if (nr < 2) argv[k++] = elem(i).string_value (); else { string_vector tmp = elem(i).all_strings (); for (octave_idx_type j = 0; j < nr; j++) argv[k++] = tmp[j]; } } } else error ("%s: expecting all arguments to be strings", fcn_name.c_str ()); return argv; } void octave_value_list::make_storable_values (void) { octave_idx_type len = length (); const Array<octave_value>& cdata = data; for (octave_idx_type i = 0; i < len; i++) { // This is optimized so that we don't force a copy unless necessary. octave_value tmp = cdata(i).storable_value (); if (! tmp.is_copy_of (cdata (i))) data(i) = tmp; } }