octave: libinterp/octave-value/ov-base.cc annotate

annotate libinterp/octave-value/ov-base.cc @ 30139:c789e728d57a

Backed out changeset 938794bc82b7 Renaming octave_base_value::count to m_count breaks some packages that define new octave_value data types. Maybe those packages shouldn't be touching the count directly, but they do. Since we may also want to switch to using std::shared_ptr to manage octave_value objects instead of our own custom reference counting implmentation, it is probably best to delay this change until we know exactly what path we want to take.

author	John W. Eaton <jwe@octave.org>
date	Wed, 08 Sep 2021 11:14:44 -0400
parents	938794bc82b7
children	870687a59e96

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 //
29358 0a5b15007766 update Octave Project Developers copyright for the new year John W. Eaton <jwe@octave.org> parents: 28427 diff changeset	3 // Copyright (C) 1996-2021 The Octave Project Developers
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	4 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	7 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	9 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	14 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	19 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ////////////////////////////////////////////////////////////////////////
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	25
21724 aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef" John W. Eaton <jwe@octave.org> parents: 21660 diff changeset	26 #if defined (HAVE_CONFIG_H)
21301 40de9f8f23a6 Use '#include "config.h"' rather than <config.h>. Rik <rik@octave.org> parents: 21200 diff changeset	27 # include "config.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	28 #endif
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	29
25438 cb1606f78f6b prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible John W. Eaton <jwe@octave.org> parents: 25337 diff changeset	30 #include <istream>
15215 9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	31 #include <limits>
25438 cb1606f78f6b prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible John W. Eaton <jwe@octave.org> parents: 25337 diff changeset	32 #include <ostream>
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	33
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	34 #include "lo-ieee.h"
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4700 diff changeset	35 #include "lo-mappers.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	36
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	37 #include "defun.h"
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	38 #include "errwarn.h"
23553 14723784b9f2 don't use singleton for call_stack John W. Eaton <jwe@octave.org> parents: 23502 diff changeset	39 #include "interpreter-private.h"
14723784b9f2 don't use singleton for call_stack John W. Eaton <jwe@octave.org> parents: 23502 diff changeset	40 #include "interpreter.h"
15149 62a35ae7d6a2 use forward decls for mxArray in ov.h and ov-base.h John W. Eaton <jwe@octave.org> parents: 15057 diff changeset	41 #include "mxarray.h"
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	42 #include "oct-hdf5.h"
2979 a3556d2adec9 [project @ 1997-05-15 22:35:37 by jwe] jwe parents: 2974 diff changeset	43 #include "oct-lvalue.h"
23553 14723784b9f2 don't use singleton for call_stack John W. Eaton <jwe@octave.org> parents: 23502 diff changeset	44 #include "oct-map.h"
3340 585a8809fd9b [project @ 1999-11-05 07:02:30 by jwe] jwe parents: 3219 diff changeset	45 #include "oct-stream.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	46 #include "ops.h"
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	47 #include "ov-base.h"
3928 e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	48 #include "ov-cell.h"
e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	49 #include "ov-ch-mat.h"
23881 5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	50 #include "ov-classdef.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	51 #include "ov-complex.h"
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	52 #include "ov-cx-mat.h"
23553 14723784b9f2 don't use singleton for call_stack John W. Eaton <jwe@octave.org> parents: 23502 diff changeset	53 #include "ov-fcn-handle.h"
3928 e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	54 #include "ov-range.h"
e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	55 #include "ov-re-mat.h"
e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	56 #include "ov-scalar.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	57 #include "ov-str-mat.h"
23553 14723784b9f2 don't use singleton for call_stack John W. Eaton <jwe@octave.org> parents: 23502 diff changeset	58 #include "ovl.h"
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	59 #include "parse.h"
24668 d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	60 #include "pr-flt-fmt.h"
13112 969ed305dde5 Remove all blank lines with "format compact" Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 12820 diff changeset	61 #include "pr-output.h"
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	62 #include "utils.h"
2948 56be458e237f [project @ 1997-05-09 13:37:35 by jwe] jwe parents: 2901 diff changeset	63 #include "variables.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	64
9790 a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	65 builtin_type_t btyp_mixed_numeric (builtin_type_t x, builtin_type_t y)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	66 {
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	67 builtin_type_t retval = btyp_unknown;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	68
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	69 if (x == btyp_bool)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	70 x = btyp_double;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	71 if (y == btyp_bool)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	72 y = btyp_double;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	73
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	74 if (x <= btyp_float_complex && y <= btyp_float_complex)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	75 retval = static_cast<builtin_type_t> (x \| y);
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	76 else if (x <= btyp_uint64 && y <= btyp_float)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	77 retval = x;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	78 else if (x <= btyp_float && y <= btyp_uint64)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	79 retval = y;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	80 else if ((x >= btyp_int8 && x <= btyp_int64
9790 a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	81 && y >= btyp_int8 && y <= btyp_int64)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	82 \|\| (x >= btyp_uint8 && x <= btyp_uint64
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	83 && y >= btyp_uint8 && y <= btyp_uint64))
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	84 retval = (x > y) ? x : y;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	85
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	86 return retval;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	87 }
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax Jaroslav Hajek <highegg@gmail.com> parents: 9753 diff changeset	88
28632 6aa0808d2ed6 also provide builtin type to class traits John W. Eaton <jwe@octave.org> parents: 28444 diff changeset	89 std::string btyp_class_name[btyp_num_types+1] =
10087 090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	90 {
090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	91 "double", "single", "double", "single",
090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	92 "int8", "int16", "int32", "int64",
090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	93 "uint8", "uint16", "uint32", "uint64",
090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	94 "logical", "char",
28632 6aa0808d2ed6 also provide builtin type to class traits John W. Eaton <jwe@octave.org> parents: 28444 diff changeset	95 "struct", "cell", "function_handle", "unknown"
10087 090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	96 };
090173f2db40 improve overload dispatching of built-in classes Jaroslav Hajek <highegg@gmail.com> parents: 10075 diff changeset	97
4612 d44675070f1a [project @ 2003-11-14 19:49:56 by jwe] jwe parents: 4604 diff changeset	98 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_base_value,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	99 "<unknown type>", "unknown");
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	100
7193 cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	101 // TRUE means to perform automatic sparse to real mutation if there
cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	102 // is memory to be saved
cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	103 bool Vsparse_auto_mutate = false;
cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	104
10544 9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	105 octave_base_value *
9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	106 octave_base_value::empty_clone (void) const
9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	107 {
9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	108 return resize (dim_vector ()).clone ();
9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	109 }
9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	110
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	111 octave_value
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	112 octave_base_value::squeeze (void) const
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	113 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	114 std::string nm = type_name ();
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	115 error ("squeeze: invalid operation for %s type", nm.c_str ());
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	116 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	117
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4507 diff changeset	118 octave_value
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	119 octave_base_value::full_value (void) const
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	120 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	121 err_wrong_type_arg ("full: invalid operation for %s type", type_name ());
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	122 }
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	123
22296 8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	124 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	125 octave_base_value::as_double (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	126 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	127 err_invalid_conversion (type_name (), "double");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	128 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	129
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	130 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	131 octave_base_value::as_single (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	132 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	133 err_invalid_conversion (type_name (), "single");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	134 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	135
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	136 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	137 octave_base_value::as_int8 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	138 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	139 err_invalid_conversion (type_name (), "int8");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	140 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	141
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	142 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	143 octave_base_value::as_int16 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	144 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	145 err_invalid_conversion (type_name (), "int16");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	146 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	147
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	148 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	149 octave_base_value::as_int32 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	150 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	151 err_invalid_conversion (type_name (), "int32");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	152 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	153
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	154 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	155 octave_base_value::as_int64 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	156 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	157 err_invalid_conversion (type_name (), "int64");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	158 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	159
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	160 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	161 octave_base_value::as_uint8 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	162 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	163 err_invalid_conversion (type_name (), "uint8");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	164 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	165
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	166 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	167 octave_base_value::as_uint16 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	168 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	169 err_invalid_conversion (type_name (), "uint16");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	170 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	171
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	172 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	173 octave_base_value::as_uint32 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	174 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	175 err_invalid_conversion (type_name (), "uint32");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	176 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	177
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	178 octave_value
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	179 octave_base_value::as_uint64 (void) const
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	180 {
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	181 err_invalid_conversion (type_name (), "uint64");
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	182 }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	183
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	184 Matrix
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	185 octave_base_value::size (void)
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	186 {
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	187 const dim_vector dv = dims ();
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21301 diff changeset	188 Matrix mdv (1, dv.ndims ());
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21301 diff changeset	189 for (octave_idx_type i = 0; i < dv.ndims (); i++)
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	190 mdv(i) = dv(i);
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	191 return mdv;
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	192 }
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	193
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	194 octave_idx_type
26922 072d0610cc56 avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26527 diff changeset	195 octave_base_value::xnumel (const octave_value_list& idx)
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	196 {
25646 4d565baa475e move libinterp/utils functions inside octave namespace John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	197 return octave::dims_to_numel (dims (), idx);
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	198 }
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9286 diff changeset	199
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	200 octave_value
4247 fc9a075d10fb [project @ 2002-12-30 23:05:27 by jwe] jwe parents: 4219 diff changeset	201 octave_base_value::subsref (const std::string&,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	202 const std::list<octave_value_list>&)
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	203 {
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	204 std::string nm = type_name ();
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	205 error ("can't perform indexing operations for %s type", nm.c_str ());
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	206 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	207
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	208 octave_value_list
4247 fc9a075d10fb [project @ 2002-12-30 23:05:27 by jwe] jwe parents: 4219 diff changeset	209 octave_base_value::subsref (const std::string&,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	210 const std::list<octave_value_list>&, int)
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	211 {
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	212 std::string nm = type_name ();
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	213 error ("can't perform indexing operations for %s type", nm.c_str ());
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	214 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	215
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	216 octave_value
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	217 octave_base_value::subsref (const std::string& type,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	218 const std::list<octave_value_list>& idx,
8677 095ae5e0a831 eliminte some compiler warnings John W. Eaton <jwe@octave.org> parents: 8658 diff changeset	219 bool /* auto_add */)
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	220 {
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	221 // This way we may get a more meaningful error message.
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	222 return subsref (type, idx);
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	223 }
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	224
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	225 octave_value
5885 bd3041e30d97 [project @ 2006-07-14 20:29:35 by jwe] jwe parents: 5874 diff changeset	226 octave_base_value::do_index_op (const octave_value_list&, bool)
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	227 {
3523 b80bbb43a1a9 [project @ 2000-02-02 10:25:52 by jwe] jwe parents: 3503 diff changeset	228 std::string nm = type_name ();
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	229 error ("can't perform indexing operations for %s type", nm.c_str ());
ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	230 }
ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	231
29569 29a1f8fd8ee6 move idx_vector classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 29359 diff changeset	232 octave::idx_vector
18130 e473c4853afc enable non-integer ranges as indices by default and deprecate preference John W. Eaton <jwe@octave.org> parents: 17787 diff changeset	233 octave_base_value::index_vector (bool /* require_integers */) const
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	234 {
23807 336f89b6208b Use character literals 'c' rather than string literals "c" when possible. Rik <rik@octave.org> parents: 23795 diff changeset	235 std::string nm = '<' + type_name () + '>';
22327 d0562b3159c7 move more classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22323 diff changeset	236 octave::err_invalid_index (nm.c_str ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	237 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	238
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	239 octave_value
4247 fc9a075d10fb [project @ 2002-12-30 23:05:27 by jwe] jwe parents: 4219 diff changeset	240 octave_base_value::subsasgn (const std::string& type,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	241 const std::list<octave_value_list>& idx,
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	242 const octave_value& rhs)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	243 {
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	244 octave_value retval;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	245
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	246 if (is_defined ())
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	247 {
23586 f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23577 diff changeset	248 if (! isnumeric ())
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	249 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	250 std::string nm = type_name ();
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	251 error ("can't perform indexed assignment for %s type", nm.c_str ());
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	252 }
20978 a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	253
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	254 switch (type[0])
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	255 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	256 case '(':
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	257 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	258 if (type.length () == 1)
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	259 retval = numeric_assign (type, idx, rhs);
23577 80c42f4cca13 maint: Deprecate is_empty and replace with isempty. Rik <rik@octave.org> parents: 23553 diff changeset	260 else if (isempty ())
20978 a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	261 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	262 // Allow conversion of empty matrix to some other
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	263 // type in cases like
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	264 //
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	265 // x = []; x(i).f = rhs
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	266
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	267 octave_value tmp = octave_value::empty_conv (type, rhs);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	268
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	269 retval = tmp.subsasgn (type, idx, rhs);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	270 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	271 else
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	272 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	273 std::string nm = type_name ();
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	274 error ("in indexed assignment of %s, last rhs index must be ()",
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	275 nm.c_str ());
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	276 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	277 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	278 break;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	279
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	280 case '{':
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	281 case '.':
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	282 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	283 std::string nm = type_name ();
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	284 error ("%s cannot be indexed with %c", nm.c_str (), type[0]);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	285 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	286 break;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	287
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	288 default:
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	289 panic_impossible ();
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	290 }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	291 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	292 else
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	293 {
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	294 // Create new object of appropriate type for given index and rhs
12171 d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	295 // types and then call undef_subsasgn for that object.
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	296
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	297 octave_value tmp = octave_value::empty_conv (type, rhs);
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	298
12171 d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	299 retval = tmp.undef_subsasgn (type, idx, rhs);
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	300 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	301
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	302 return retval;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	303 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	304
12171 d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	305 octave_value
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	306 octave_base_value::undef_subsasgn (const std::string& type,
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	307 const std::list<octave_value_list>& idx,
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	308 const octave_value& rhs)
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	309 {
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	310 // In most cases, undef_subsasgn is handled the sams as subsasgn. One
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	311 // exception is octave_class objects.
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	312
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	313 return subsasgn (type, idx, rhs);
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	314 }
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	315
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5353 diff changeset	316 octave_idx_type
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5353 diff changeset	317 octave_base_value::nnz (void) const
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5353 diff changeset	318 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	319 err_wrong_type_arg ("octave_base_value::nnz ()", type_name ());
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5353 diff changeset	320 }
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5353 diff changeset	321
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	322 octave_idx_type
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	323 octave_base_value::nzmax (void) const
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	324 {
10513 c5005bc2b7a9 implement working spalloc Jaroslav Hajek <highegg@gmail.com> parents: 10414 diff changeset	325 return numel ();
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	326 }
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	327
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	328 octave_idx_type
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	329 octave_base_value::nfields (void) const
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	330 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	331 err_wrong_type_arg ("octave_base_value::nfields ()", type_name ());
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	332 }
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	333
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	334 octave_value
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4550 diff changeset	335 octave_base_value::reshape (const dim_vector&) const
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4550 diff changeset	336 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	337 err_wrong_type_arg ("octave_base_value::reshape ()", type_name ());
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4550 diff changeset	338 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4550 diff changeset	339
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4550 diff changeset	340 octave_value
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4580 diff changeset	341 octave_base_value::permute (const Array<int>&, bool) const
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4580 diff changeset	342 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	343 err_wrong_type_arg ("octave_base_value::permute ()", type_name ());
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4580 diff changeset	344 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4580 diff changeset	345
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4580 diff changeset	346 octave_value
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5715 diff changeset	347 octave_base_value::resize (const dim_vector&, bool) const
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4910 diff changeset	348 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	349 err_wrong_type_arg ("octave_base_value::resize ()", type_name ());
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4910 diff changeset	350 }
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4910 diff changeset	351
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	352 MatrixType
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	353 octave_base_value::matrix_type (void) const
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	354 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	355 err_wrong_type_arg ("octave_base_value::matrix_type ()", type_name ());
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	356 }
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	357
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	358 MatrixType
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	359 octave_base_value::matrix_type (const MatrixType&) const
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	360 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	361 err_wrong_type_arg ("octave_base_value::matrix_type ()", type_name ());
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	362 }
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	363
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4910 diff changeset	364 octave_value
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	365 octave_base_value::all (int) const
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	366 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	367 return 0.0;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	368 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	369
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	370 octave_value
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	371 octave_base_value::any (int) const
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	372 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	373 return 0.0;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	374 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	375
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	376 octave_value
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	377 octave_base_value::convert_to_str (bool pad, bool force, char type) const
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	378 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	379 octave_value retval = convert_to_str_internal (pad, force, type);
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	380
23586 f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23577 diff changeset	381 if (! force && isnumeric ())
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	382 warn_implicit_conversion ("Octave:num-to-str",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	383 type_name (), retval.type_name ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	384
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	385 return retval;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	386 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	387
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	388 octave_value
5279 bd32f770c09a [project @ 2005-04-12 21:55:31 by jwe] jwe parents: 5164 diff changeset	389 octave_base_value::convert_to_str_internal (bool, bool, char) const
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	390 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	391 err_wrong_type_arg ("octave_base_value::convert_to_str_internal ()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	392 type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	393 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	394
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	395 void
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	396 octave_base_value::convert_to_row_or_column_vector (void)
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	397 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	398 err_wrong_type_arg
21024 6176560b03d9 maint: Remove return stmts after gripe function calls. Rik <rik@octave.org> parents: 21013 diff changeset	399 ("octave_base_value::convert_to_row_or_column_vector ()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	400 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	401
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	402 void
18416 bcd71a2531d3 Support disp/display overloading in classdef Michael Goffioul <michael.goffioul@gmail.com> parents: 18316 diff changeset	403 octave_base_value::print (std::ostream&, bool)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	404 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	405 err_wrong_type_arg ("octave_base_value::print ()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	406 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	407
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	408 void
3523 b80bbb43a1a9 [project @ 2000-02-02 10:25:52 by jwe] jwe parents: 3503 diff changeset	409 octave_base_value::print_raw (std::ostream&, bool) const
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	410 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	411 err_wrong_type_arg ("octave_base_value::print_raw ()", type_name ());
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	412 }
e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	413
e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	414 bool
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	415 octave_base_value::print_name_tag (std::ostream& os,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	416 const std::string& name) const
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	417 {
e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	418 indent (os);
4604 cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	419
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	420 if (print_as_scalar ())
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	421 os << name << " = ";
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	422 else
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	423 {
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	424 os << name << " =";
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	425 newline (os);
13112 969ed305dde5 Remove all blank lines with "format compact" Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 12820 diff changeset	426 if (! Vcompact_format)
969ed305dde5 Remove all blank lines with "format compact" Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 12820 diff changeset	427 newline (os);
969ed305dde5 Remove all blank lines with "format compact" Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 12820 diff changeset	428
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	429 return true;
4604 cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	430 }
cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	431
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	432 return false;
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	433 }
e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2882 diff changeset	434
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	435 void
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	436 octave_base_value::print_with_name (std::ostream& output_buf,
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	437 const std::string& name,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	438 bool print_padding)
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	439 {
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: 8551 diff changeset	440 bool pad_after = print_name_tag (output_buf, name);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	441
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: 8551 diff changeset	442 print (output_buf);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	443
20792 d0991cbd6141 maint: Remove extra spaces in if () conditionals. Rik <rik@octave.org> parents: 20785 diff changeset	444 if (print_padding && pad_after && ! Vcompact_format)
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: 8551 diff changeset	445 newline (output_buf);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	446 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	447
24668 d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	448 float_display_format
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	449 octave_base_value::get_edit_display_format (void) const
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	450 {
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	451 return float_display_format ();
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	452 }
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24620 diff changeset	453
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	454 void
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	455 octave_base_value::print_info (std::ostream& os,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	456 const std::string& /* prefix */) const
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	457 {
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	458 os << "no info for type: " << type_name () << "\n";
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	459 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	460
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	461 #define INT_CONV_METHOD(T, F) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	462 T \
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4247 diff changeset	463 octave_base_value::F ## _value (bool require_int, bool frc_str_conv) const \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	464 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	465 T retval = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	466 \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	467 double d = 0.0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	468 \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	469 try \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	470 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	471 d = double_value (frc_str_conv); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	472 } \
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28646 diff changeset	473 catch (octave::execution_exception& ee) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	474 { \
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28646 diff changeset	475 err_wrong_type_arg (ee, "octave_base_value::" #F "_value ()", type_name ()); \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	476 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	477 \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	478 if (require_int && octave::math::x_nint (d) != d) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	479 error_with_cfn ("conversion of %g to " #T " value failed", d); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	480 else if (d < std::numeric_limits<T>::min ()) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	481 retval = std::numeric_limits<T>::min (); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	482 else if (d > std::numeric_limits<T>::max ()) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	483 retval = std::numeric_limits<T>::max (); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	484 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	485 retval = static_cast<T> (octave::math::fix (d)); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	486 \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22094 diff changeset	487 return retval; \
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4247 diff changeset	488 }
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	489
15215 9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	490 INT_CONV_METHOD (short int, short)
9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	491 INT_CONV_METHOD (unsigned short int, ushort)
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	492
15215 9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	493 INT_CONV_METHOD (int, int)
9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	494 INT_CONV_METHOD (unsigned int, uint)
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	495
15215 9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	496 INT_CONV_METHOD (long int, long)
9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	497 INT_CONV_METHOD (unsigned long int, ulong)
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	498
16323 e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 15696 diff changeset	499 INT_CONV_METHOD (int64_t, int64)
e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 15696 diff changeset	500 INT_CONV_METHOD (uint64_t, uint64)
e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 15696 diff changeset	501
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	502 int
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	503 octave_base_value::nint_value (bool frc_str_conv) const
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	504 {
20747 ee2743bd07a8 eliminate various compiler warnings John W. Eaton <jwe@octave.org> parents: 20741 diff changeset	505 double d = 0.0;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	506
20741 a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	507 try
a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	508 {
a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	509 d = double_value (frc_str_conv);
a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	510 }
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28646 diff changeset	511 catch (octave::execution_exception& ee)
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	512 {
29163 8f67ad8b3103 maint: Updating naming conventions for exceptions and use const where possible. Rik <rik@octave.org> parents: 28646 diff changeset	513 err_wrong_type_arg (ee, "octave_base_value::nint_value ()", type_name ());
20741 a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	514 }
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	515
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21739 diff changeset	516 if (octave::math::isnan (d))
20741 a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	517 error ("conversion of NaN to integer value failed");
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	518
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21739 diff changeset	519 return static_cast<int> (octave::math::fix (d));
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	520 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	521
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	522 double
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	523 octave_base_value::double_value (bool) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	524 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	525 err_wrong_type_arg ("octave_base_value::double_value ()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	526 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	527
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	528 float
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	529 octave_base_value::float_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	530 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	531 err_wrong_type_arg ("octave_base_value::float_value ()", type_name ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	532 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	533
3351 8623649c967c [project @ 1999-11-15 16:17:01 by jwe] jwe parents: 3340 diff changeset	534 Cell
3539 ea583bc68959 [project @ 2000-02-02 12:48:09 by jwe] jwe parents: 3536 diff changeset	535 octave_base_value::cell_value () const
3351 8623649c967c [project @ 1999-11-15 16:17:01 by jwe] jwe parents: 3340 diff changeset	536 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	537 err_wrong_type_arg ("octave_base_value::cell_value()", type_name ());
3351 8623649c967c [project @ 1999-11-15 16:17:01 by jwe] jwe parents: 3340 diff changeset	538 }
8623649c967c [project @ 1999-11-15 16:17:01 by jwe] jwe parents: 3340 diff changeset	539
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	540 Matrix
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	541 octave_base_value::matrix_value (bool) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	542 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	543 err_wrong_type_arg ("octave_base_value::matrix_value()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	544 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	545
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	546 FloatMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	547 octave_base_value::float_matrix_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	548 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	549 err_wrong_type_arg ("octave_base_value::float_matrix_value()", type_name ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	550 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	551
4507 65f47f8a92a2 [project @ 2003-09-10 15:48:02 by jwe] jwe parents: 4505 diff changeset	552 NDArray
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	553 octave_base_value::array_value (bool) const
4505 e944fbe3fff2 [project @ 2003-09-09 19:14:06 by jwe] jwe parents: 4457 diff changeset	554 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	555 err_wrong_type_arg ("octave_base_value::array_value()", type_name ());
4505 e944fbe3fff2 [project @ 2003-09-09 19:14:06 by jwe] jwe parents: 4457 diff changeset	556 }
e944fbe3fff2 [project @ 2003-09-09 19:14:06 by jwe] jwe parents: 4457 diff changeset	557
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	558 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	559 octave_base_value::float_array_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	560 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	561 err_wrong_type_arg ("octave_base_value::float_array_value()", type_name ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	562 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	563
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	564 Complex
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	565 octave_base_value::complex_value (bool) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	566 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	567 err_wrong_type_arg ("octave_base_value::complex_value()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	568 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	569
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	570 FloatComplex
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	571 octave_base_value::float_complex_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	572 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	573 err_wrong_type_arg ("octave_base_value::float_complex_value()", type_name ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	574 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	575
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	576 ComplexMatrix
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	577 octave_base_value::complex_matrix_value (bool) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	578 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	579 err_wrong_type_arg ("octave_base_value::complex_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	580 type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	581 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	582
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	583 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	584 octave_base_value::float_complex_matrix_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	585 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	586 err_wrong_type_arg ("octave_base_value::float_complex_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	587 type_name ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	588 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	589
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	590 ComplexNDArray
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	591 octave_base_value::complex_array_value (bool) const
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	592 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	593 err_wrong_type_arg ("octave_base_value::complex_array_value()", type_name ());
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	594 }
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	595
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	596 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	597 octave_base_value::float_complex_array_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	598 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	599 err_wrong_type_arg ("octave_base_value::float_complex_array_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	600 type_name ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	601 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	602
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	603 bool
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	604 octave_base_value::bool_value (bool) const
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	605 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	606 err_wrong_type_arg ("octave_base_value::bool_value()", type_name ());
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	607 }
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	608
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	609 boolMatrix
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	610 octave_base_value::bool_matrix_value (bool) const
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	611 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	612 err_wrong_type_arg ("octave_base_value::bool_matrix_value()", type_name ());
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	613 }
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	614
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	615 boolNDArray
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	616 octave_base_value::bool_array_value (bool) const
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	617 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	618 err_wrong_type_arg ("octave_base_value::bool_array_value()", type_name ());
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	619 }
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	620
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	621 charMatrix
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4732 diff changeset	622 octave_base_value::char_matrix_value (bool force) const
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	623 {
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4732 diff changeset	624 octave_value tmp = convert_to_str (false, force);
4257 e556870ce8f0 [project @ 2003-01-02 03:14:41 by jwe] jwe parents: 4254 diff changeset	625
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	626 return tmp.char_matrix_value ();
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	627 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	628
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	629 charNDArray
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	630 octave_base_value::char_array_value (bool) const
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	631 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	632 err_wrong_type_arg ("octave_base_value::char_array_value()", type_name ());
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	633 }
69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	634
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	635 SparseMatrix
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	636 octave_base_value::sparse_matrix_value (bool) const
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	637 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	638 err_wrong_type_arg ("octave_base_value::sparse_matrix_value()", type_name ());
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	639 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	640
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	641 SparseComplexMatrix
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	642 octave_base_value::sparse_complex_matrix_value (bool) const
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	643 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	644 err_wrong_type_arg ("octave_base_value::sparse_complex_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	645 type_name ());
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	646 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	647
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	648 SparseBoolMatrix
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	649 octave_base_value::sparse_bool_matrix_value (bool) const
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	650 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	651 err_wrong_type_arg ("octave_base_value::sparse_bool_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	652 type_name ());
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	653 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5105 diff changeset	654
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	655 DiagMatrix
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	656 octave_base_value::diag_matrix_value (bool) const
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	657 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	658 err_wrong_type_arg ("octave_base_value::diag_matrix_value()", type_name ());
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	659 }
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	660
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	661 FloatDiagMatrix
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	662 octave_base_value::float_diag_matrix_value (bool) const
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	663 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	664 err_wrong_type_arg ("octave_base_value::float_diag_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	665 type_name ());
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	666 }
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	667
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	668 ComplexDiagMatrix
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	669 octave_base_value::complex_diag_matrix_value (bool) const
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	670 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	671 err_wrong_type_arg ("octave_base_value::complex_diag_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	672 type_name ());
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	673 }
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	674
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	675 FloatComplexDiagMatrix
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	676 octave_base_value::float_complex_diag_matrix_value (bool) const
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	677 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	678 err_wrong_type_arg ("octave_base_value::float_complex_diag_matrix_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	679 type_name ());
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	680 }
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	681
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	682 PermMatrix
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	683 octave_base_value::perm_matrix_value (void) const
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	684 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	685 err_wrong_type_arg ("octave_base_value::perm_matrix_value()", type_name ());
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	686 }
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	687
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	688 octave_int8
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	689 octave_base_value::int8_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	690 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	691 err_wrong_type_arg ("octave_base_value::int8_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	692 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	693
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	694 octave_int16
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	695 octave_base_value::int16_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	696 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	697 err_wrong_type_arg ("octave_base_value::int16_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	698 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	699
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	700 octave_int32
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	701 octave_base_value::int32_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	702 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	703 err_wrong_type_arg ("octave_base_value::int32_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	704 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	705
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	706 octave_int64
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	707 octave_base_value::int64_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	708 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	709 err_wrong_type_arg ("octave_base_value::int64_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	710 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	711
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	712 octave_uint8
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	713 octave_base_value::uint8_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	714 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	715 err_wrong_type_arg ("octave_base_value::uint8_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	716 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	717
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	718 octave_uint16
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	719 octave_base_value::uint16_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	720 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	721 err_wrong_type_arg ("octave_base_value::uint16_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	722 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	723
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	724 octave_uint32
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	725 octave_base_value::uint32_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	726 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	727 err_wrong_type_arg ("octave_base_value::uint32_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	728 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	729
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	730 octave_uint64
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	731 octave_base_value::uint64_scalar_value (void) const
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	732 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	733 err_wrong_type_arg ("octave_base_value::uint64_scalar_value()", type_name ());
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	734 }
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	735
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	736 int8NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	737 octave_base_value::int8_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	738 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	739 err_wrong_type_arg ("octave_base_value::int8_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	740 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	741
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	742 int16NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	743 octave_base_value::int16_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	744 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	745 err_wrong_type_arg ("octave_base_value::int16_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	746 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	747
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	748 int32NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	749 octave_base_value::int32_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	750 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	751 err_wrong_type_arg ("octave_base_value::int32_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	752 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	753
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	754 int64NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	755 octave_base_value::int64_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	756 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	757 err_wrong_type_arg ("octave_base_value::int64_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	758 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	759
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	760 uint8NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	761 octave_base_value::uint8_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	762 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	763 err_wrong_type_arg ("octave_base_value::uint8_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	764 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	765
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	766 uint16NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	767 octave_base_value::uint16_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	768 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	769 err_wrong_type_arg ("octave_base_value::uint16_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	770 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	771
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	772 uint32NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	773 octave_base_value::uint32_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	774 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	775 err_wrong_type_arg ("octave_base_value::uint32_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	776 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	777
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	778 uint64NDArray
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	779 octave_base_value::uint64_array_value (void) const
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	780 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	781 err_wrong_type_arg ("octave_base_value::uint64_array_value()", type_name ());
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	782 }
6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4741 diff changeset	783
2493 8ed4362aa0d6 [project @ 1996-11-11 02:35:04 by jwe] jwe parents: 2466 diff changeset	784 string_vector
20990 fc9cca99b2de Deprecate all_strings, replace with string_vector_value. Rik <rik@octave.org> parents: 20978 diff changeset	785 octave_base_value::string_vector_value (bool pad) const
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	786 {
5715 edf82d02be75 [project @ 2006-03-24 16:42:43 by jwe] jwe parents: 5707 diff changeset	787 octave_value tmp = convert_to_str (pad, true);
4257 e556870ce8f0 [project @ 2003-01-02 03:14:41 by jwe] jwe parents: 4254 diff changeset	788
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	789 return tmp.string_vector_value ();
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	790 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	791
3536 e8fbc8c3d6d9 [project @ 2000-02-02 12:01:00 by jwe] jwe parents: 3534 diff changeset	792 std::string
4457 d7d9ca19960a [project @ 2003-07-11 03:05:38 by jwe] jwe parents: 4452 diff changeset	793 octave_base_value::string_value (bool force) const
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	794 {
4457 d7d9ca19960a [project @ 2003-07-11 03:05:38 by jwe] jwe parents: 4452 diff changeset	795 octave_value tmp = convert_to_str (force);
4257 e556870ce8f0 [project @ 2003-01-02 03:14:41 by jwe] jwe parents: 4254 diff changeset	796
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	797 return tmp.string_value ();
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	798 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	799
20576 40ed9b46a800 new octave_value::string_value method with optional error message John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	800 std::string
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	801 octave_base_value::xstring_value (void) const
20576 40ed9b46a800 new octave_value::string_value method with optional error message John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	802 {
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	803 wrong_type_arg_error ();
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	804
8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	805 return std::string ();
20576 40ed9b46a800 new octave_value::string_value method with optional error message John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	806 }
40ed9b46a800 new octave_value::string_value method with optional error message John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	807
8732 a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	808 Array<std::string>
a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	809 octave_base_value::cellstr_value (void) const
a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	810 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	811 err_wrong_type_arg ("octave_base_value::cellstr_value()", type_name ());
8732 a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	812 }
a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	813
28646 e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	814 octave::range<float>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	815 octave_base_value::float_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	816 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	817 err_wrong_type_arg ("octave_base_value::float_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	818 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	819
28638 98192ec1621f replace Range with range<double> John W. Eaton <jwe@octave.org> parents: 28632 diff changeset	820 octave::range<double>
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	821 octave_base_value::range_value (void) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	822 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	823 err_wrong_type_arg ("octave_base_value::range_value()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	824 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	825
28646 e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	826 octave::range<octave_int8>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	827 octave_base_value::int8_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	828 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	829 err_wrong_type_arg ("octave_base_value::int8_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	830 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	831
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	832 octave::range<octave_int16>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	833 octave_base_value::int16_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	834 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	835 err_wrong_type_arg ("octave_base_value::int16_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	836 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	837
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	838 octave::range<octave_int32>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	839 octave_base_value::int32_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	840 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	841 err_wrong_type_arg ("octave_base_value::int32_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	842 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	843
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	844 octave::range<octave_int64>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	845 octave_base_value::int64_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	846 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	847 err_wrong_type_arg ("octave_base_value::int64_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	848 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	849
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	850 octave::range<octave_uint8>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	851 octave_base_value::uint8_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	852 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	853 err_wrong_type_arg ("octave_base_value::uint8_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	854 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	855
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	856 octave::range<octave_uint16>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	857 octave_base_value::uint16_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	858 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	859 err_wrong_type_arg ("octave_base_value::uint16_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	860 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	861
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	862 octave::range<octave_uint32>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	863 octave_base_value::uint32_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	864 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	865 err_wrong_type_arg ("octave_base_value::uint32_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	866 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	867
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	868 octave::range<octave_uint64>
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	869 octave_base_value::uint64_range_value (void) const
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	870 {
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	871 err_wrong_type_arg ("octave_base_value::uint64_range_value()", type_name ());
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	872 }
e26201931ea3 new template class for octave_range objects John W. Eaton <jwe@octave.org> parents: 28638 diff changeset	873
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	874 octave_map
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	875 octave_base_value::map_value (void) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	876 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	877 err_wrong_type_arg ("octave_base_value::map_value()", type_name ());
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	878 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	879
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	880 octave_scalar_map
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	881 octave_base_value::scalar_map_value (void) const
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	882 {
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	883 octave_map tmp = map_value ();
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	884
20879 5357423bca0a Code Sprint 2015: remove return/break/goto after error Andreas Weber <andy.weber.aw@gmail.com> parents: 20853 diff changeset	885 if (tmp.numel () != 1)
20678 4b00afb5e9c3 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20666 diff changeset	886 error ("invalid conversion of multi-dimensional struct to scalar struct");
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	887
20879 5357423bca0a Code Sprint 2015: remove return/break/goto after error Andreas Weber <andy.weber.aw@gmail.com> parents: 20853 diff changeset	888 return octave_scalar_map (tmp.checkelem (0));
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	889 }
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	890
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	891 string_vector
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	892 octave_base_value::map_keys (void) const
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	893 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	894 err_wrong_type_arg ("octave_base_value::map_keys()", type_name ());
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	895 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	896
29654 d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	897 std::size_t
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	898 octave_base_value::nparents (void) const
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	899 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	900 err_wrong_type_arg ("octave_base_value::nparents()", type_name ());
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	901 }
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	902
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	903 std::list<std::string>
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	904 octave_base_value::parent_class_name_list (void) const
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	905 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	906 err_wrong_type_arg ("octave_base_value::parent_class_name_list()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	907 type_name ());
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	908 }
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	909
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	910 string_vector
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	911 octave_base_value::parent_class_names (void) const
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	912 {
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	913 err_wrong_type_arg ("octave_base_value::parent_class_names()", type_name ());
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	914 }
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9064 diff changeset	915
23881 5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	916 octave_classdef *
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	917 octave_base_value::classdef_object_value (bool silent)
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	918 {
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	919 if (! silent)
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	920 err_wrong_type_arg ("octave_base_value::classdef_object_value()",
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	921 type_name ());
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	922
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	923 return nullptr;
23881 5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	924 }
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23807 diff changeset	925
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	926 octave_function *
ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	927 octave_base_value::function_value (bool silent)
ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	928 {
ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	929 if (! silent)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	930 err_wrong_type_arg ("octave_base_value::function_value()", type_name ());
228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	931
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	932 return nullptr;
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	933 }
ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2962 diff changeset	934
4700 ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	935 octave_user_function *
ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	936 octave_base_value::user_function_value (bool silent)
ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	937 {
ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	938 if (! silent)
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	939 err_wrong_type_arg ("octave_base_value::user_function_value()",
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	940 type_name ());
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	941 return nullptr;
4700 ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	942 }
ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	943
7719 87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	944 octave_user_script *
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	945 octave_base_value::user_script_value (bool silent)
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	946 {
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	947 if (! silent)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	948 err_wrong_type_arg ("octave_base_value::user_script_value()", type_name ());
228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	949
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	950 return nullptr;
7719 87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	951 }
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	952
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	953 octave_user_code *
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	954 octave_base_value::user_code_value (bool silent)
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	955 {
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	956 if (! silent)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	957 err_wrong_type_arg ("octave_base_value::user_code_value()", type_name ());
228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	958
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	959 return nullptr;
7719 87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	960 }
87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	961
4346 d39de791ef9c [project @ 2003-02-20 21:38:39 by jwe] jwe parents: 4343 diff changeset	962 octave_fcn_handle *
4343 db5e0814277a [project @ 2003-02-20 16:44:16 by jwe] jwe parents: 4257 diff changeset	963 octave_base_value::fcn_handle_value (bool silent)
db5e0814277a [project @ 2003-02-20 16:44:16 by jwe] jwe parents: 4257 diff changeset	964 {
db5e0814277a [project @ 2003-02-20 16:44:16 by jwe] jwe parents: 4257 diff changeset	965 if (! silent)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	966 err_wrong_type_arg ("octave_base_value::fcn_handle_value()", type_name ());
228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21118 diff changeset	967
23882 8e61b91f2e24 * ov-base.cc: Eliminate unecessary uses of retval. John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	968 return nullptr;
4343 db5e0814277a [project @ 2003-02-20 16:44:16 by jwe] jwe parents: 4257 diff changeset	969 }
db5e0814277a [project @ 2003-02-20 16:44:16 by jwe] jwe parents: 4257 diff changeset	970
2882 05926e1b367d [project @ 1997-04-24 09:48:59 by jwe] jwe parents: 2847 diff changeset	971 octave_value_list
05926e1b367d [project @ 1997-04-24 09:48:59 by jwe] jwe parents: 2847 diff changeset	972 octave_base_value::list_value (void) const
05926e1b367d [project @ 1997-04-24 09:48:59 by jwe] jwe parents: 2847 diff changeset	973 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	974 err_wrong_type_arg ("octave_base_value::list_value()", type_name ());
2882 05926e1b367d [project @ 1997-04-24 09:48:59 by jwe] jwe parents: 2847 diff changeset	975 }
05926e1b367d [project @ 1997-04-24 09:48:59 by jwe] jwe parents: 2847 diff changeset	976
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	977 bool
6974 9e32bb109980 [project @ 2007-10-08 11:06:47 by jwe] jwe parents: 5958 diff changeset	978 octave_base_value::save_ascii (std::ostream&)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	979 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	980 err_wrong_type_arg ("octave_base_value::save_ascii()", type_name ());
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	981 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	982
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	983 bool
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	984 octave_base_value::load_ascii (std::istream&)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	985 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	986 err_wrong_type_arg ("octave_base_value::load_ascii()", type_name ());
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	987 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	988
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	989 bool
26399 586413770c7f pass save_as_floats by value in octave_value save_binary functions John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	990 octave_base_value::save_binary (std::ostream&, bool)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	991 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	992 err_wrong_type_arg ("octave_base_value::save_binary()", type_name ());
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	993 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	994
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	995 bool
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	996 octave_base_value::load_binary (std::istream&, bool,
21739 c4ab2e54f100 use namespace for oct_mach_info class John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	997 octave::mach_info::float_format)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	998 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	999 err_wrong_type_arg ("octave_base_value::load_binary()", type_name ());
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1000 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1001
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1002 bool
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1003 octave_base_value::save_hdf5 (octave_hdf5_id, const char *, bool)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1004 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1005 err_wrong_type_arg ("octave_base_value::save_binary()", type_name ());
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1006 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1007
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1008 bool
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1009 octave_base_value::load_hdf5 (octave_hdf5_id, const char *)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1010 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1011 err_wrong_type_arg ("octave_base_value::load_binary()", type_name ());
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4661 diff changeset	1012 }
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4933 diff changeset	1013
44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4933 diff changeset	1014 int
23059 b98ebcd7f11c move some octave stream classes into octave namespace John W. Eaton <jwe@octave.org> parents: 23052 diff changeset	1015 octave_base_value::write (octave::stream&, int, oct_data_conv::data_type,
21739 c4ab2e54f100 use namespace for oct_mach_info class John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	1016 int, octave::mach_info::float_format) const
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4933 diff changeset	1017 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1018 err_wrong_type_arg ("octave_base_value::write()", type_name ());
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4933 diff changeset	1019 }
44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4933 diff changeset	1020
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	1021 mxArray *
28126 4c21f99b4ad5 handle interleaved complex data and new typed data access functions for mex John W. Eaton <jwe@octave.org> parents: 27923 diff changeset	1022 octave_base_value::as_mxArray (bool) const
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	1023 {
23795 980f39c3ab90 Use C++11 nullptr rather than 0 in code (bug #51565). Rik <rik@octave.org> parents: 23718 diff changeset	1024 return nullptr;
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	1025 }
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5897 diff changeset	1026
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1027 octave_value
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7528 diff changeset	1028 octave_base_value::diag (octave_idx_type) const
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7528 diff changeset	1029 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1030 err_wrong_type_arg ("octave_base_value::diag ()", type_name ());
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7528 diff changeset	1031 }
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7528 diff changeset	1032
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7528 diff changeset	1033 octave_value
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14429 diff changeset	1034 octave_base_value::diag (octave_idx_type, octave_idx_type) const
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14429 diff changeset	1035 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1036 err_wrong_type_arg ("octave_base_value::diag ()", type_name ());
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14429 diff changeset	1037 }
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14429 diff changeset	1038
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14429 diff changeset	1039 octave_value
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1040 octave_base_value::sort (octave_idx_type, sortmode) const
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1041 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1042 err_wrong_type_arg ("octave_base_value::sort ()", type_name ());
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1043 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1044
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1045 octave_value
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1046 octave_base_value::sort (Array<octave_idx_type> &,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1047 octave_idx_type, sortmode) const
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1048 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1049 err_wrong_type_arg ("octave_base_value::sort ()", type_name ());
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1050 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1051
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1052 sortmode
23588 0549061d35b9 maint: Deprecate is_sorted and replace with issorted. Rik <rik@octave.org> parents: 23586 diff changeset	1053 octave_base_value::issorted (sortmode) const
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1054 {
23588 0549061d35b9 maint: Deprecate is_sorted and replace with issorted. Rik <rik@octave.org> parents: 23586 diff changeset	1055 err_wrong_type_arg ("octave_base_value::issorted ()", type_name ());
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1056 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1057
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1058 Array<octave_idx_type>
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8732 diff changeset	1059 octave_base_value::sort_rows_idx (sortmode) const
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1060 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1061 err_wrong_type_arg ("octave_base_value::sort_rows_idx ()", type_name ());
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1062 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1063
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1064 sortmode
8734 767ed8cc6634 rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows John W. Eaton <jwe@octave.org> parents: 8733 diff changeset	1065 octave_base_value::is_sorted_rows (sortmode) const
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1066 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1067 err_wrong_type_arg ("octave_base_value::is_sorted_rows ()", type_name ());
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1068 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8677 diff changeset	1069
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1070 const char *
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1071 octave_base_value::get_umap_name (unary_mapper_t umap)
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1072 {
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1073 static const char *names[num_unary_mappers] =
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1074 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1075 "abs",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1076 "acos",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1077 "acosh",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1078 "angle",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1079 "arg",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1080 "asin",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1081 "asinh",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1082 "atan",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1083 "atanh",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1084 "cbrt",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1085 "ceil",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1086 "conj",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1087 "cos",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1088 "cosh",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1089 "erf",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1090 "erfinv",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1091 "erfcinv",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1092 "erfc",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1093 "erfcx",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1094 "erfi",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1095 "dawson",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1096 "exp",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1097 "expm1",
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 20990 diff changeset	1098 "isfinite",
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1099 "fix",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1100 "floor",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1101 "gamma",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1102 "imag",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1103 "isinf",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1104 "isna",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1105 "isnan",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1106 "lgamma",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1107 "log",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1108 "log2",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1109 "log10",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1110 "log1p",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1111 "real",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1112 "round",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1113 "roundb",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1114 "signum",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1115 "sin",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1116 "sinh",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1117 "sqrt",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1118 "tan",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1119 "tanh",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1120 "isalnum",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1121 "isalpha",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1122 "isascii",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1123 "iscntrl",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1124 "isdigit",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1125 "isgraph",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1126 "islower",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1127 "isprint",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1128 "ispunct",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1129 "isspace",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1130 "isupper",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1131 "isxdigit",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1132 "signbit",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1133 "tolower",
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1134 "toupper"
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1135 };
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7489 diff changeset	1136
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1137 if (umap < 0 \|\| umap >= num_unary_mappers)
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1138 return "unknown";
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1139 else
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1140 return names[umap];
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1141 }
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7489 diff changeset	1142
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1143 void
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1144 octave_base_value::warn_load (const char *type) const
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1145 {
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1146 warning_with_id
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1147 ("Octave:load-save-unavailable",
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1148 "%s: loading %s files not available in this version of Octave",
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1149 t_name.c_str (), type);
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1150 }
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1151
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1152 void
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1153 octave_base_value::warn_save (const char *type) const
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1154 {
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1155 warning_with_id
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1156 ("Octave:load-save-unavailable",
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1157 "%s: saving %s files not available in this version of Octave",
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1158 t_name.c_str (), type);
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1159 }
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19697 diff changeset	1160
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	1161 void
68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	1162 octave_base_value::wrong_type_arg_error (void) const
68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	1163 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1164 err_wrong_type_arg (type_name ());
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	1165 }
68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20681 diff changeset	1166
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1167 octave_value
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1168 octave_base_value::map (unary_mapper_t umap) const
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1169 {
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1170 error ("%s: not defined for %s", get_umap_name (umap), type_name ().c_str ());
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9790 diff changeset	1171 }
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7489 diff changeset	1172
7489 8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1173 void
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1174 octave_base_value::lock (void)
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1175 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1176 err_wrong_type_arg ("octave_base_value::lock ()", type_name ());
7489 8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1177 }
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1178
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1179 void
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1180 octave_base_value::unlock (void)
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1181 {
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21040 diff changeset	1182 err_wrong_type_arg ("octave_base_value::unlock ()", type_name ());
7489 8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1183 }
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1184
23680 ef71711f6d64 rework __dump_symbol_table__ function John W. Eaton <jwe@octave.org> parents: 23588 diff changeset	1185 octave_value
ef71711f6d64 rework __dump_symbol_table__ function John W. Eaton <jwe@octave.org> parents: 23588 diff changeset	1186 octave_base_value::dump (void) const
7761 5adeea5de26c symbol table reporting functions John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1187 {
23680 ef71711f6d64 rework __dump_symbol_table__ function John W. Eaton <jwe@octave.org> parents: 23588 diff changeset	1188 std::map<std::string, octave_value> m
23718 251cb33c6570 style fixes for initializer lists John W. Eaton <jwe@octave.org> parents: 23716 diff changeset	1189 = {{ "class", this->class_name () },
251cb33c6570 style fixes for initializer lists John W. Eaton <jwe@octave.org> parents: 23716 diff changeset	1190 { "type", this->type_name () },
251cb33c6570 style fixes for initializer lists John W. Eaton <jwe@octave.org> parents: 23716 diff changeset	1191 { "dims", this->dims().as_array () }};
7761 5adeea5de26c symbol table reporting functions John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1192
23680 ef71711f6d64 rework __dump_symbol_table__ function John W. Eaton <jwe@octave.org> parents: 23588 diff changeset	1193 return octave_value (m);
7761 5adeea5de26c symbol table reporting functions John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1194 }
5adeea5de26c symbol table reporting functions John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1195
21040 3e7cfee5f786 maint: Rename attributes GCC_ATTR_XXX to OCTAVE_XXX. Rik <rik@octave.org> parents: 21029 diff changeset	1196 OCTAVE_NORETURN static
21029 e3b3bb522d62 maint: Move GCC_ attributes to start of declaration for future compatibility. Rik <rik@octave.org> parents: 21024 diff changeset	1197 void
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1198 err_indexed_assignment (const std::string& tn1, const std::string& tn2)
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1199 {
15466 d174210ce1ec use ' instead of ` in error messages, warnings and most comments John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1200 error ("assignment of '%s' to indexed '%s' not implemented",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1201 tn2.c_str (), tn1.c_str ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1202 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1203
21040 3e7cfee5f786 maint: Rename attributes GCC_ATTR_XXX to OCTAVE_XXX. Rik <rik@octave.org> parents: 21029 diff changeset	1204 OCTAVE_NORETURN static
21029 e3b3bb522d62 maint: Move GCC_ attributes to start of declaration for future compatibility. Rik <rik@octave.org> parents: 21024 diff changeset	1205 void
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1206 err_assign_conversion_failed (const std::string& tn1, const std::string& tn2)
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1207 {
15466 d174210ce1ec use ' instead of ` in error messages, warnings and most comments John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1208 error ("type conversion for assignment of '%s' to indexed '%s' failed",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1209 tn2.c_str (), tn1.c_str ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1210 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1211
21040 3e7cfee5f786 maint: Rename attributes GCC_ATTR_XXX to OCTAVE_XXX. Rik <rik@octave.org> parents: 21029 diff changeset	1212 OCTAVE_NORETURN static
21029 e3b3bb522d62 maint: Move GCC_ attributes to start of declaration for future compatibility. Rik <rik@octave.org> parents: 21024 diff changeset	1213 void
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1214 err_no_conversion (const std::string& on, const std::string& tn1,
dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1215 const std::string& tn2)
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1216 {
15466 d174210ce1ec use ' instead of ` in error messages, warnings and most comments John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1217 error ("operator %s: no conversion for assignment of '%s' to indexed '%s'",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1218 on.c_str (), tn2.c_str (), tn1.c_str ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1219 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1220
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1221 octave_value
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1222 octave_base_value::numeric_assign (const std::string& type,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1223 const std::list<octave_value_list>& idx,
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1224 const octave_value& rhs)
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1225 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1226 octave_value retval;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1227
9286 c2248cc4821a don't crash on assignments like a() = 1 Jaroslav Hajek <highegg@gmail.com> parents: 9151 diff changeset	1228 if (idx.front ().empty ())
20879 5357423bca0a Code Sprint 2015: remove return/break/goto after error Andreas Weber <andy.weber.aw@gmail.com> parents: 20853 diff changeset	1229 error ("missing index in indexed assignment");
9286 c2248cc4821a don't crash on assignments like a() = 1 Jaroslav Hajek <highegg@gmail.com> parents: 9151 diff changeset	1230
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1231 int t_lhs = type_id ();
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1232 int t_rhs = rhs.type_id ();
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1233
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1234 octave::type_info& ti
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1235 = octave::__get_type_info__ ("octave_base_value::numeric_assign");
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1236
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1237 octave::type_info::assign_op_fcn f
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1238 = ti.lookup_assign_op (octave_value::op_asn_eq, t_lhs, t_rhs);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1239
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1240 bool done = false;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1241
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1242 if (f)
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1243 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1244 f (*this, idx.front (), rhs.get_rep ());
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1245
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	1246 done = true;
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1247 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1248
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1249 if (done)
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1250 {
30139 c789e728d57a Backed out changeset 938794bc82b7 John W. Eaton <jwe@octave.org> parents: 30133 diff changeset	1251 count++;
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1252 retval = octave_value (this);
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1253 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1254 else
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1255 {
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1256 int t_result = ti.lookup_pref_assign_conv (t_lhs, t_rhs);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1257
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1258 if (t_result >= 0)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1259 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1260 octave_base_value::type_conv_fcn cf
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1261 = ti.lookup_widening_op (t_lhs, t_result);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1262
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1263 if (! cf)
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1264 err_indexed_assignment (type_name (), rhs.type_name ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1265
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1266 octave_base_value tmp = cf (this);
5874 210c5c98c403 [project @ 2006-07-01 02:33:45 by jwe] jwe parents: 5851 diff changeset	1267
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1268 if (! tmp)
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1269 err_assign_conversion_failed (type_name (), rhs.type_name ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1270
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1271 octave_value val (tmp);
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1272
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1273 retval = val.subsasgn (type, idx, rhs);
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1274
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1275 done = true;
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1276 }
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1277
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20542 diff changeset	1278 if (! done)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1279 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1280 octave_value tmp_rhs;
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1281
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1282 octave_base_value::type_conv_info cf_rhs
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1283 = rhs.numeric_conversion_function ();
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1284
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1285 octave_base_value::type_conv_info cf_this
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1286 = numeric_conversion_function ();
8345 c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 7885 diff changeset	1287
c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 7885 diff changeset	1288 // Try biased (one-sided) conversions first.
c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 7885 diff changeset	1289 if (cf_rhs.type_id () >= 0
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1290 && (ti.lookup_assign_op (octave_value::op_asn_eq,
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1291 t_lhs, cf_rhs.type_id ())
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1292 \|\| ti.lookup_pref_assign_conv (t_lhs,
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1293 cf_rhs.type_id ()) >= 0))
23795 980f39c3ab90 Use C++11 nullptr rather than 0 in code (bug #51565). Rik <rik@octave.org> parents: 23718 diff changeset	1294 cf_this = nullptr;
8345 c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 7885 diff changeset	1295 else if (cf_this.type_id () >= 0
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1296 && (ti.lookup_assign_op (octave_value::op_asn_eq,
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1297 cf_this.type_id (), t_rhs)
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1298 \|\| ti.lookup_pref_assign_conv (cf_this.type_id (),
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1299 t_rhs) >= 0))
23795 980f39c3ab90 Use C++11 nullptr rather than 0 in code (bug #51565). Rik <rik@octave.org> parents: 23718 diff changeset	1300 cf_rhs = nullptr;
8345 c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 7885 diff changeset	1301
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1302 if (cf_rhs)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1303 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1304 octave_base_value *tmp = cf_rhs (rhs.get_rep ());
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1305
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1306 if (! tmp)
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1307 err_assign_conversion_failed (type_name (), rhs.type_name ());
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1308
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1309 tmp_rhs = octave_value (tmp);
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1310 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1311 else
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1312 tmp_rhs = rhs;
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1313
30139 c789e728d57a Backed out changeset 938794bc82b7 John W. Eaton <jwe@octave.org> parents: 30133 diff changeset	1314 count++;
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1315 octave_value tmp_lhs = octave_value (this);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1316
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1317 if (cf_this)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1318 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1319 octave_base_value tmp = cf_this (this);
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1320
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1321 if (! tmp)
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1322 err_assign_conversion_failed (type_name (), rhs.type_name ());
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1323
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1324 tmp_lhs = octave_value (tmp);
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1325 }
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1326
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1327 if (! cf_this && ! cf_rhs)
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1328 err_no_conversion (octave_value::assign_op_as_string
dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1329 (octave_value::op_asn_eq),
dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1330 type_name (), rhs.type_name ());
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1331
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1332 retval = tmp_lhs.subsasgn (type, idx, tmp_rhs);
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1333
3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21102 diff changeset	1334 done = true;
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10232 diff changeset	1335 }
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1336 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1337
21102 dfcb9d74b253 Rename local gripe_XXX functions to err_XXX or warn_XXX. Rik <rik@octave.org> parents: 21100 diff changeset	1338 // The assignment may have converted to a type that is wider than necessary.
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1339
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1340 retval.maybe_mutate ();
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1341
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1342 return retval;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1343 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1344
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1345 // Current indentation.
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1346 int octave_base_value::curr_print_indent_level = 0;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1347
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1348 // TRUE means we are at the beginning of a line.
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1349 bool octave_base_value::beginning_of_line = true;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1350
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1351 // Each print() function should call this before printing anything.
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1352 //
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1353 // This doesn't need to be fast, but isn't there a better way?
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1354
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1355 void
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1356 octave_base_value::indent (std::ostream& os) const
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1357 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1358 assert (curr_print_indent_level >= 0);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1359
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1360 if (beginning_of_line)
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1361 {
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1362 // FIXME: do we need this?
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1363 // os << prefix;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1364
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1365 for (int i = 0; i < curr_print_indent_level; i++)
23807 336f89b6208b Use character literals 'c' rather than string literals "c" when possible. Rik <rik@octave.org> parents: 23795 diff changeset	1366 os << ' ';
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1367
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1368 beginning_of_line = false;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1369 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1370 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1371
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1372 // All print() functions should use this to print new lines.
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1373
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1374 void
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1375 octave_base_value::newline (std::ostream& os) const
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1376 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1377 os << "\n";
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1378
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1379 beginning_of_line = true;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1380 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1381
21024 6176560b03d9 maint: Remove return stmts after gripe function calls. Rik <rik@octave.org> parents: 21013 diff changeset	1382 // For resetting print state.
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1383
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1384 void
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1385 octave_base_value::reset (void) const
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1386 {
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1387 beginning_of_line = true;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1388 curr_print_indent_level = 0;
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1389 }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5731 diff changeset	1390
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1391 octave_value
10893 61a5ba82cfbb omit some unused named parameters to avoid warning Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1392 octave_base_value::fast_elem_extract (octave_idx_type) const
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1393 {
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1394 return octave_value ();
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1395 }
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1396
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1397 bool
10893 61a5ba82cfbb omit some unused named parameters to avoid warning Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1398 octave_base_value::fast_elem_insert (octave_idx_type, const octave_value&)
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1399 {
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1400 return false;
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1401 }
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1402
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1403 bool
10893 61a5ba82cfbb omit some unused named parameters to avoid warning Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1404 octave_base_value::fast_elem_insert_self (void *, builtin_type_t) const
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1405 {
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1406 return false;
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1407 }
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10652 diff changeset	1408
22296 8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1409 static octave_base_value *
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1410 oct_conv_matrix_conv (const octave_base_value&)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1411 {
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1412 return new octave_matrix ();
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1413 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1414
22296 8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1415 static octave_base_value *
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1416 oct_conv_complex_matrix_conv (const octave_base_value&)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1417 {
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1418 return new octave_complex_matrix ();
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1419 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1420
22296 8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1421 static octave_base_value *
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1422 oct_conv_string_conv (const octave_base_value&)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1423 {
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1424 return new octave_char_matrix_str ();
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1425 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1426
22296 8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1427 static octave_base_value *
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	1428 oct_conv_cell_conv (const octave_base_value&)
3928 e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	1429 {
e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	1430 return new octave_cell ();
e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	1431 }
e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3544 diff changeset	1432
18314 06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1433 static inline octave_value_list
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1434 sanitize (const octave_value_list& ovl)
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1435 {
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1436 octave_value_list retval = ovl;
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1437
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1438 for (octave_idx_type i = 0; i < ovl.length (); i++)
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1439 {
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1440 if (retval(i).is_magic_colon ())
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1441 retval(i) = ":";
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1442 }
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1443
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1444 return retval;
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1445 }
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1446
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1447 octave_value
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1448 make_idx_args (const std::string& type,
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1449 const std::list<octave_value_list>& idx,
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1450 const std::string& who)
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1451 {
29654 d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	1452 std::size_t len = type.length ();
18314 06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1453
20978 a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1454 if (len != idx.size ())
18314 06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1455 error ("invalid index for %s", who.c_str ());
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1456
20978 a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1457 Cell type_field (1, len);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1458 Cell subs_field (1, len);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1459
25337 3ff9192b676e use auto keyword to declare iterator variables where possible John W. Eaton <jwe@octave.org> parents: 25103 diff changeset	1460 auto p = idx.begin ();
20978 a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1461
29654 d13d090cb03a use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	1462 for (std::size_t i = 0; i < len; i++)
20978 a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1463 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1464 char t = type[i];
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1465
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1466 switch (t)
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1467 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1468 case '(':
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1469 type_field(i) = "()";
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1470 subs_field(i) = Cell (sanitize (*p++));
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1471 break;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1472
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1473 case '{':
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1474 type_field(i) = "{}";
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1475 subs_field(i) = Cell (sanitize (*p++));
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1476 break;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1477
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1478 case '.':
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1479 {
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1480 type_field(i) = ".";
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1481
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1482 octave_value_list vlist = *p++;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1483
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1484 if (vlist.length () != 1)
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1485 error ("only single argument permitted for '.' index");
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1486
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1487 octave_value val = vlist(0);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1488
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1489 if (! val.is_string ())
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1490 error ("string argument required for '.' index");
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1491
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1492 subs_field(i) = val;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1493 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1494 break;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1495
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1496 default:
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1497 panic_impossible ();
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1498 break;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1499 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1500 }
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1501
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1502 octave_map m;
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1503
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1504 m.assign ("type", type_field);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1505 m.assign ("subs", subs_field);
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1506
a5b500efca9f maint: invert if/else/error instances. John W. Eaton <jwe@octave.org> parents: 20940 diff changeset	1507 return m;
18314 06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1508 }
06eb893b9db6 Implement subsref overloading in classdef. Michael Goffioul <michael.goffioul@gmail.com> parents: 18130 diff changeset	1509
26525 0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1510 bool
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1511 called_from_builtin (void)
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1512 {
27209 ac92aa74fa1a eliminate some direct access to call stack in gui and octave_base_value John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1513 octave::tree_evaluator& tw
ac92aa74fa1a eliminate some direct access to call stack in gui and octave_base_value John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1514 = octave::__get_evaluator__ ("called_from_builtin");
26525 0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1515
27209 ac92aa74fa1a eliminate some direct access to call stack in gui and octave_base_value John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1516 octave_function *fcn = tw.caller_function ();
26525 0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1517
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1518 // FIXME: we probably need a better check here, or some other
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1519 // mechanism to avoid overloaded functions when builtin is used.
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1520 // For example, what if someone overloads the builtin function?
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1521 // Also, are there other places where using builtin is not properly
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1522 // avoiding dispatch?
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1523
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1524 return (fcn && fcn->name () == "builtin");
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1525 }
0d3eca5955dc Backed out changeset 920a4ad8043b (bug #54995) John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	1526
29989 b260322f6730 move xdiv, xnorm, and xpow inside octave namespace John W. Eaton <jwe@octave.org> parents: 29958 diff changeset	1527 OCTAVE_NAMESPACE_BEGIN
b260322f6730 move xdiv, xnorm, and xpow inside octave namespace John W. Eaton <jwe@octave.org> parents: 29958 diff changeset	1528
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1529 void
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1530 install_base_type_conversions (octave::type_info& ti)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1531 {
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1532 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_scalar, octave_matrix);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1533 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_matrix, octave_matrix);
25103 078b795c5219 maint: style check C++ ahead of 4.4 release. Rik <rik@octave.org> parents: 25054 diff changeset	1534 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_complex,
078b795c5219 maint: style check C++ ahead of 4.4 release. Rik <rik@octave.org> parents: 25054 diff changeset	1535 octave_complex_matrix);
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1536 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_complex_matrix,
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1537 octave_complex_matrix);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1538 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_range, octave_matrix);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1539 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_char_matrix_str,
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1540 octave_char_matrix_str);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1541 INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_cell, octave_cell);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1542
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1543 INSTALL_WIDENOP_TI (ti, octave_base_value, octave_matrix, matrix_conv);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1544 INSTALL_WIDENOP_TI (ti, octave_base_value, octave_complex_matrix,
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1545 complex_matrix_conv);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1546 INSTALL_WIDENOP_TI (ti, octave_base_value, octave_char_matrix_str, string_conv);
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1547 INSTALL_WIDENOP_TI (ti, octave_base_value, octave_cell, cell_conv);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1548 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1549
7193 cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	1550 DEFUN (sparse_auto_mutate, args, nargout,
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1551 doc: /* -- texinfo --
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1552 @deftypefn {} {@var{val} =} sparse_auto_mutate ()
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1553 @deftypefnx {} {@var{old_val} =} sparse_auto_mutate (@var{new_val})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1554 @deftypefnx {} {} sparse_auto_mutate (@var{new_val}, "local")
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1555 Query or set the internal variable that controls whether Octave will
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1556 automatically mutate sparse matrices to full matrices to save memory.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1557
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1558 For example:
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1559
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1560 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1561 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1562 s = speye (3);
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1563 sparse_auto_mutate (false);
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1564 s(:, 1) = 1;
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1565 typeinfo (s)
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1566 @result{} sparse matrix
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1567 sparse_auto_mutate (true);
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1568 s(1, :) = 1;
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1569 typeinfo (s)
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1570 @result{} matrix
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1571 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1572 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1573
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1574 When called from inside a function with the @qcode{"local"} option, the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1575 variable is changed locally for the function and any subroutines it calls.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1576 The original variable value is restored when exiting the function.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21782 diff changeset	1577 @end deftypefn */)
7193 cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	1578 {
30001 428cccc75cc9 move most functions in variables.cc to octave namespace John W. Eaton <jwe@octave.org> parents: 29989 diff changeset	1579 return set_internal_variable (Vsparse_auto_mutate, args, nargout,
428cccc75cc9 move most functions in variables.cc to octave namespace John W. Eaton <jwe@octave.org> parents: 29989 diff changeset	1580 "sparse_auto_mutate");
7193 cbdee3da62bd [project @ 2007-11-26 22:20:25 by dbateman] dbateman parents: 7017 diff changeset	1581 }
12820 efd924e19ff7 codesprint: Add tests for sparse_auto_mutate() Rik <octave@nomad.inbox5.com> parents: 12483 diff changeset	1582
efd924e19ff7 codesprint: Add tests for sparse_auto_mutate() Rik <octave@nomad.inbox5.com> parents: 12483 diff changeset	1583 /*
efd924e19ff7 codesprint: Add tests for sparse_auto_mutate() Rik <octave@nomad.inbox5.com> parents: 12483 diff changeset	1584 %!test
14429 eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1585 %! s = speye (3);
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1586 %! sparse_auto_mutate (false);
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1587 %! s(:, 1) = 1;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1588 %! assert (typeinfo (s), "sparse matrix");
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1589 %! sparse_auto_mutate (true);
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1590 %! s(1, :) = 1;
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1591 %! assert (typeinfo (s), "matrix");
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	1592 %! sparse_auto_mutate (false);
12820 efd924e19ff7 codesprint: Add tests for sparse_auto_mutate() Rik <octave@nomad.inbox5.com> parents: 12483 diff changeset	1593 */
29958 32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace John W. Eaton <jwe@octave.org> parents: 29655 diff changeset	1594
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace John W. Eaton <jwe@octave.org> parents: 29655 diff changeset	1595 OCTAVE_NAMESPACE_END

Mercurial > octave

annotate libinterp/octave-value/ov-base.cc @ 30139:c789e728d57a