Mercurial > octave
diff libinterp/octave-value/ov.cc @ 24540:46440078d73b
don't use singleton for octave_value_typeinfo
* ov-typeinfo.h, ov-typeinfo.cc (type_info): New class containing the
functionaity provided by the non-static functions in the
octave_value_typeinfo class. Define in octave namespace.
(octave_value_typeinfo): Now a namespace containing global functions
instead of a class containing all static functions. Provided for
backward compatibility, so all functions are tagged as deprecated.
* ops.h (INSTALL_UNOP_TI, INSTALL_NCUNOP_TI, INSTALL_BINOP_TI,
INSTALL_CATOP_TI, INSTALL_ASSIGNOP_TI, INSTALL_ASSIGNANYOP_TI,
INSTALL_ASSIGNCONV_TI, INSTALL_WIDENOP_TI): New macros.
(install_ops): Accept reference to type_info object as
an argument.
* mk-ops.sh: Generate function decls and calls that pass reference
to type_info object as an argument.
* op-b-b.cc, op-b-bm.cc, op-b-sbm.cc, op-bm-b.cc, op-bm-bm.cc,
op-bm-sbm.cc, op-cdm-cdm.cc, op-cell.cc, op-chm.cc, op-class.cc,
op-cm-cm.cc, op-cm-cs.cc, op-cm-m.cc, op-cm-s.cc, op-cm-scm.cc,
op-cm-sm.cc, op-cs-cm.cc, op-cs-cs.cc, op-cs-m.cc, op-cs-s.cc,
op-cs-scm.cc, op-cs-sm.cc, op-dm-dm.cc, op-dm-scm.cc, op-dm-sm.cc,
op-dm-template.cc, op-dms-template.cc, op-fcdm-fcdm.cc, op-fcm-fcm.cc,
op-fcm-fcs.cc, op-fcm-fm.cc, op-fcm-fs.cc, op-fcn.cc, op-fcs-fcm.cc,
op-fcs-fcs.cc, op-fcs-fm.cc, op-fcs-fs.cc, op-fdm-fdm.cc,
op-fm-fcm.cc, op-fm-fcs.cc, op-fm-fm.cc, op-fm-fs.cc, op-fs-fcm.cc,
op-fs-fcs.cc, op-fs-fm.cc, op-fs-fs.cc, op-i16-i16.cc, op-i32-i32.cc,
op-i64-i64.cc, op-i8-i8.cc, op-int-concat.cc, op-int.h, op-m-cm.cc,
op-m-cs.cc, op-m-m.cc, op-m-s.cc, op-m-scm.cc, op-m-sm.cc,
op-pm-pm.cc, op-pm-scm.cc, op-pm-sm.cc, op-pm-template.cc,
op-range.cc, op-s-cm.cc, op-s-cs.cc, op-s-m.cc, op-s-s.cc,
op-s-scm.cc, op-s-sm.cc, op-sbm-b.cc, op-sbm-bm.cc, op-sbm-sbm.cc,
op-scm-cm.cc, op-scm-cs.cc, op-scm-m.cc, op-scm-s.cc, op-scm-scm.cc,
op-scm-sm.cc, op-sm-cm.cc, op-sm-cs.cc, op-sm-m.cc, op-sm-s.cc,
op-sm-scm.cc, op-sm-sm.cc, op-str-m.cc, op-str-s.cc, op-str-str.cc,
op-struct.cc, op-ui16-ui16.cc, op-ui32-ui32.cc, op-ui64-ui64.cc,
op-ui8-ui8.cc): Use new _T1 macros. Update install_TYPE_ops function
for each type to accept reference to type_info object as argument.
* interpreter.h, interpreter.cc (interpreter::m_type_info):
New member variable.
(interpreter::get_type_info): New function.
(interpreter::interpreter): Initialize m_type_info before
m_symbol_table. Don't call install_types or install ops. That is now
handled by the in type_info constructor. Don't call m_cdef_manager.
That is now handled by the cdef_manager constructor.
* interpreter-private.h, interpreter-private.cc (__get_type_info__):
New function. Use where necessary to get reference to
interpreter::m_type_info object.
* ov-classdef.cc, ov-classdef.h (octave_classdef::octave_classdef):
Handle all initialization here.
(octave_classdef::initialize): Delete unused function.
* ov.h, ov.cc (install_types): Accept reference to type_info object as
argument. Pass on to individual register_type functions.
* ov-base.h, ov-base.cc (DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA): Update
to define additional register_type functions that accepts reference to
type_info object.
(install_base_type_conversions): Update to use new *_TI macros.
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Fri, 05 Jan 2018 18:44:53 -0500 |
| parents | 194eb4bd202b |
| children | dbec1e04f499 |
line wrap: on
line diff
--- a/libinterp/octave-value/ov.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov.cc Fri Jan 05 18:44:53 2018 -0500 @@ -1521,7 +1521,7 @@ operator = (rhs.storable_value ()); else if (is_defined ()) { - octave_value_typeinfo::assign_op_fcn f = nullptr; + octave::type_info::assign_op_fcn f = nullptr; // Only attempt to operate in-place if this variable is unshared. if (rep->count == 1) @@ -1529,7 +1529,10 @@ int tthis = this->type_id (); int trhs = rhs.type_id (); - f = octave_value_typeinfo::lookup_assign_op (op, tthis, trhs); + octave::type_info& ti + = octave::__get_type_info__ ("octave_value::assign"); + + f = ti.lookup_assign_op (op, tthis, trhs); } if (f) @@ -2160,13 +2163,15 @@ int t1 = v1.type_id (); int t2 = v2.type_id (); + octave::type_info& ti = octave::__get_type_info__ ("do_binary_op"); + if (t1 == octave_class::static_type_id () || t2 == octave_class::static_type_id () || t1 == octave_classdef::static_type_id () || t2 == octave_classdef::static_type_id ()) { - octave_value_typeinfo::binary_class_op_fcn f - = octave_value_typeinfo::lookup_binary_class_op (op); + octave::type_info::binary_class_op_fcn f + = ti.lookup_binary_class_op (op); if (! f) err_binary_op (octave_value::binary_op_as_string (op), @@ -2179,8 +2184,8 @@ // FIXME: we need to handle overloading operators for built-in // classes (double, char, int8, etc.) - octave_value_typeinfo::binary_op_fcn f - = octave_value_typeinfo::lookup_binary_op (op, t1, t2); + octave::type_info::binary_op_fcn f + = ti.lookup_binary_op (op, t1, t2); if (f) retval = f (*v1.rep, *v2.rep); @@ -2196,13 +2201,10 @@ // Try biased (one-sided) conversions first. if (cf2.type_id () >= 0 - && octave_value_typeinfo::lookup_binary_op (op, t1, - cf2.type_id ())) + && ti.lookup_binary_op (op, t1, cf2.type_id ())) cf1 = nullptr; else if (cf1.type_id () >= 0 - && octave_value_typeinfo::lookup_binary_op (op, - cf1.type_id (), - t2)) + && ti.lookup_binary_op (op, cf1.type_id (), t2)) cf2 = nullptr; if (cf1) @@ -2244,13 +2246,10 @@ // Try biased (one-sided) conversions first. if (cf2.type_id () >= 0 - && octave_value_typeinfo::lookup_binary_op (op, t1, - cf2.type_id ())) + && ti.lookup_binary_op (op, t1, cf2.type_id ())) cf1 = nullptr; else if (cf1.type_id () >= 0 - && octave_value_typeinfo::lookup_binary_op (op, - cf1.type_id (), - t2)) + && ti.lookup_binary_op (op, cf1.type_id (), t2)) cf2 = nullptr; if (cf1) @@ -2279,7 +2278,7 @@ err_binary_op (octave_value::binary_op_as_string (op), v1.type_name (), v2.type_name ()); - f = octave_value_typeinfo::lookup_binary_op (op, t1, t2); + f = ti.lookup_binary_op (op, t1, t2); if (! f) err_binary_op (octave_value::binary_op_as_string (op), @@ -2353,13 +2352,14 @@ int t1 = v1.type_id (); int t2 = v2.type_id (); + octave::type_info& ti = octave::__get_type_info__ ("do_binary_op"); + if (t1 == octave_class::static_type_id () || t2 == octave_class::static_type_id () || t1 == octave_classdef::static_type_id () || t2 == octave_classdef::static_type_id ()) { - octave_value_typeinfo::binary_class_op_fcn f - = octave_value_typeinfo::lookup_binary_class_op (op); + octave::type_info::binary_class_op_fcn f = ti.lookup_binary_class_op (op); if (f) retval = f (v1, v2); @@ -2368,8 +2368,7 @@ } else { - octave_value_typeinfo::binary_op_fcn f - = octave_value_typeinfo::lookup_binary_op (op, t1, t2); + octave::type_info::binary_op_fcn f = ti.lookup_binary_op (op, t1, t2); if (f) retval = f (*v1.rep, *v2.rep); @@ -2405,8 +2404,9 @@ int t1 = v1.type_id (); int t2 = v2.type_id (); - octave_value_typeinfo::cat_op_fcn f - = octave_value_typeinfo::lookup_cat_op (t1, t2); + octave::type_info& ti = octave::__get_type_info__ ("do_cat_op"); + + octave::type_info::cat_op_fcn f = ti.lookup_cat_op (t1, t2); if (f) retval = f (*v1.rep, *v2.rep, ra_idx); @@ -2419,11 +2419,9 @@ octave_base_value::type_conv_info cf2 = v2.numeric_conversion_function (); // Try biased (one-sided) conversions first. - if (cf2.type_id () >= 0 - && octave_value_typeinfo::lookup_cat_op (t1, cf2.type_id ())) + if (cf2.type_id () >= 0 && ti.lookup_cat_op (t1, cf2.type_id ())) cf1 = nullptr; - else if (cf1.type_id () >= 0 - && octave_value_typeinfo::lookup_cat_op (cf1.type_id (), t2)) + else if (cf1.type_id () >= 0 && ti.lookup_cat_op (cf1.type_id (), t2)) cf2 = nullptr; if (cf1) @@ -2591,11 +2589,12 @@ int t = v.type_id (); + octave::type_info& ti = octave::__get_type_info__ ("do_unary_op"); + if (t == octave_class::static_type_id () || t == octave_classdef::static_type_id ()) { - octave_value_typeinfo::unary_class_op_fcn f - = octave_value_typeinfo::lookup_unary_class_op (op); + octave::type_info::unary_class_op_fcn f = ti.lookup_unary_class_op (op); if (! f) err_unary_op (octave_value::unary_op_as_string (op), v.class_name ()); @@ -2607,8 +2606,7 @@ // FIXME: we need to handle overloading operators for built-in // classes (double, char, int8, etc.) - octave_value_typeinfo::unary_op_fcn f - = octave_value_typeinfo::lookup_unary_op (op, t); + octave::type_info::unary_op_fcn f = ti.lookup_unary_op (op, t); if (f) retval = f (*v.rep); @@ -2662,8 +2660,11 @@ // Genuine. int t = type_id (); - octave_value_typeinfo::non_const_unary_op_fcn f - = octave_value_typeinfo::lookup_non_const_unary_op (op, t); + octave::type_info& ti + = octave::__get_type_info__ ("do_non_const_unary_op"); + + octave::type_info::non_const_unary_op_fcn f + = ti.lookup_non_const_unary_op (op, t); if (f) { @@ -2689,7 +2690,7 @@ t = type_id (); - f = octave_value_typeinfo::lookup_non_const_unary_op (op, t); + f = ti.lookup_non_const_unary_op (op, t); if (f) { @@ -2718,11 +2719,16 @@ // Non-genuine. int t = type_id (); - octave_value_typeinfo::non_const_unary_op_fcn f = nullptr; + octave::type_info::non_const_unary_op_fcn f = nullptr; // Only attempt to operate in-place if this variable is unshared. if (rep->count == 1) - f = octave_value_typeinfo::lookup_non_const_unary_op (op, t); + { + octave::type_info& ti + = octave::__get_type_info__ ("do_non_const_unary_op"); + + f = ti.lookup_non_const_unary_op (op, t); + } if (f) f (*rep); @@ -2849,63 +2855,63 @@ } void -install_types (void) +install_types (octave::type_info& ti) { - octave_base_value::register_type (); - octave_cell::register_type (); - octave_scalar::register_type (); - octave_complex::register_type (); - octave_matrix::register_type (); - octave_diag_matrix::register_type (); - octave_complex_matrix::register_type (); - octave_complex_diag_matrix::register_type (); - octave_range::register_type (); - octave_bool::register_type (); - octave_bool_matrix::register_type (); - octave_char_matrix_str::register_type (); - octave_char_matrix_sq_str::register_type (); - octave_int8_scalar::register_type (); - octave_int16_scalar::register_type (); - octave_int32_scalar::register_type (); - octave_int64_scalar::register_type (); - octave_uint8_scalar::register_type (); - octave_uint16_scalar::register_type (); - octave_uint32_scalar::register_type (); - octave_uint64_scalar::register_type (); - octave_int8_matrix::register_type (); - octave_int16_matrix::register_type (); - octave_int32_matrix::register_type (); - octave_int64_matrix::register_type (); - octave_uint8_matrix::register_type (); - octave_uint16_matrix::register_type (); - octave_uint32_matrix::register_type (); - octave_uint64_matrix::register_type (); - octave_sparse_bool_matrix::register_type (); - octave_sparse_matrix::register_type (); - octave_sparse_complex_matrix::register_type (); - octave_struct::register_type (); - octave_scalar_struct::register_type (); - octave_class::register_type (); - octave_cs_list::register_type (); - octave_magic_colon::register_type (); - octave_builtin::register_type (); - octave_user_function::register_type (); - octave_dld_function::register_type (); - octave_fcn_handle::register_type (); - octave_fcn_inline::register_type (); - octave_float_scalar::register_type (); - octave_float_complex::register_type (); - octave_float_matrix::register_type (); - octave_float_diag_matrix::register_type (); - octave_float_complex_matrix::register_type (); - octave_float_complex_diag_matrix::register_type (); - octave_perm_matrix::register_type (); - octave_null_matrix::register_type (); - octave_null_str::register_type (); - octave_null_sq_str::register_type (); - octave_lazy_index::register_type (); - octave_oncleanup::register_type (); - octave_java::register_type (); + octave_base_value::register_type (ti); + octave_cell::register_type (ti); + octave_scalar::register_type (ti); + octave_complex::register_type (ti); + octave_matrix::register_type (ti); + octave_diag_matrix::register_type (ti); + octave_complex_matrix::register_type (ti); + octave_complex_diag_matrix::register_type (ti); + octave_range::register_type (ti); + octave_bool::register_type (ti); + octave_bool_matrix::register_type (ti); + octave_char_matrix_str::register_type (ti); + octave_char_matrix_sq_str::register_type (ti); + octave_int8_scalar::register_type (ti); + octave_int16_scalar::register_type (ti); + octave_int32_scalar::register_type (ti); + octave_int64_scalar::register_type (ti); + octave_uint8_scalar::register_type (ti); + octave_uint16_scalar::register_type (ti); + octave_uint32_scalar::register_type (ti); + octave_uint64_scalar::register_type (ti); + octave_int8_matrix::register_type (ti); + octave_int16_matrix::register_type (ti); + octave_int32_matrix::register_type (ti); + octave_int64_matrix::register_type (ti); + octave_uint8_matrix::register_type (ti); + octave_uint16_matrix::register_type (ti); + octave_uint32_matrix::register_type (ti); + octave_uint64_matrix::register_type (ti); + octave_sparse_bool_matrix::register_type (ti); + octave_sparse_matrix::register_type (ti); + octave_sparse_complex_matrix::register_type (ti); + octave_struct::register_type (ti); + octave_scalar_struct::register_type (ti); + octave_class::register_type (ti); + octave_cs_list::register_type (ti); + octave_magic_colon::register_type (ti); + octave_builtin::register_type (ti); + octave_user_function::register_type (ti); + octave_dld_function::register_type (ti); + octave_fcn_handle::register_type (ti); + octave_fcn_inline::register_type (ti); + octave_float_scalar::register_type (ti); + octave_float_complex::register_type (ti); + octave_float_matrix::register_type (ti); + octave_float_diag_matrix::register_type (ti); + octave_float_complex_matrix::register_type (ti); + octave_float_complex_diag_matrix::register_type (ti); + octave_perm_matrix::register_type (ti); + octave_null_matrix::register_type (ti); + octave_null_str::register_type (ti); + octave_null_sq_str::register_type (ti); + octave_lazy_index::register_type (ti); + octave_oncleanup::register_type (ti); + octave_java::register_type (ti); } DEFUN (sizeof, args, ,