# HG changeset patch # User Jaroslav Hajek # Date 1272014623 -7200 # Node ID 9961fc022d9dab62bb1e5b48c00865abf53f6892 # Parent f41c6634d5af73dfa40510a2c1e2f5064d6e4e63 fix assignment to non-existing variables and octave_value::assign diff -r f41c6634d5af -r 9961fc022d9d src/ChangeLog --- a/src/ChangeLog Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ChangeLog Fri Apr 23 11:23:43 2010 +0200 @@ -1,3 +1,23 @@ +2010-04-23 Jaroslav Hajek + + * ov-bool.h (octave_bool::empty_clone): Correctly return an empty + matrix. + * ov-float.h (octave_float::empty_clone): Ditto. + * ov-base-mat.h (octave_base_matrix::clone, + octave_base_matrix::empty_clone): Remove. + * ov-base-scalar.h (octave_base_scalar::clone, + octave_base_scalar::empty_clone): Remove. + * ov-base-sparse.h (octave_base_sparse::clone, + octave_base_sparse::empty_clone): Remove. + * ov-base.h (octave_base_value::empty_clone): Remove implementation. + * ov-base.cc (octave_base_value::empty_clone): Implement here. + Fall back to resize() for empty_clone(). + * ov.cc (octave_value::assign): Correct behavior in the indexed OP= case. + Use better error messages. Always return non-const reference, like any + assignment. + * ov.h: Update decls. + * oct-lvalue.cc (octave_lvalue::assign): Simplify. + 2010-04-22 Rik * DLD-FUNCTIONS/hess.cc.: return correct Hessenberg matrix when called diff -r f41c6634d5af -r 9961fc022d9d src/oct-lvalue.cc --- a/src/oct-lvalue.cc Fri Apr 23 09:48:57 2010 +0200 +++ b/src/oct-lvalue.cc Fri Apr 23 11:23:43 2010 +0200 @@ -35,12 +35,10 @@ { if (val) { - octave_value tmp (idx.empty () - ? val->assign (op, rhs) - : val->assign (op, type, idx, rhs)); - - if (! error_state) - *val = tmp; + if (idx.empty ()) + val->assign (op, rhs); + else + val->assign (op, type, idx, rhs); } } diff -r f41c6634d5af -r 9961fc022d9d src/ov-base-mat.h --- a/src/ov-base-mat.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-base-mat.h Fri Apr 23 11:23:43 2010 +0200 @@ -70,9 +70,6 @@ ~octave_base_matrix (void) { clear_cached_info (); } - octave_base_value *clone (void) const { return new octave_base_matrix (*this); } - octave_base_value *empty_clone (void) const { return new octave_base_matrix (); } - size_t byte_size (void) const { return matrix.byte_size (); } octave_value squeeze (void) const { return MT (matrix.squeeze ()); } diff -r f41c6634d5af -r 9961fc022d9d src/ov-base-scalar.h --- a/src/ov-base-scalar.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-base-scalar.h Fri Apr 23 11:23:43 2010 +0200 @@ -57,9 +57,6 @@ ~octave_base_scalar (void) { } - octave_base_value *clone (void) const { return new octave_base_scalar (*this); } - octave_base_value *empty_clone (void) const { return new octave_base_scalar (); } - octave_value squeeze (void) const { return scalar; } octave_value full_value (void) const { return scalar; } diff -r f41c6634d5af -r 9961fc022d9d src/ov-base-sparse.h --- a/src/ov-base-sparse.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-base-sparse.h Fri Apr 23 11:23:43 2010 +0200 @@ -72,10 +72,6 @@ ~octave_base_sparse (void) { } - octave_base_value *clone (void) const { return new octave_base_sparse (*this); } - octave_base_value *empty_clone (void) const - { return new octave_base_sparse (); } - octave_idx_type nnz (void) const { return matrix.nnz (); } octave_idx_type nzmax (void) const { return matrix.nzmax (); } diff -r f41c6634d5af -r 9961fc022d9d src/ov-base.cc --- a/src/ov-base.cc Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-base.cc Fri Apr 23 11:23:43 2010 +0200 @@ -115,6 +115,12 @@ // is memory to be saved bool Vsparse_auto_mutate = false; +octave_base_value * +octave_base_value::empty_clone (void) const +{ + return resize (dim_vector ()).clone (); +} + octave_value octave_base_value::squeeze (void) const { diff -r f41c6634d5af -r 9961fc022d9d src/ov-base.h --- a/src/ov-base.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-base.h Fri Apr 23 11:23:43 2010 +0200 @@ -216,7 +216,7 @@ // Empty clone. virtual octave_base_value * - empty_clone (void) const { return new octave_base_value (); } + empty_clone (void) const; // Unique clone. Usually clones, but may be overriden to fake the // cloning when sharing copies is to be controlled from within an diff -r f41c6634d5af -r 9961fc022d9d src/ov-bool.h --- a/src/ov-bool.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-bool.h Fri Apr 23 11:23:43 2010 +0200 @@ -37,6 +37,7 @@ #include "oct-stream.h" #include "ov-base.h" #include "ov-base-scalar.h" +#include "ov-bool-mat.h" #include "ov-scalar.h" #include "ov-typeinfo.h" @@ -65,7 +66,7 @@ ~octave_bool (void) { } octave_base_value *clone (void) const { return new octave_bool (*this); } - octave_base_value *empty_clone (void) const { return new octave_bool (); } + octave_base_value *empty_clone (void) const { return new octave_bool_matrix (); } type_conv_info numeric_conversion_function (void) const; diff -r f41c6634d5af -r 9961fc022d9d src/ov-float.h --- a/src/ov-float.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov-float.h Fri Apr 23 11:23:43 2010 +0200 @@ -72,7 +72,7 @@ // We return an octave_matrix here instead of an octave_float_scalar so // that in expressions like A(2,2,2) = 2 (for A previously // undefined), A will be empty instead of a 1x1 object. - octave_base_value *empty_clone (void) const { return new octave_matrix (); } + octave_base_value *empty_clone (void) const { return new octave_float_matrix (); } octave_value do_index_op (const octave_value_list& idx, bool resize_ok = false); diff -r f41c6634d5af -r 9961fc022d9d src/ov.cc --- a/src/ov.cc Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov.cc Fri Apr 23 11:23:43 2010 +0200 @@ -1271,7 +1271,7 @@ return rep->subsasgn (type, idx, rhs); } -octave_value +octave_value& octave_value::assign (assign_op op, const std::string& type, const std::list& idx, const octave_value& rhs) @@ -1284,15 +1284,20 @@ if (op != op_asn_eq) { - octave_value t = subsref (type, idx); - - if (! error_state) + if (is_defined ()) { - binary_op binop = op_eq_to_binary_op (op); + octave_value t = subsref (type, idx); if (! error_state) - t_rhs = do_binary_op (binop, t, rhs); + { + binary_op binop = op_eq_to_binary_op (op); + + if (! error_state) + t_rhs = do_binary_op (binop, t, rhs); + } } + else + error ("in computed assignment A(index) OP= X, A must be defined first"); } if (! error_state) @@ -1300,26 +1305,26 @@ if (type[0] == '.' && ! (is_map () || is_object ())) { octave_value tmp = Octave_map (); - retval = tmp.subsasgn (type, idx, t_rhs); + *this = tmp.subsasgn (type, idx, t_rhs); } else - retval = subsasgn (type, idx, t_rhs); + *this = subsasgn (type, idx, t_rhs); if (error_state) gripe_assign_failed_or_no_method (assign_op_as_string (op_asn_eq), type_name (), rhs.type_name ()); } - return retval; + return *this; } -const octave_value& +octave_value& octave_value::assign (assign_op op, const octave_value& rhs) { if (op == op_asn_eq) // Regularize a null matrix if stored into a variable. operator = (rhs.storable_value ()); - else + else if (is_defined ()) { octave_value_typeinfo::assign_op_fcn f = 0; @@ -1358,6 +1363,8 @@ } } } + else + error ("in computed assignment A OP= X, A must be defined first"); return *this; } diff -r f41c6634d5af -r 9961fc022d9d src/ov.h --- a/src/ov.h Fri Apr 23 09:48:57 2010 +0200 +++ b/src/ov.h Fri Apr 23 11:23:43 2010 +0200 @@ -411,11 +411,11 @@ const std::list& idx, const octave_value& rhs); - octave_value assign (assign_op op, const std::string& type, + octave_value& assign (assign_op op, const std::string& type, const std::list& idx, const octave_value& rhs); - const octave_value& assign (assign_op, const octave_value& rhs); + octave_value& assign (assign_op, const octave_value& rhs); idx_vector index_vector (void) const { return rep->index_vector (); }