Mercurial > octave
annotate libinterp/octave-value/ov-typeinfo.cc @ 22281:0f9ab4f1f4b3
new function __dump_typeinfo__
* ov-typeinfo.h, ov-typeinfo.cc (F__dump_typeinfo__): New function.
(octave_value_typeinfo::do_installed_type_names): Now const.
(as_bool_nd_array, as_nd_array): New static functions.
(octave_value_typeinfo::unary_ops_map,
octave_value_typeinfo::non_const_unary_ops_map,
octave_value_typeinfo::binary_ops_map,
octave_value_typeinfo::compound_binary_ops_map,
octave_value_typeinfo::assign_ops_map,
octave_value_typeinfo::assignany_ops_map,
octave_value_typeinfo::do_installed_type_info,
octave_value_typeinfo::installed_type_info): New member functions.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Sat, 13 Aug 2016 17:39:29 -0400 |
parents | 112b20240c87 |
children | 8b18f46f6427 |
rev | line source |
---|---|
2376 | 1 /* |
2 | |
19697
4197fc428c7d
maint: Update copyright notices for 2015.
John W. Eaton <jwe@octave.org>
parents:
18533
diff
changeset
|
3 Copyright (C) 1996-2015 John W. Eaton |
2376 | 4 |
5 This file is part of Octave. | |
6 | |
7 Octave is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by the | |
7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
10 option) any later version. | |
2376 | 11 |
12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
7016 | 18 along with Octave; see the file COPYING. If not, see |
19 <http://www.gnu.org/licenses/>. | |
2376 | 20 |
21 */ | |
22 | |
21724
aba2e6293dd8
use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents:
21301
diff
changeset
|
23 #if defined (HAVE_CONFIG_H) |
21301
40de9f8f23a6
Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents:
21200
diff
changeset
|
24 # include "config.h" |
2376 | 25 #endif |
26 | |
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
27 #include "Array.h" |
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
28 #include "singleton-cleanup.h" |
2376 | 29 |
30 #include "defun.h" | |
31 #include "error.h" | |
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
32 #include "ov-typeinfo.h" |
2376 | 33 |
2479 | 34 const int |
35 octave_value_typeinfo::init_tab_sz (16); | |
36 | |
37 octave_value_typeinfo * | |
38 octave_value_typeinfo::instance (0); | |
2376 | 39 |
2926 | 40 bool |
41 octave_value_typeinfo::instance_ok (void) | |
42 { | |
43 bool retval = true; | |
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
44 |
2926 | 45 if (! instance) |
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
46 { |
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
47 instance = new octave_value_typeinfo (); |
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
48 |
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
49 if (instance) |
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
50 singleton_cleanup_list::add (cleanup_instance); |
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
51 } |
2926 | 52 |
53 if (! instance) | |
20956
850e3d2533d4
maint: Eliminate more useless statements after error().
Rik <rik@octave.org>
parents:
20939
diff
changeset
|
54 error ("unable to create value type info object!"); |
2926 | 55 |
56 return retval; | |
57 } | |
58 | |
2376 | 59 int |
4612 | 60 octave_value_typeinfo::register_type (const std::string& t_name, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
61 const std::string& c_name, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
62 const octave_value& val) |
2376 | 63 { |
2926 | 64 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
65 ? instance->do_register_type (t_name, c_name, val) : -1; |
2376 | 66 } |
67 | |
68 bool | |
7336 | 69 octave_value_typeinfo::register_unary_class_op (octave_value::unary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
70 octave_value_typeinfo::unary_class_op_fcn f) |
7336 | 71 { |
72 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
73 ? instance->do_register_unary_class_op (op, f) : false; |
7336 | 74 } |
75 | |
76 bool | |
3203 | 77 octave_value_typeinfo::register_unary_op (octave_value::unary_op op, |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
78 int t, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
79 octave_value_typeinfo::unary_op_fcn f) |
3203 | 80 { |
81 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
82 ? instance->do_register_unary_op (op, t, f) : false; |
3203 | 83 } |
84 | |
85 bool | |
86 octave_value_typeinfo::register_non_const_unary_op (octave_value::unary_op op, | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
87 int t, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
88 octave_value_typeinfo::non_const_unary_op_fcn f) |
3203 | 89 { |
90 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
91 ? instance->do_register_non_const_unary_op (op, t, f) : false; |
3203 | 92 } |
93 | |
94 bool | |
7336 | 95 octave_value_typeinfo::register_binary_class_op (octave_value::binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
96 octave_value_typeinfo::binary_class_op_fcn f) |
7336 | 97 { |
98 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
99 ? instance->do_register_binary_class_op (op, f) : false; |
7336 | 100 } |
101 | |
102 bool | |
2376 | 103 octave_value_typeinfo::register_binary_op (octave_value::binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
104 int t1, int t2, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
105 octave_value_typeinfo::binary_op_fcn f) |
2376 | 106 { |
2926 | 107 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
108 ? instance->do_register_binary_op (op, t1, t2, f) : false; |
2376 | 109 } |
110 | |
111 bool | |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
112 octave_value_typeinfo::register_binary_class_op (octave_value::compound_binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
113 octave_value_typeinfo::binary_class_op_fcn f) |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
114 { |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
115 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
116 ? instance->do_register_binary_class_op (op, f) : false; |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
117 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
118 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
119 bool |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
120 octave_value_typeinfo::register_binary_op (octave_value::compound_binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
121 int t1, int t2, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
122 octave_value_typeinfo::binary_op_fcn f) |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
123 { |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
124 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
125 ? instance->do_register_binary_op (op, t1, t2, f) : false; |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
126 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
127 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
128 bool |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
129 octave_value_typeinfo::register_cat_op (int t1, int t2, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
130 octave_value_typeinfo::cat_op_fcn f) |
4915 | 131 { |
132 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
133 ? instance->do_register_cat_op (t1, t2, f) : false; |
4915 | 134 } |
135 | |
136 bool | |
2882 | 137 octave_value_typeinfo::register_assign_op (octave_value::assign_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
138 int t_lhs, int t_rhs, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
139 octave_value_typeinfo::assign_op_fcn f) |
2376 | 140 { |
2926 | 141 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
142 ? instance->do_register_assign_op (op, t_lhs, t_rhs, f) : -1; |
2376 | 143 } |
144 | |
145 bool | |
3196 | 146 octave_value_typeinfo::register_assignany_op (octave_value::assign_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
147 int t_lhs, octave_value_typeinfo::assignany_op_fcn f) |
3196 | 148 { |
149 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
150 ? instance->do_register_assignany_op (op, t_lhs, f) : -1; |
3196 | 151 } |
152 | |
153 bool | |
2376 | 154 octave_value_typeinfo::register_pref_assign_conv (int t_lhs, int t_rhs, |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
155 int t_result) |
2376 | 156 { |
2926 | 157 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
158 ? instance->do_register_pref_assign_conv (t_lhs, t_rhs, t_result) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
159 : false; |
2376 | 160 } |
161 | |
162 bool | |
4901 | 163 octave_value_typeinfo::register_type_conv_op (int t, int t_result, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
164 octave_base_value::type_conv_fcn f) |
4901 | 165 { |
166 return (instance_ok ()) | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
167 ? instance->do_register_type_conv_op (t, t_result, f) : false; |
4901 | 168 } |
169 | |
170 bool | |
2376 | 171 octave_value_typeinfo::register_widening_op (int t, int t_result, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
172 octave_base_value::type_conv_fcn f) |
2376 | 173 { |
2926 | 174 return (instance_ok ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
175 ? instance->do_register_widening_op (t, t_result, f) : false; |
2376 | 176 } |
177 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
178 // FIXME: we should also store all class names and provide a |
4687 | 179 // way to list them (calling class with nargin == 0?). |
180 | |
2376 | 181 int |
4612 | 182 octave_value_typeinfo::do_register_type (const std::string& t_name, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
183 const std::string& /* c_name */, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
184 const octave_value& val) |
2376 | 185 { |
186 int i = 0; | |
187 | |
188 for (i = 0; i < num_types; i++) | |
4612 | 189 if (t_name == types (i)) |
2376 | 190 return i; |
191 | |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20163
diff
changeset
|
192 int len = types.numel (); |
2376 | 193 |
194 if (i == len) | |
195 { | |
196 len *= 2; | |
197 | |
21017
93748bcaec17
maint: Replace emtpy 'std::string ()' calls with "".
Rik <rik@octave.org>
parents:
20956
diff
changeset
|
198 types.resize (dim_vector (len, 1), ""); |
2376 | 199 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
200 vals.resize (dim_vector (len, 1), octave_value ()); |
4640 | 201 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
202 unary_ops.resize (dim_vector (octave_value::num_unary_ops, len), 0); |
3203 | 203 |
204 non_const_unary_ops.resize | |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
205 (dim_vector (octave_value::num_unary_ops, len), 0); |
3203 | 206 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
207 binary_ops.resize |
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
208 (dim_vector (octave_value::num_binary_ops, len, len), 0); |
2376 | 209 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
210 compound_binary_ops.resize |
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
211 (dim_vector (octave_value::num_compound_binary_ops, len, len), 0); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
212 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
213 cat_ops.resize (dim_vector (len, len), 0); |
4915 | 214 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
215 assign_ops.resize |
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
216 (dim_vector (octave_value::num_assign_ops, len, len), 0); |
2376 | 217 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
218 assignany_ops.resize |
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
219 (dim_vector (octave_value::num_assign_ops, len), 0); |
3196 | 220 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
221 pref_assign_conv.resize (dim_vector (len, len), -1); |
2376 | 222 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
223 type_conv_ops.resize (dim_vector (len, len), 0); |
4901 | 224 |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
225 widening_ops.resize (dim_vector (len, len), 0); |
2376 | 226 } |
227 | |
4612 | 228 types (i) = t_name; |
2376 | 229 |
4640 | 230 vals (i) = val; |
231 | |
2376 | 232 num_types++; |
233 | |
234 return i; | |
235 } | |
236 | |
237 bool | |
7336 | 238 octave_value_typeinfo::do_register_unary_class_op (octave_value::unary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
239 octave_value_typeinfo::unary_class_op_fcn f) |
7336 | 240 { |
241 if (lookup_unary_class_op (op)) | |
242 { | |
243 std::string op_name = octave_value::unary_op_as_string (op); | |
244 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
245 warning ("duplicate unary operator '%s' for class dispatch", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
246 op_name.c_str ()); |
7336 | 247 } |
248 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
249 unary_class_ops.checkelem (static_cast<int> (op)) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
250 = reinterpret_cast<void *> (f); |
7336 | 251 |
252 return false; | |
253 } | |
254 | |
255 bool | |
3203 | 256 octave_value_typeinfo::do_register_unary_op (octave_value::unary_op op, |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
257 int t, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
258 octave_value_typeinfo::unary_op_fcn f) |
3203 | 259 { |
4508 | 260 if (lookup_unary_op (op, t)) |
261 { | |
262 std::string op_name = octave_value::unary_op_as_string (op); | |
263 std::string type_name = types(t); | |
264 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
265 warning ("duplicate unary operator '%s' for type '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
266 op_name.c_str (), type_name.c_str ()); |
4508 | 267 } |
268 | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
269 unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f); |
3203 | 270 |
271 return false; | |
272 } | |
273 | |
274 bool | |
275 octave_value_typeinfo::do_register_non_const_unary_op | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
276 (octave_value::unary_op op, int t, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
277 octave_value_typeinfo::non_const_unary_op_fcn f) |
3203 | 278 { |
4508 | 279 if (lookup_non_const_unary_op (op, t)) |
280 { | |
281 std::string op_name = octave_value::unary_op_as_string (op); | |
282 std::string type_name = types(t); | |
283 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
284 warning ("duplicate unary operator '%s' for type '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
285 op_name.c_str (), type_name.c_str ()); |
4508 | 286 } |
287 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
288 non_const_unary_ops.checkelem (static_cast<int> (op), t) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
289 = reinterpret_cast<void *> (f); |
3203 | 290 |
291 return false; | |
292 } | |
293 | |
294 bool | |
7336 | 295 octave_value_typeinfo::do_register_binary_class_op (octave_value::binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
296 octave_value_typeinfo::binary_class_op_fcn f) |
7336 | 297 { |
298 if (lookup_binary_class_op (op)) | |
299 { | |
300 std::string op_name = octave_value::binary_op_as_string (op); | |
301 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
302 warning ("duplicate binary operator '%s' for class dispatch", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
303 op_name.c_str ()); |
7336 | 304 } |
305 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
306 binary_class_ops.checkelem (static_cast<int> (op)) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
307 = reinterpret_cast<void *> (f); |
7336 | 308 |
309 return false; | |
310 } | |
311 | |
312 bool | |
2376 | 313 octave_value_typeinfo::do_register_binary_op (octave_value::binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
314 int t1, int t2, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
315 octave_value_typeinfo::binary_op_fcn f) |
2376 | 316 { |
4508 | 317 if (lookup_binary_op (op, t1, t2)) |
318 { | |
319 std::string op_name = octave_value::binary_op_as_string (op); | |
320 std::string t1_name = types(t1); | |
321 std::string t2_name = types(t2); | |
322 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
323 warning ("duplicate binary operator '%s' for types '%s' and '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
324 op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); |
4508 | 325 } |
326 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
327 binary_ops.checkelem (static_cast<int> (op), t1, t2) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
328 = reinterpret_cast<void *> (f); |
2376 | 329 |
330 return false; | |
331 } | |
332 | |
333 bool | |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
334 octave_value_typeinfo::do_register_binary_class_op (octave_value::compound_binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
335 octave_value_typeinfo::binary_class_op_fcn f) |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
336 { |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
337 if (lookup_binary_class_op (op)) |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
338 { |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
339 std::string op_name = octave_value::binary_op_fcn_name (op); |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
340 |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
341 warning ("duplicate compound binary operator '%s' for class dispatch", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
342 op_name.c_str ()); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
343 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
344 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
345 compound_binary_class_ops.checkelem (static_cast<int> (op)) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
346 = reinterpret_cast<void *> (f); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
347 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
348 return false; |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
349 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
350 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
351 bool |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
352 octave_value_typeinfo::do_register_binary_op (octave_value::compound_binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
353 int t1, int t2, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
354 octave_value_typeinfo::binary_op_fcn f) |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
355 { |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
356 if (lookup_binary_op (op, t1, t2)) |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
357 { |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
358 std::string op_name = octave_value::binary_op_fcn_name (op); |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
359 std::string t1_name = types(t1); |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
360 std::string t2_name = types(t2); |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
361 |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
362 warning ("duplicate compound binary operator '%s' for types '%s' and '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
363 op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
364 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
365 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
366 compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
367 = reinterpret_cast<void *> (f); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
368 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
369 return false; |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
370 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
371 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
372 bool |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
373 octave_value_typeinfo::do_register_cat_op (int t1, int t2, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
374 octave_value_typeinfo::cat_op_fcn f) |
4915 | 375 { |
376 if (lookup_cat_op (t1, t2)) | |
377 { | |
378 std::string t1_name = types(t1); | |
379 std::string t2_name = types(t2); | |
380 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
381 warning ("duplicate concatenation operator for types '%s' and '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
382 t1_name.c_str (), t1_name.c_str ()); |
4915 | 383 } |
384 | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
385 cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f); |
4915 | 386 |
387 return false; | |
388 } | |
389 | |
390 bool | |
2882 | 391 octave_value_typeinfo::do_register_assign_op (octave_value::assign_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
392 int t_lhs, int t_rhs, |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
393 octave_value_typeinfo::assign_op_fcn f) |
2376 | 394 { |
4508 | 395 if (lookup_assign_op (op, t_lhs, t_rhs)) |
396 { | |
397 std::string op_name = octave_value::assign_op_as_string (op); | |
398 std::string t_lhs_name = types(t_lhs); | |
399 std::string t_rhs_name = types(t_rhs); | |
400 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
401 warning ("duplicate assignment operator '%s' for types '%s' and '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
402 op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ()); |
4508 | 403 } |
404 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
405 assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
406 = reinterpret_cast<void *> (f); |
2376 | 407 |
408 return false; | |
409 } | |
410 | |
411 bool | |
3196 | 412 octave_value_typeinfo::do_register_assignany_op (octave_value::assign_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
413 int t_lhs, octave_value_typeinfo::assignany_op_fcn f) |
3196 | 414 { |
4508 | 415 if (lookup_assignany_op (op, t_lhs)) |
416 { | |
417 std::string op_name = octave_value::assign_op_as_string (op); | |
418 std::string t_lhs_name = types(t_lhs); | |
419 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
420 warning ("duplicate assignment operator '%s' for types '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
421 op_name.c_str (), t_lhs_name.c_str ()); |
4508 | 422 } |
423 | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
424 assignany_ops.checkelem (static_cast<int> (op), t_lhs) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
425 = reinterpret_cast<void *> (f); |
3196 | 426 |
427 return false; | |
428 } | |
429 | |
430 bool | |
2376 | 431 octave_value_typeinfo::do_register_pref_assign_conv (int t_lhs, int t_rhs, |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
432 int t_result) |
2376 | 433 { |
4508 | 434 if (lookup_pref_assign_conv (t_lhs, t_rhs) >= 0) |
435 { | |
436 std::string t_lhs_name = types(t_lhs); | |
437 std::string t_rhs_name = types(t_rhs); | |
438 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
439 warning ("overriding assignment conversion for types '%s' and '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
440 t_lhs_name.c_str (), t_rhs_name.c_str ()); |
4508 | 441 } |
442 | |
2376 | 443 pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result; |
444 | |
445 return false; | |
446 } | |
447 | |
448 bool | |
4901 | 449 octave_value_typeinfo::do_register_type_conv_op |
5759 | 450 (int t, int t_result, octave_base_value::type_conv_fcn f) |
4901 | 451 { |
452 if (lookup_type_conv_op (t, t_result)) | |
453 { | |
454 std::string t_name = types(t); | |
455 std::string t_result_name = types(t_result); | |
456 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
457 warning ("overriding type conversion op for '%s' to '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
458 t_name.c_str (), t_result_name.c_str ()); |
4901 | 459 } |
460 | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
461 type_conv_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f); |
4901 | 462 |
463 return false; | |
464 } | |
465 | |
466 bool | |
2376 | 467 octave_value_typeinfo::do_register_widening_op |
5759 | 468 (int t, int t_result, octave_base_value::type_conv_fcn f) |
2376 | 469 { |
4508 | 470 if (lookup_widening_op (t, t_result)) |
471 { | |
472 std::string t_name = types(t); | |
473 std::string t_result_name = types(t_result); | |
474 | |
15466
d174210ce1ec
use ' instead of ` in error messages, warnings and most comments
John W. Eaton <jwe@octave.org>
parents:
14138
diff
changeset
|
475 warning ("overriding widening op for '%s' to '%s'", |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
476 t_name.c_str (), t_result_name.c_str ()); |
4508 | 477 } |
478 | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
479 widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f); |
2376 | 480 |
481 return false; | |
482 } | |
483 | |
4640 | 484 octave_value |
485 octave_value_typeinfo::do_lookup_type (const std::string& nm) | |
486 { | |
487 octave_value retval; | |
488 | |
489 for (int i = 0; i < num_types; i++) | |
490 { | |
491 if (nm == types(i)) | |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
492 { |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
493 retval = vals(i); |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
494 retval.make_unique (); |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
495 break; |
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
496 } |
4640 | 497 } |
498 | |
499 return retval; | |
500 } | |
501 | |
7336 | 502 octave_value_typeinfo::unary_class_op_fcn |
503 octave_value_typeinfo::do_lookup_unary_class_op (octave_value::unary_op op) | |
504 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
505 void *f = unary_class_ops.checkelem (static_cast<int> (op)); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
506 return reinterpret_cast<octave_value_typeinfo::unary_class_op_fcn> (f); |
7336 | 507 } |
508 | |
5759 | 509 octave_value_typeinfo::unary_op_fcn |
3203 | 510 octave_value_typeinfo::do_lookup_unary_op (octave_value::unary_op op, int t) |
511 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
512 void *f = unary_ops.checkelem (static_cast<int> (op), t); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
513 return reinterpret_cast<octave_value_typeinfo::unary_op_fcn> (f); |
3203 | 514 } |
515 | |
5759 | 516 octave_value_typeinfo::non_const_unary_op_fcn |
3203 | 517 octave_value_typeinfo::do_lookup_non_const_unary_op |
518 (octave_value::unary_op op, int t) | |
519 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
520 void *f = non_const_unary_ops.checkelem (static_cast<int> (op), t); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
521 return reinterpret_cast<octave_value_typeinfo::non_const_unary_op_fcn> (f); |
3203 | 522 } |
523 | |
7336 | 524 octave_value_typeinfo::binary_class_op_fcn |
525 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::binary_op op) | |
526 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
527 void *f = binary_class_ops.checkelem (static_cast<int> (op)); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
528 return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f); |
7336 | 529 } |
530 | |
5759 | 531 octave_value_typeinfo::binary_op_fcn |
2376 | 532 octave_value_typeinfo::do_lookup_binary_op (octave_value::binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
533 int t1, int t2) |
2376 | 534 { |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
535 void *f = binary_ops.checkelem (static_cast<int> (op), t1, t2); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
536 return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f); |
2376 | 537 } |
538 | |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
539 octave_value_typeinfo::binary_class_op_fcn |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
540 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::compound_binary_op op) |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
541 { |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
542 void *f = compound_binary_class_ops.checkelem (static_cast<int> (op)); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
543 return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
544 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
545 |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
546 octave_value_typeinfo::binary_op_fcn |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
547 octave_value_typeinfo::do_lookup_binary_op (octave_value::compound_binary_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
548 int t1, int t2) |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
549 { |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
550 void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
551 return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f); |
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
552 } |
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
553 |
5759 | 554 octave_value_typeinfo::cat_op_fcn |
4915 | 555 octave_value_typeinfo::do_lookup_cat_op (int t1, int t2) |
556 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
557 void *f = cat_ops.checkelem (t1, t2); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
558 return reinterpret_cast<octave_value_typeinfo::cat_op_fcn> (f); |
4915 | 559 } |
560 | |
5759 | 561 octave_value_typeinfo::assign_op_fcn |
2882 | 562 octave_value_typeinfo::do_lookup_assign_op (octave_value::assign_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
563 int t_lhs, int t_rhs) |
2376 | 564 { |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
565 void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
566 return reinterpret_cast<octave_value_typeinfo::assign_op_fcn> (f); |
2376 | 567 } |
568 | |
5759 | 569 octave_value_typeinfo::assignany_op_fcn |
3196 | 570 octave_value_typeinfo::do_lookup_assignany_op (octave_value::assign_op op, |
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
571 int t_lhs) |
3196 | 572 { |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
573 void *f = assignany_ops.checkelem (static_cast<int> (op), t_lhs); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
574 return reinterpret_cast<octave_value_typeinfo::assignany_op_fcn> (f); |
3196 | 575 } |
576 | |
2376 | 577 int |
578 octave_value_typeinfo::do_lookup_pref_assign_conv (int t_lhs, int t_rhs) | |
579 { | |
580 return pref_assign_conv.checkelem (t_lhs, t_rhs); | |
581 } | |
582 | |
5759 | 583 octave_base_value::type_conv_fcn |
4901 | 584 octave_value_typeinfo::do_lookup_type_conv_op (int t, int t_result) |
585 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
586 void *f = type_conv_ops.checkelem (t, t_result); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
587 return reinterpret_cast<octave_base_value::type_conv_fcn> (f); |
4901 | 588 } |
589 | |
5759 | 590 octave_base_value::type_conv_fcn |
2376 | 591 octave_value_typeinfo::do_lookup_widening_op (int t, int t_result) |
592 { | |
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
593 void *f = widening_ops.checkelem (t, t_result); |
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
594 return reinterpret_cast<octave_base_value::type_conv_fcn> (f); |
2376 | 595 } |
596 | |
597 string_vector | |
22281
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
598 octave_value_typeinfo::do_installed_type_names (void) const |
2376 | 599 { |
600 string_vector retval (num_types); | |
601 | |
11438
9e8497537319
typeinfo: return cellstr, not char array
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
602 for (int i = 0; i < num_types; i++) |
9e8497537319
typeinfo: return cellstr, not char array
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
603 retval(i) = types(i); |
2376 | 604 |
605 return retval; | |
606 } | |
607 | |
2457 | 608 DEFUN (typeinfo, args, , |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
609 doc: /* -*- texinfo -*- |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
610 @deftypefn {} {} typeinfo () |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
611 @deftypefnx {} {} typeinfo (@var{expr}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
612 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
613 Return the type of the expression @var{expr}, as a string. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
614 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
615 If @var{expr} is omitted, return a cell array of strings containing all the |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
616 currently installed data types. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
617 @seealso{class, isa} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
618 @end deftypefn */) |
2376 | 619 { |
620 int nargin = args.length (); | |
621 | |
20797
492738d32c60
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20428
diff
changeset
|
622 if (nargin > 1) |
492738d32c60
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20428
diff
changeset
|
623 print_usage (); |
492738d32c60
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20428
diff
changeset
|
624 |
2376 | 625 if (nargin == 0) |
20939
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
626 return ovl (Cell (octave_value_typeinfo::installed_type_names ())); |
20797
492738d32c60
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20428
diff
changeset
|
627 else |
20939
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
628 return ovl (args(0).type_name ()); |
2376 | 629 } |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
630 |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
631 /* |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
632 %!assert (iscellstr (typeinfo ())) |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
633 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
634 %!assert (typeinfo ({"cell"}), "cell") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
635 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
636 %!assert (typeinfo (1), "scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
637 %!assert (typeinfo (double (1)), "scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
638 %!assert (typeinfo (i), "complex scalar") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
639 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
640 %!assert (typeinfo ([1, 2]), "matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
641 %!assert (typeinfo (double ([1, 2])), "matrix") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
642 %!assert (typeinfo (diag ([1, 2])), "diagonal matrix") |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
643 %!assert (typeinfo ([i, 2]), "complex matrix") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
644 %!assert (typeinfo (diag ([i, 2])), "complex diagonal matrix") |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
645 |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
646 %!assert (typeinfo (1:2), "range") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
647 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
648 %!assert (typeinfo (false), "bool") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
649 %!assert (typeinfo ([true, false]), "bool matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
650 |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
651 %!assert (typeinfo ("string"), "string") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
652 %!assert (typeinfo ('string'), "sq_string") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
653 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
654 %!assert (typeinfo (int8 (1)), "int8 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
655 %!assert (typeinfo (int16 (1)), "int16 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
656 %!assert (typeinfo (int32 (1)), "int32 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
657 %!assert (typeinfo (int64 (1)), "int64 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
658 %!assert (typeinfo (uint8 (1)), "uint8 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
659 %!assert (typeinfo (uint16 (1)), "uint16 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
660 %!assert (typeinfo (uint32 (1)), "uint32 scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
661 %!assert (typeinfo (uint64 (1)), "uint64 scalar") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
662 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
663 %!assert (typeinfo (int8 ([1,2])), "int8 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
664 %!assert (typeinfo (int16 ([1,2])), "int16 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
665 %!assert (typeinfo (int32 ([1,2])), "int32 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
666 %!assert (typeinfo (int64 ([1,2])), "int64 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
667 %!assert (typeinfo (uint8 ([1,2])), "uint8 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
668 %!assert (typeinfo (uint16 ([1,2])), "uint16 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
669 %!assert (typeinfo (uint32 ([1,2])), "uint32 matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
670 %!assert (typeinfo (uint64 ([1,2])), "uint64 matrix") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
671 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
672 %!assert (typeinfo (sparse ([true, false])), "sparse bool matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
673 %!assert (typeinfo (logical (sparse (i * eye (10)))), "sparse bool matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
674 %!assert (typeinfo (sparse ([1,2])), "sparse matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
675 %!assert (typeinfo (sparse (eye (10))), "sparse matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
676 %!assert (typeinfo (sparse ([i,2])), "sparse complex matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
677 %!assert (typeinfo (sparse (i * eye (10))), "sparse complex matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
678 |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
679 %!test |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
680 %! s(2).a = 1; |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
681 %! assert (typeinfo (s), "struct"); |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
682 |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
683 %!test |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
684 %! s.a = 1; |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
685 %! assert (typeinfo (s), "scalar struct"); |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
686 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
687 ## FIXME: This doesn't work as a test for comma-separated list |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
688 %!#test |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
689 %! clist = {1, 2, 3}; |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
690 %! assert (typeinfo (clist{:}), "cs-list"); |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
691 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
692 %!assert (typeinfo (@sin), "function handle") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
693 %!assert (typeinfo (@(x) x), "function handle") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
694 |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
695 %!assert (typeinfo (inline ("x^2")), "inline function") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
696 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
697 %!assert (typeinfo (single (1)), "float scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
698 %!assert (typeinfo (single (i)), "float complex scalar") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
699 %!assert (typeinfo (single ([1, 2])), "float matrix") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
700 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
701 %!assert (typeinfo (single (diag ([1, 2]))), "float diagonal matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
702 %!assert (typeinfo (diag (single ([1, 2]))), "float diagonal matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
703 %!assert (typeinfo (single (diag ([i, 2]))), "float complex diagonal matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
704 %!assert (typeinfo (diag (single ([i, 2]))), "float complex diagonal matrix") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
705 |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
706 %!assert (typeinfo (eye(3)(:,[1 3 2])), "permutation matrix") |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
707 %!test |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
708 %! [l, u, p] = lu (rand (3)); |
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
709 %! assert (typeinfo (p), "permutation matrix"); |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
710 |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
711 %!assert (typeinfo ([]), "null_matrix") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
712 %!assert (typeinfo (""), "null_string") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
713 %!assert (typeinfo (''), "null_sq_string") |
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
714 |
15810
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
715 %!test |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
716 %! cvar = onCleanup (@() ""); |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
717 %! assert (typeinfo (cvar), "onCleanup"); |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
718 |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
719 %!testif HAVE_JAVA |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
720 %! x = javaObject ("java.lang.StringBuffer"); |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
721 %! assert (typeinfo (x), "octave_java"); |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
722 |
87a61a4d8fd2
Add typeinfo %!tests for onCleanup and octave_java types.
Rik <rik@octave.org>
parents:
15467
diff
changeset
|
723 ## Test input validation |
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
724 %!error typeinfo ("foo", 1) |
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
725 */ |
22281
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
726 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
727 static boolNDArray |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
728 as_bool_nd_array (const Array<void *>& x) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
729 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
730 boolNDArray retval (x.dims ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
731 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
732 for (octave_idx_type i = 0; i < x.numel (); i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
733 retval.xelem (i) = x(i); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
734 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
735 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
736 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
737 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
738 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
739 octave_value_typeinfo::unary_ops_map (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
740 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
741 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
742 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
743 int len = std::min (non_const_unary_ops.columns (), num_types); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
744 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
745 dim_vector tab_dims (1, len); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
746 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
747 for (int j = 0; j < octave_value::num_unary_ops; j++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
748 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
749 boolNDArray tab (tab_dims); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
750 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
751 for (int i = 0; i < len; i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
752 tab.xelem (i) = (unary_ops(j,i) != 0); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
753 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
754 octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
755 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
756 retval.setfield (octave_value::unary_op_as_string (op_id), tab); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
757 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
758 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
759 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
760 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
761 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
762 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
763 octave_value_typeinfo::non_const_unary_ops_map (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
764 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
765 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
766 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
767 int len = std::min (non_const_unary_ops.columns (), num_types); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
768 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
769 dim_vector tab_dims (1, len); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
770 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
771 for (int j = 0; j < octave_value::num_unary_ops; j++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
772 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
773 boolNDArray tab (tab_dims); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
774 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
775 for (int i = 0; i < len; i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
776 tab.xelem (i) = (non_const_unary_ops(j,i) != 0); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
777 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
778 octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
779 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
780 retval.setfield (octave_value::unary_op_as_string (op_id), tab); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
781 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
782 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
783 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
784 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
785 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
786 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
787 octave_value_typeinfo::binary_ops_map (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
788 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
789 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
790 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
791 int len = std::min (binary_ops.columns (), num_types); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
792 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
793 dim_vector tab_dims (len, len); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
794 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
795 for (int k = 0; k < octave_value::num_binary_ops; k++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
796 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
797 boolNDArray tab (tab_dims); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
798 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
799 for (int j = 0; j < len; j++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
800 for (int i = 0; i < len; i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
801 tab.xelem (j,i) = (binary_ops(k,j,i) != 0); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
802 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
803 octave_value::binary_op op_id = static_cast<octave_value::binary_op> (k); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
804 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
805 retval.setfield (octave_value::binary_op_as_string (op_id), tab); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
806 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
807 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
808 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
809 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
810 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
811 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
812 octave_value_typeinfo::compound_binary_ops_map (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
813 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
814 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
815 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
816 int len = std::min (compound_binary_ops.columns (), num_types); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
817 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
818 dim_vector tab_dims (len, len); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
819 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
820 for (int k = 0; k < octave_value::num_compound_binary_ops; k++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
821 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
822 boolNDArray tab (tab_dims); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
823 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
824 for (int j = 0; j < len; j++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
825 for (int i = 0; i < len; i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
826 tab.xelem (j,i) = (compound_binary_ops(k,j,i) != 0); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
827 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
828 octave_value::compound_binary_op op_id = static_cast<octave_value::compound_binary_op> (k); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
829 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
830 retval.setfield (octave_value::binary_op_fcn_name (op_id), tab); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
831 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
832 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
833 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
834 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
835 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
836 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
837 octave_value_typeinfo::assign_ops_map (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
838 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
839 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
840 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
841 int len = std::min (assign_ops.columns (), num_types); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
842 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
843 dim_vector tab_dims (len, len); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
844 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
845 for (int k = 0; k < octave_value::num_assign_ops; k++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
846 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
847 boolNDArray tab (tab_dims); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
848 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
849 for (int j = 0; j < len; j++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
850 for (int i = 0; i < len; i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
851 tab.xelem (j,i) = (assign_ops(k,j,i) != 0); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
852 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
853 octave_value::assign_op op_id = static_cast<octave_value::assign_op> (k); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
854 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
855 retval.setfield (octave_value::assign_op_as_string (op_id), tab); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
856 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
857 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
858 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
859 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
860 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
861 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
862 octave_value_typeinfo::assignany_ops_map (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
863 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
864 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
865 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
866 int len = std::min (assignany_ops.columns (), num_types); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
867 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
868 dim_vector tab_dims (1, len); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
869 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
870 for (int j = 0; j < octave_value::num_assign_ops; j++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
871 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
872 boolNDArray tab (tab_dims); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
873 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
874 for (int i = 0; i < len; i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
875 tab.xelem (i) = (assignany_ops(j,i) != 0); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
876 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
877 octave_value::assign_op op_id = static_cast<octave_value::assign_op> (j); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
878 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
879 retval.setfield (octave_value::assign_op_as_string (op_id), tab); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
880 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
881 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
882 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
883 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
884 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
885 static NDArray |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
886 as_nd_array (const Array<int>& x) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
887 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
888 NDArray retval (x.dims ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
889 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
890 for (int i = 0; i < x.numel (); i++) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
891 retval.xelem(i) = x(i); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
892 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
893 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
894 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
895 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
896 octave_scalar_map |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
897 octave_value_typeinfo::do_installed_type_info (void) const |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
898 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
899 octave_scalar_map retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
900 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
901 retval.setfield ("types", octave_value (Cell (do_installed_type_names ()))); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
902 retval.setfield ("unary_ops", unary_ops_map ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
903 retval.setfield ("non_const_unary_ops", non_const_unary_ops_map ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
904 retval.setfield ("binary_ops", binary_ops_map ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
905 retval.setfield ("compound_unary_ops", compound_binary_ops_map ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
906 retval.setfield ("cat_ops", as_bool_nd_array (cat_ops)); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
907 retval.setfield ("assign_ops", assign_ops_map ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
908 retval.setfield ("assignany_ops", assignany_ops_map ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
909 retval.setfield ("pref_assign_conv", as_nd_array (pref_assign_conv)); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
910 retval.setfield ("type_conv_ops", as_bool_nd_array (type_conv_ops)); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
911 retval.setfield ("widening_ops", as_bool_nd_array (widening_ops)); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
912 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
913 return retval; |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
914 } |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
915 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
916 DEFUN (__dump_typeinfo__, args, , |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
917 doc: /* -*- texinfo -*- |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
918 @deftypefn {} {} __dump_typeinfo__ () |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
919 Undocumented internal function. |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
920 @end deftypefn */) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
921 { |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
922 if (args.length () > 0) |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
923 print_usage (); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
924 |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
925 return ovl (octave_value_typeinfo::installed_type_info ()); |
0f9ab4f1f4b3
new function __dump_typeinfo__
John W. Eaton <jwe@octave.org>
parents:
21966
diff
changeset
|
926 } |