Mercurial > octave
view liboctave/util/lo-array-gripes.cc @ 20652:7a8096f8df5d
more cleanup of indexing exceptions
* data.cc (index_error): New function.
(Fnth_element, F__accumarray_sum__, __accumdim_sum__): Use it.
* lo-array-gripes.h, lo-array-gripes.cc (index_exception::message):
Rename from index_exception::err. Return std::string instead of const
char *. Change all uses.
(index_exception::expression): Rename from index_exception::access.
(index_exception::index_exception, invalid_index::invalid_index,
out_of_range::out_of_range): Accept const string& instead of const
char *. Change all uses.
(invalid_index::details): Rename from invalid_index::explain. Return
std::string instead of const char *. Change all uses.
(invalid_index::err_idx): Rename from invalid_index::id. Return
std::string instead of const char *. Change all uses.
(gripe_invalid_index): Accept const std::string& argument instead of
const char *.
(index_exception::~index_exception): Don't declare with "throw ()".
(index_exception::details): Rename from index_exception::explain. Return
std::string instead of const char *. Change all uses.
(index_exception::err_idx): Rename from index_exception::id. Return
std::string instead of const char *. Change all uses.
(index_exception::idx): Return std::string instead of const char *.
Change all uses.
(index_exception::err_id): Rename from index_exception::id.
(index_exception::msg): Delete member variable.
(index_expression::expression): Rename from index_expression::access.
Change all uses.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Wed, 21 Oct 2015 23:43:46 -0400 |
parents | c1d94e5cd5ea |
children | c16947991354 |
line wrap: on
line source
/* Copyright (C) 2003-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 <cstring> #include "lo-array-gripes.h" #include "lo-error.h" const char *error_id_nonconformant_args = "Octave:nonconformant-args"; const char *error_id_index_out_of_bounds = "Octave:index-out-of-bounds"; const char *error_id_invalid_index = "Octave:invalid-index"; const char *warning_id_nearly_singular_matrix = "Octave:nearly-singular-matrix"; const char *warning_id_singular_matrix = "Octave:singular-matrix"; void gripe_nan_to_logical_conversion (void) { (*current_liboctave_error_handler) ("invalid conversion from NaN to logical"); } void gripe_nan_to_character_conversion (void) { (*current_liboctave_error_handler) ("invalid conversion from NaN to character"); } void gripe_nonconformant (const char *op, octave_idx_type op1_len, octave_idx_type op2_len) { const char *err_id = error_id_nonconformant_args; (*current_liboctave_error_with_id_handler) (err_id, "%s: nonconformant arguments (op1 len: %d, op2 len: %d)", op, op1_len, op2_len); } void gripe_nonconformant (const char *op, octave_idx_type op1_nr, octave_idx_type op1_nc, octave_idx_type op2_nr, octave_idx_type op2_nc) { const char *err_id = error_id_nonconformant_args; (*current_liboctave_error_with_id_handler) (err_id, "%s: nonconformant arguments (op1 is %dx%d, op2 is %dx%d)", op, op1_nr, op1_nc, op2_nr, op2_nc); } void gripe_nonconformant (const char *op, const dim_vector& op1_dims, const dim_vector& op2_dims) { const char *err_id = error_id_nonconformant_args; std::string op1_dims_str = op1_dims.str (); std::string op2_dims_str = op2_dims.str (); (*current_liboctave_error_with_id_handler) (err_id, "%s: nonconformant arguments (op1 is %s, op2 is %s)", op, op1_dims_str.c_str (), op2_dims_str.c_str ()); } void gripe_del_index_out_of_range (bool is1d, octave_idx_type idx, octave_idx_type ext) { const char *err_id = error_id_index_out_of_bounds; (*current_liboctave_error_with_id_handler) (err_id, "A(%s) = []: index out of bounds; value %d out of bound %d", is1d ? "I" : "..,I,..", idx, ext); } // Common procedures of base class index_exception, thrown whenever an // object is indexed incorrectly, such as by an index that is out of // range, negative, fractional, complex, or of a non-numeric type. std::string index_exception::message (void) const { std::string msg = expression () + "; " + details (); return msg.c_str (); } // Show the expression that caused the error, e.g., "A(-1,_)", // "A(0+1i)", "A(_,3)". Show how many indices come before/after the // offending one, e.g., (<error>), (<error>,_), or (_,<error>,...[x5]...) std::string index_exception::expression (void) const { // FIXME: don't use a fixed size buffer! const int buf_len = 300; char output [buf_len]; char pre [buf_len]; char post [buf_len]; // dim == 0 if position not yet given, or // <static_cast unsigned int>(-1) if explicitly shown to be unknown // both are caught by this condition if (static_cast <unsigned int> (dim-1) > 100000) { // No parentheses are given if the dimension is not known. pre[0] = post[0] = '\0'; } else { if (dim < 5) { pre[0] = '('; octave_idx_type i; for (i = 1; i < dim; i++) { pre[2*i-1] = '_'; pre[2*i] = ','; } pre[2*i-1] = '\0'; // i == min (1, dim) } else { sprintf (pre, "(...[x%d]...", dim-1); } if (static_cast <unsigned int> (nd-dim) < 5) { for (octave_idx_type i = 0; i < nd-dim; i++) { post[2*i] = ','; post[2*i+1] = '_'; } if (nd >= dim) { post[2*(nd-dim)] = ')'; post[2*(nd-dim)+1] = '\0'; } } else sprintf (post, "...[x%d]...)", nd-dim); } const char *v; if (var[0] == '\0' || var == "<unknown>") v = "index "; else v = var.c_str (); std::string tmp_idx = idx (); snprintf (output, buf_len, "%s%s%s%s", v, pre, tmp_idx.c_str (), post); return output; } class invalid_index : public index_exception { public: invalid_index (const std::string& value, octave_idx_type ndim, octave_idx_type dimen) : index_exception (value, ndim, dimen) { } std::string details (void) const { #ifdef USE_64_BIT_IDX_T return "subscripts must be either integers 1 to (2^63)-1 or logicals"; #else return "subscripts must be either integers 1 to (2^31)-1 or logicals"; #endif } // ID of error to throw const char *err_id (void) const { return error_id_invalid_index; } }; // Complain if an index is negative, fractional, or too big. void gripe_invalid_index (const std::string& idx, octave_idx_type nd, octave_idx_type dim, const std::string&) { invalid_index e (idx, nd, dim); throw e; } void gripe_invalid_index (octave_idx_type n, octave_idx_type nd, octave_idx_type dim, const std::string& var) { // Note: log10 (2^63) = 19 digits. char buf[64]; sprintf (buf, "%d", n+1); gripe_invalid_index (buf, nd, dim, var); } void gripe_invalid_index (double n, octave_idx_type nd, octave_idx_type dim, const std::string& var) { char buf[64]; sprintf (buf, "%g", n+1); gripe_invalid_index (buf, nd, dim, var); } // Gripe and exception for read access beyond the bounds of an array. class out_of_range : public index_exception { public: out_of_range (const std::string& value, octave_idx_type nd_in, octave_idx_type dim_in) : index_exception (value, nd_in, dim_in), extent (0) { } std::string details (void) const { std::string expl; if (nd >= size.length ()) // if not an index slice { if (var != "") expl = "but " + var + " has size "; else expl = "but object has size "; expl = expl + size.str ('x'); } else { char buf[64]; sprintf (buf, "%d", extent); expl = "out of bound " + std::string (buf); } return expl; } // ID of error to throw. const char *err_id (void) const { return error_id_index_out_of_bounds; } void set_size (const dim_vector& size_in) { size = size_in; } void set_extent (octave_idx_type ext) { extent = ext; } private: dim_vector size; // dimension of object being accessed octave_idx_type extent; // length of dimension being accessed }; // Complain of an index that is out of range, but we don't know matrix size void gripe_index_out_of_range (int nd, int dim, octave_idx_type idx, octave_idx_type ext) { char buf[64]; sprintf (buf, "%d", idx); out_of_range e (buf, nd, dim); e.set_extent (ext); dim_vector d (1,1,1,1,1,1,1); // make explain give extent not size e.set_size (d); throw e; } // Complain of an index that is out of range void gripe_index_out_of_range (int nd, int dim, octave_idx_type idx, octave_idx_type ext, const dim_vector& d) { char buf[64]; sprintf (buf, "%d", idx); out_of_range e (buf, nd, dim); e.set_extent (ext); e.set_size (d); throw e; } void gripe_invalid_resize (void) { (*current_liboctave_error_with_id_handler) ("Octave:invalid-resize", "Invalid resizing operation or ambiguous assignment to an out-of-bounds array element"); } void gripe_singular_matrix (double rcond) { if (rcond == 0.0) { (*current_liboctave_warning_with_id_handler) (warning_id_singular_matrix, "matrix singular to machine precision"); } else { (*current_liboctave_warning_with_id_handler) (warning_id_nearly_singular_matrix, "matrix singular to machine precision, rcond = %g", rcond); } } /* Tests in test/index.tst */