Mercurial > octave
changeset 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.
line wrap: on
line diff
--- a/libinterp/corefcn/data.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/data.cc Fri Jan 05 18:44:53 2018 -0500 @@ -1927,8 +1927,9 @@ // an empty matrix and copy all data. // // We might also start with a empty octave_value using - // tmp = octave_value_typeinfo::lookup_type - // (args(1).type_name()); + // + // tmp = octave::type_info::lookup_type (args(1).type_name()); + // // and then directly resize. However, for some types there might // be some additional setup needed, and so this should be avoided.
--- a/libinterp/corefcn/interpreter-private.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/interpreter-private.cc Fri Jan 05 18:44:53 2018 -0500 @@ -72,6 +72,13 @@ return interp.get_load_path (); } + type_info& __get_type_info__ (const std::string& who) + { + interpreter& interp = __get_interpreter__ (who); + + return interp.get_type_info (); + } + symbol_table& __get_symbol_table__ (const std::string& who) { interpreter& interp = __get_interpreter__ (who);
--- a/libinterp/corefcn/interpreter-private.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/interpreter-private.h Fri Jan 05 18:44:53 2018 -0500 @@ -33,13 +33,14 @@ namespace octave { - class interpreter; + class call_stack; class dynamic_loader; class gtk_manager; class help_system; + class interpreter; class load_path; class tree_evaluator; - class call_stack; + class type_info; extern interpreter& __get_interpreter__ (const std::string& who); @@ -49,6 +50,8 @@ extern load_path& __get_load_path__ (const std::string& who); + extern type_info& __get_type_info__ (const std::string& who); + extern symbol_table& __get_symbol_table__ (const std::string& who); extern symbol_scope __get_current_scope__ (const std::string& who);
--- a/libinterp/corefcn/interpreter.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/interpreter.cc Fri Jan 05 18:44:53 2018 -0500 @@ -59,7 +59,6 @@ #include "oct-hist.h" #include "oct-map.h" #include "oct-mutex.h" -#include "ops.h" #include "ovl.h" #include "ov.h" #include "ov-classdef.h" @@ -352,6 +351,7 @@ m_help_system (*this), m_dynamic_loader (*this), m_load_path (), + m_type_info (), m_symbol_table (), m_evaluator (*this), m_stream_list (*this), @@ -417,14 +417,8 @@ else quit_allowed = false; - install_types (); - - install_ops (); - install_builtins (); - m_cdef_manager.initialize (); - bool line_editing = false; bool traditional = false;
--- a/libinterp/corefcn/interpreter.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/interpreter.h Fri Jan 05 18:44:53 2018 -0500 @@ -37,6 +37,7 @@ #include "load-path.h" #include "oct-stream.h" #include "ov-classdef.h" +#include "ov-typeinfo.h" #include "pt-eval.h" #include "symtab.h" #include "url-handle-manager.h" @@ -167,6 +168,11 @@ return m_symbol_table; } + type_info& get_type_info (void) + { + return m_type_info; + } + symbol_scope get_current_scope (void); symbol_scope require_current_scope (const std::string& who); @@ -240,6 +246,8 @@ load_path m_load_path; + type_info m_type_info; + symbol_table m_symbol_table; tree_evaluator m_evaluator;
--- a/libinterp/corefcn/ls-hdf5.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/ls-hdf5.cc Fri Jan 05 18:44:53 2018 -0500 @@ -52,6 +52,7 @@ #include "defun.h" #include "error.h" #include "errwarn.h" +#include "interpreter-private.h" #include "load-save.h" #include "oct-hdf5.h" #include "ovl.h" @@ -366,6 +367,9 @@ std::string vname = name; + octave::type_info& type_info + = octave::__get_type_info__ ("hdf5_read_next_data_internal"); + // Allow identifiers as all digits so we can load lists saved by // earlier versions of Octave. @@ -438,7 +442,7 @@ H5Tclose (st_id); H5Dclose (data_id); - d->tc = octave_value_typeinfo::lookup_type (typ); + d->tc = type_info.lookup_type (typ); retval = (d->tc.load_hdf5 (subgroup_id, "value") ? 1 : -1); @@ -454,9 +458,9 @@ // octave list otherwise. if (hdf5_check_attr (subgroup_id, "OCTAVE_LIST")) - d->tc = octave_value_typeinfo::lookup_type ("list"); + d->tc = type_info.lookup_type ("list"); else - d->tc = octave_value_typeinfo::lookup_type ("struct"); + d->tc = type_info.lookup_type ("struct"); // check for OCTAVE_GLOBAL attribute: d->global = hdf5_check_attr (subgroup_id, "OCTAVE_GLOBAL"); @@ -493,9 +497,9 @@ hsize_t rank = H5Sget_simple_extent_ndims (space_id); if (rank == 0) - d->tc = octave_value_typeinfo::lookup_type ("scalar"); + d->tc = type_info.lookup_type ("scalar"); else - d->tc = octave_value_typeinfo::lookup_type ("matrix"); + d->tc = type_info.lookup_type ("matrix"); H5Sclose (space_id); } @@ -600,12 +604,12 @@ else int_typ.append ("matrix"); - d->tc = octave_value_typeinfo::lookup_type (int_typ); + d->tc = type_info.lookup_type (int_typ); H5Sclose (space_id); } } else if (type_class_id == H5T_STRING) - d->tc = octave_value_typeinfo::lookup_type ("string"); + d->tc = type_info.lookup_type ("string"); else if (type_class_id == H5T_COMPOUND) { hid_t complex_type = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); @@ -617,16 +621,16 @@ hsize_t rank = H5Sget_simple_extent_ndims (space_id); if (rank == 0) - d->tc = octave_value_typeinfo::lookup_type ("complex scalar"); + d->tc = type_info.lookup_type ("complex scalar"); else - d->tc = octave_value_typeinfo::lookup_type ("complex matrix"); + d->tc = type_info.lookup_type ("complex matrix"); H5Sclose (space_id); } else // Assume that if its not complex its a range. // If its not, it'll be rejected later in the range code. - d->tc = octave_value_typeinfo::lookup_type ("range"); + d->tc = type_info.lookup_type ("range"); H5Tclose (complex_type); }
--- a/libinterp/corefcn/ls-oct-binary.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/ls-oct-binary.cc Fri Jan 05 18:44:53 2018 -0500 @@ -40,6 +40,7 @@ #include "defun.h" #include "error.h" #include "errwarn.h" +#include "interpreter-private.h" #include "load-save.h" #include "ls-oct-binary.h" #include "ls-utils.h" @@ -95,7 +96,7 @@ // // type string type_length // -// The string "type" is then used with octave_value_typeinfo::lookup_type +// The string "type" is then used with octave::type_info::lookup_type // to create an octave_value of the correct type. The specific load/save // function is then called. // @@ -170,23 +171,26 @@ if (! is.read (reinterpret_cast<char *> (&tmp), 1)) error ("load: trouble reading binary file '%s'", filename.c_str ()); + octave::type_info& type_info + = octave::__get_type_info__ ("read_binary_data"); + // All cases except 255 kept for backwards compatibility switch (tmp) { case 1: - tc = octave_value_typeinfo::lookup_type ("scalar"); + tc = type_info.lookup_type ("scalar"); break; case 2: - tc = octave_value_typeinfo::lookup_type ("matrix"); + tc = type_info.lookup_type ("matrix"); break; case 3: - tc = octave_value_typeinfo::lookup_type ("complex scalar"); + tc = type_info.lookup_type ("complex scalar"); break; case 4: - tc = octave_value_typeinfo::lookup_type ("complex matrix"); + tc = type_info.lookup_type ("complex matrix"); break; case 5: @@ -211,11 +215,11 @@ break; case 6: - tc = octave_value_typeinfo::lookup_type ("range"); + tc = type_info.lookup_type ("range"); break; case 7: - tc = octave_value_typeinfo::lookup_type ("string"); + tc = type_info.lookup_type ("string"); break; case 255: @@ -231,7 +235,7 @@ error ("load: trouble reading binary file '%s'", filename.c_str ()); s[len] = '\0'; std::string typ = s; - tc = octave_value_typeinfo::lookup_type (typ); + tc = type_info.lookup_type (typ); } break; default:
--- a/libinterp/corefcn/ls-oct-text.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/corefcn/ls-oct-text.cc Fri Jan 05 18:44:53 2018 -0500 @@ -50,6 +50,7 @@ #include "defun.h" #include "error.h" #include "errwarn.h" +#include "interpreter-private.h" #include "load-save.h" #include "ls-ascii-helper.h" #include "ls-oct-text.h" @@ -278,7 +279,12 @@ if (SUBSTRING_COMPARE_EQ (typ, 0, 12, "string array")) tc = charMatrix (); else - tc = octave_value_typeinfo::lookup_type (typ); + { + octave::type_info& type_info + = octave::__get_type_info__ ("read_text_data"); + + tc = type_info.lookup_type (typ); + } if (! tc.load_ascii (is)) error ("load: trouble reading ascii file '%s'", filename.c_str ());
--- a/libinterp/octave-value/ov-base.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-base.cc Fri Jan 05 18:44:53 2018 -0500 @@ -1178,9 +1178,11 @@ int t_lhs = type_id (); int t_rhs = rhs.type_id (); - octave_value_typeinfo::assign_op_fcn f - = octave_value_typeinfo::lookup_assign_op (octave_value::op_asn_eq, - t_lhs, t_rhs); + octave::type_info& ti + = octave::__get_type_info__ ("octave_base_value::numeric_assign"); + + octave::type_info::assign_op_fcn f + = ti.lookup_assign_op (octave_value::op_asn_eq, t_lhs, t_rhs); bool done = false; @@ -1198,13 +1200,12 @@ } else { - int t_result - = octave_value_typeinfo::lookup_pref_assign_conv (t_lhs, t_rhs); + int t_result = ti.lookup_pref_assign_conv (t_lhs, t_rhs); if (t_result >= 0) { octave_base_value::type_conv_fcn cf - = octave_value_typeinfo::lookup_widening_op (t_lhs, t_result); + = ti.lookup_widening_op (t_lhs, t_result); if (! cf) err_indexed_assignment (type_name (), rhs.type_name ()); @@ -1233,17 +1234,16 @@ // Try biased (one-sided) conversions first. if (cf_rhs.type_id () >= 0 - && (octave_value_typeinfo::lookup_assign_op (octave_value::op_asn_eq, - t_lhs, - cf_rhs.type_id ()) - || octave_value_typeinfo::lookup_pref_assign_conv (t_lhs, - cf_rhs.type_id ()) >= 0)) + && (ti.lookup_assign_op (octave_value::op_asn_eq, + t_lhs, cf_rhs.type_id ()) + || ti.lookup_pref_assign_conv (t_lhs, + cf_rhs.type_id ()) >= 0)) cf_this = nullptr; else if (cf_this.type_id () >= 0 - && (octave_value_typeinfo::lookup_assign_op (octave_value::op_asn_eq, - cf_this.type_id (), t_rhs) - || octave_value_typeinfo::lookup_pref_assign_conv (cf_this.type_id (), - t_rhs) >= 0)) + && (ti.lookup_assign_op (octave_value::op_asn_eq, + cf_this.type_id (), t_rhs) + || ti.lookup_pref_assign_conv (cf_this.type_id (), + t_rhs) >= 0)) cf_rhs = nullptr; if (cf_rhs) @@ -1471,23 +1471,23 @@ } void -install_base_type_conversions (void) +install_base_type_conversions (octave::type_info& ti) { - INSTALL_ASSIGNCONV (octave_base_value, octave_scalar, octave_matrix); - INSTALL_ASSIGNCONV (octave_base_value, octave_matrix, octave_matrix); - INSTALL_ASSIGNCONV (octave_base_value, octave_complex, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_base_value, octave_complex_matrix, - octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_base_value, octave_range, octave_matrix); - INSTALL_ASSIGNCONV (octave_base_value, octave_char_matrix_str, - octave_char_matrix_str); - INSTALL_ASSIGNCONV (octave_base_value, octave_cell, octave_cell); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_scalar, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_matrix, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_complex, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_complex_matrix, + octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_range, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_char_matrix_str, + octave_char_matrix_str); + INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_cell, octave_cell); - INSTALL_WIDENOP (octave_base_value, octave_matrix, matrix_conv); - INSTALL_WIDENOP (octave_base_value, octave_complex_matrix, - complex_matrix_conv); - INSTALL_WIDENOP (octave_base_value, octave_char_matrix_str, string_conv); - INSTALL_WIDENOP (octave_base_value, octave_cell, cell_conv); + INSTALL_WIDENOP_TI (ti, octave_base_value, octave_matrix, matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_base_value, octave_complex_matrix, + complex_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_base_value, octave_char_matrix_str, string_conv); + INSTALL_WIDENOP_TI (ti, octave_base_value, octave_cell, cell_conv); } DEFUN (sparse_auto_mutate, args, nargout,
--- a/libinterp/octave-value/ov-base.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-base.h Fri Jan 05 18:44:53 2018 -0500 @@ -41,6 +41,17 @@ #include "oct-hdf5-types.h" #include "oct-stream.h" +namespace octave +{ + class type_info; + + // FIXME: This is not ideal, but it avoids including + // interpreter-private.h here and bringing in a lot of unnecessary + // symbols that require even more header files. + + extern type_info& __get_type_info__ (const std::string&); +} + class Cell; class mxArray; class octave_map; @@ -159,20 +170,28 @@ static std::string static_type_name (void) { return t_name; } \ static std::string static_class_name (void) { return c_name; } \ static void register_type (void); \ + static void register_type (octave::type_info&); \ \ private: \ static int t_id; \ static const std::string t_name; \ static const std::string c_name; -#define DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(t, n, c) \ - int t::t_id (-1); \ - const std::string t::t_name (n); \ - const std::string t::c_name (c); \ - void t::register_type (void) \ - { \ - octave_value v (new t ()); \ - t_id = octave_value_typeinfo::register_type (t::t_name, t::c_name, v); \ +#define DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(t, n, c) \ + int t::t_id (-1); \ + const std::string t::t_name (n); \ + const std::string t::c_name (c); \ + void t::register_type (void) \ + { \ + octave::type_info& type_info \ + = octave::__get_type_info__ (#t "::register_type"); \ + \ + register_type (type_info); \ + } \ + void t::register_type (octave::type_info& ti) \ + { \ + octave_value v (new t ()); \ + t_id = ti.register_type (t::t_name, t::c_name, v); \ } // A base value type, so that derived types only have to redefine what
--- a/libinterp/octave-value/ov-class.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-class.cc Fri Jan 05 18:44:53 2018 -0500 @@ -50,6 +50,7 @@ #include "oct-hdf5.h" #include "ov-class.h" #include "ov-fcn.h" +#include "ov-typeinfo.h" #include "ov-usr-fcn.h" #include "pager.h" #include "parse.h" @@ -63,11 +64,10 @@ const std::string octave_class::t_name ("class"); void -octave_class::register_type (void) +octave_class::register_type (octave::type_info& ti) { - t_id = octave_value_typeinfo::register_type - (octave_class::t_name, "<unknown>", - octave_value (new octave_class ())); + t_id = ti.register_type (octave_class::t_name, "<unknown>", + octave_value (new octave_class ())); } octave_class::octave_class (const octave_map& m, const std::string& id,
--- a/libinterp/octave-value/ov-class.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-class.h Fri Jan 05 18:44:53 2018 -0500 @@ -37,7 +37,11 @@ #include "error.h" #include "oct-map.h" #include "ov-base.h" -#include "ov-typeinfo.h" + +namespace octave +{ + class type_info; +} class octave_value_list; @@ -207,7 +211,7 @@ static int static_type_id (void) { return t_id; } static std::string static_type_name (void) { return t_name; } static std::string static_class_name (void) { return "<unknown>"; } - static void register_type (void); + static void register_type (octave::type_info&); private: static int t_id;
--- a/libinterp/octave-value/ov-classdef.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-classdef.cc Fri Jan 05 18:44:53 2018 -0500 @@ -833,11 +833,10 @@ const std::string octave_classdef::t_name ("object"); void -octave_classdef::register_type (void) +octave_classdef::register_type (octave::type_info& ti) { - t_id = octave_value_typeinfo::register_type - (octave_classdef::t_name, "<unknown>", - octave_value (new octave_classdef ())); + t_id = ti.register_type (octave_classdef::t_name, "<unknown>", + octave_value (new octave_classdef ())); } octave_value_list @@ -3344,10 +3343,14 @@ //---------------------------------------------------------------------------- -void -cdef_manager::initialize (void) +cdef_manager::cdef_manager (octave::interpreter& interp) + : m_interpreter (interp), m_all_classes (), m_all_packages (), + m_meta_class (), m_meta_property (), m_meta_method (), + m_meta_package (), m_meta () { - octave_classdef::register_type (); + octave::type_info& ti = m_interpreter.get_type_info (); + + octave_classdef::register_type (ti); // bootstrap cdef_class tmp_handle = make_class ("handle");
--- a/libinterp/octave-value/ov-classdef.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-classdef.h Fri Jan 05 18:44:53 2018 -0500 @@ -45,6 +45,7 @@ { class interpreter; class tree_classdef; + class type_info; } // This is mainly a boostrap class to declare the expected interface. @@ -1547,7 +1548,7 @@ static int static_type_id (void) { return t_id; } static std::string static_type_name (void) { return t_name; } static std::string static_class_name (void) { return "<unknown>"; } - static void register_type (void); + static void register_type (octave::type_info&); private: @@ -1600,11 +1601,7 @@ { public: - cdef_manager (octave::interpreter& interp) - : m_interpreter (interp), m_all_classes (), m_all_packages (), - m_meta_class (), m_meta_property (), m_meta_method (), - m_meta_package (), m_meta () - { } + cdef_manager (octave::interpreter& interp); // No copying! @@ -1614,8 +1611,6 @@ ~cdef_manager (void) = default; - void initialize (void); - cdef_class find_class (const std::string& name, bool error_if_not_found = true, bool load_if_not_found = true);
--- a/libinterp/octave-value/ov-java.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-java.cc Fri Jan 05 18:44:53 2018 -0500 @@ -2065,12 +2065,12 @@ const std::string octave_java::t_name ("octave_java"); void -octave_java::register_type (void) +octave_java::register_type (octave::type_info& ti) { #if defined (HAVE_JAVA) - t_id = octave_value_typeinfo::register_type - (octave_java::t_name, "<unknown>", octave_value (new octave_java ())); + t_id = ti.register_type (octave_java::t_name, "<unknown>", + octave_value (new octave_java ())); #endif }
--- a/libinterp/octave-value/ov-java.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-java.h Fri Jan 05 18:44:53 2018 -0500 @@ -28,6 +28,11 @@ #include "ov.h" #include "ovl.h" +namespace octave +{ + class type_info; +} + typedef void *voidptr; class OCTINTERP_API octave_java : public octave_base_value @@ -173,7 +178,7 @@ static int static_type_id (void) { return t_id; } static std::string static_type_name (void) { return t_name; } static std::string static_class_name (void) { return "<unknown>"; } - static void register_type (void); + static void register_type (octave::type_info&); private:
--- a/libinterp/octave-value/ov-typeinfo.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-typeinfo.cc Fri Jan 05 18:44:53 2018 -0500 @@ -25,553 +25,980 @@ #endif #include "Array.h" -#include "singleton-cleanup.h" #include "defun.h" #include "error.h" +#include "interpreter.h" +#include "interpreter-private.h" +#include "ops.h" #include "ov-typeinfo.h" - -const int -octave_value_typeinfo::init_tab_sz (16); - -octave_value_typeinfo * -octave_value_typeinfo::instance (nullptr); - -bool -octave_value_typeinfo::instance_ok (void) -{ - bool retval = true; - - if (! instance) - { - instance = new octave_value_typeinfo (); - - if (instance) - singleton_cleanup_list::add (cleanup_instance); - } - - if (! instance) - error ("unable to create value type info object!"); - - return retval; -} - -int -octave_value_typeinfo::register_type (const std::string& t_name, - const std::string& c_name, - const octave_value& val) -{ - return (instance_ok ()) - ? instance->do_register_type (t_name, c_name, val) : -1; -} - -bool -octave_value_typeinfo::register_unary_class_op (octave_value::unary_op op, - octave_value_typeinfo::unary_class_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_unary_class_op (op, f) : false; -} - -bool -octave_value_typeinfo::register_unary_op (octave_value::unary_op op, - int t, - octave_value_typeinfo::unary_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_unary_op (op, t, f) : false; -} - -bool -octave_value_typeinfo::register_non_const_unary_op (octave_value::unary_op op, - int t, - octave_value_typeinfo::non_const_unary_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_non_const_unary_op (op, t, f) : false; -} - -bool -octave_value_typeinfo::register_binary_class_op (octave_value::binary_op op, - octave_value_typeinfo::binary_class_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_binary_class_op (op, f) : false; -} - -bool -octave_value_typeinfo::register_binary_op (octave_value::binary_op op, - int t1, int t2, - octave_value_typeinfo::binary_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_binary_op (op, t1, t2, f) : false; -} - -bool -octave_value_typeinfo::register_binary_class_op (octave_value::compound_binary_op op, - octave_value_typeinfo::binary_class_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_binary_class_op (op, f) : false; -} - -bool -octave_value_typeinfo::register_binary_op (octave_value::compound_binary_op op, - int t1, int t2, - octave_value_typeinfo::binary_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_binary_op (op, t1, t2, f) : false; -} - -bool -octave_value_typeinfo::register_cat_op (int t1, int t2, - octave_value_typeinfo::cat_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_cat_op (t1, t2, f) : false; -} - -bool -octave_value_typeinfo::register_assign_op (octave_value::assign_op op, - int t_lhs, int t_rhs, - octave_value_typeinfo::assign_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_assign_op (op, t_lhs, t_rhs, f) : false; -} - -bool -octave_value_typeinfo::register_assignany_op (octave_value::assign_op op, - int t_lhs, octave_value_typeinfo::assignany_op_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_assignany_op (op, t_lhs, f) : false; -} - -bool -octave_value_typeinfo::register_pref_assign_conv (int t_lhs, int t_rhs, - int t_result) -{ - return (instance_ok ()) - ? instance->do_register_pref_assign_conv (t_lhs, t_rhs, t_result) - : false; -} - -bool -octave_value_typeinfo::register_widening_op (int t, int t_result, - octave_base_value::type_conv_fcn f) -{ - return (instance_ok ()) - ? instance->do_register_widening_op (t, t_result, f) : false; -} +#include "ov.h" // FIXME: we should also store all class names and provide a // way to list them (calling class with nargin == 0?). -int -octave_value_typeinfo::do_register_type (const std::string& t_name, - const std::string& /* c_name */, - const octave_value& val) +static NDArray +as_nd_array (const Array<int>& x) { - int i = 0; - - for (i = 0; i < num_types; i++) - if (t_name == types (i)) - return i; - - int len = types.numel (); - - if (i == len) - { - len *= 2; - - types.resize (dim_vector (len, 1), ""); - - vals.resize (dim_vector (len, 1), octave_value ()); - - unary_ops.resize (dim_vector (octave_value::num_unary_ops, len), nullptr); - - non_const_unary_ops.resize - (dim_vector (octave_value::num_unary_ops, len), nullptr); - - binary_ops.resize - (dim_vector (octave_value::num_binary_ops, len, len), nullptr); - - compound_binary_ops.resize - (dim_vector (octave_value::num_compound_binary_ops, len, len), nullptr); - - cat_ops.resize (dim_vector (len, len), nullptr); - - assign_ops.resize - (dim_vector (octave_value::num_assign_ops, len, len), nullptr); - - assignany_ops.resize - (dim_vector (octave_value::num_assign_ops, len), nullptr); - - pref_assign_conv.resize (dim_vector (len, len), -1); - - widening_ops.resize (dim_vector (len, len), nullptr); - } - - types (i) = t_name; - - vals (i) = val; - - num_types++; - - return i; -} - -bool -octave_value_typeinfo::do_register_unary_class_op (octave_value::unary_op op, - octave_value_typeinfo::unary_class_op_fcn f) -{ - if (lookup_unary_class_op (op)) - { - std::string op_name = octave_value::unary_op_as_string (op); + NDArray retval (x.dims ()); - warning ("duplicate unary operator '%s' for class dispatch", - op_name.c_str ()); - } - - unary_class_ops.checkelem (static_cast<int> (op)) - = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_unary_op (octave_value::unary_op op, - int t, - octave_value_typeinfo::unary_op_fcn f) -{ - if (lookup_unary_op (op, t)) - { - std::string op_name = octave_value::unary_op_as_string (op); - std::string type_name = types(t); - - warning ("duplicate unary operator '%s' for type '%s'", - op_name.c_str (), type_name.c_str ()); - } - - unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f); - - return false; -} + for (int i = 0; i < x.numel (); i++) + retval.xelem(i) = x(i); -bool -octave_value_typeinfo::do_register_non_const_unary_op - (octave_value::unary_op op, int t, - octave_value_typeinfo::non_const_unary_op_fcn f) -{ - if (lookup_non_const_unary_op (op, t)) - { - std::string op_name = octave_value::unary_op_as_string (op); - std::string type_name = types(t); - - warning ("duplicate unary operator '%s' for type '%s'", - op_name.c_str (), type_name.c_str ()); - } - - non_const_unary_ops.checkelem (static_cast<int> (op), t) - = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_binary_class_op (octave_value::binary_op op, - octave_value_typeinfo::binary_class_op_fcn f) -{ - if (lookup_binary_class_op (op)) - { - std::string op_name = octave_value::binary_op_as_string (op); - - warning ("duplicate binary operator '%s' for class dispatch", - op_name.c_str ()); - } - - binary_class_ops.checkelem (static_cast<int> (op)) - = reinterpret_cast<void *> (f); - - return false; + return retval; } -bool -octave_value_typeinfo::do_register_binary_op (octave_value::binary_op op, - int t1, int t2, - octave_value_typeinfo::binary_op_fcn f) -{ - if (lookup_binary_op (op, t1, t2)) - { - std::string op_name = octave_value::binary_op_as_string (op); - std::string t1_name = types(t1); - std::string t2_name = types(t2); - - warning ("duplicate binary operator '%s' for types '%s' and '%s'", - op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); - } - - binary_ops.checkelem (static_cast<int> (op), t1, t2) - = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_binary_class_op (octave_value::compound_binary_op op, - octave_value_typeinfo::binary_class_op_fcn f) -{ - if (lookup_binary_class_op (op)) - { - std::string op_name = octave_value::binary_op_fcn_name (op); - - warning ("duplicate compound binary operator '%s' for class dispatch", - op_name.c_str ()); - } - - compound_binary_class_ops.checkelem (static_cast<int> (op)) - = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_binary_op (octave_value::compound_binary_op op, - int t1, int t2, - octave_value_typeinfo::binary_op_fcn f) -{ - if (lookup_binary_op (op, t1, t2)) - { - std::string op_name = octave_value::binary_op_fcn_name (op); - std::string t1_name = types(t1); - std::string t2_name = types(t2); - - warning ("duplicate compound binary operator '%s' for types '%s' and '%s'", - op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); - } - - compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) - = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_cat_op (int t1, int t2, - octave_value_typeinfo::cat_op_fcn f) -{ - if (lookup_cat_op (t1, t2)) - { - std::string t1_name = types(t1); - std::string t2_name = types(t2); - - warning ("duplicate concatenation operator for types '%s' and '%s'", - t1_name.c_str (), t1_name.c_str ()); - } - - cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_assign_op (octave_value::assign_op op, - int t_lhs, int t_rhs, - octave_value_typeinfo::assign_op_fcn f) +static boolNDArray +as_bool_nd_array (const Array<void *>& x) { - if (lookup_assign_op (op, t_lhs, t_rhs)) - { - std::string op_name = octave_value::assign_op_as_string (op); - std::string t_lhs_name = types(t_lhs); - std::string t_rhs_name = types(t_rhs); - - warning ("duplicate assignment operator '%s' for types '%s' and '%s'", - op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ()); - } - - assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) - = reinterpret_cast<void *> (f); - - return false; -} - -bool -octave_value_typeinfo::do_register_assignany_op (octave_value::assign_op op, - int t_lhs, octave_value_typeinfo::assignany_op_fcn f) -{ - if (lookup_assignany_op (op, t_lhs)) - { - std::string op_name = octave_value::assign_op_as_string (op); - std::string t_lhs_name = types(t_lhs); - - warning ("duplicate assignment operator '%s' for types '%s'", - op_name.c_str (), t_lhs_name.c_str ()); - } - - assignany_ops.checkelem (static_cast<int> (op), t_lhs) - = reinterpret_cast<void *> (f); - - return false; -} + boolNDArray retval (x.dims ()); -bool -octave_value_typeinfo::do_register_pref_assign_conv (int t_lhs, int t_rhs, - int t_result) -{ - if (lookup_pref_assign_conv (t_lhs, t_rhs) >= 0) - { - std::string t_lhs_name = types(t_lhs); - std::string t_rhs_name = types(t_rhs); - - warning ("overriding assignment conversion for types '%s' and '%s'", - t_lhs_name.c_str (), t_rhs_name.c_str ()); - } - - pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result; - - return false; -} - -bool -octave_value_typeinfo::do_register_widening_op - (int t, int t_result, octave_base_value::type_conv_fcn f) -{ - if (lookup_widening_op (t, t_result)) - { - std::string t_name = types(t); - std::string t_result_name = types(t_result); - - warning ("overriding widening op for '%s' to '%s'", - t_name.c_str (), t_result_name.c_str ()); - } - - widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f); - - return false; -} - -octave_value -octave_value_typeinfo::do_lookup_type (const std::string& nm) -{ - octave_value retval; - - for (int i = 0; i < num_types; i++) - { - if (nm == types(i)) - { - retval = vals(i); - retval.make_unique (); - break; - } - } + for (octave_idx_type i = 0; i < x.numel (); i++) + retval.xelem (i) = x(i); return retval; } -octave_value_typeinfo::unary_class_op_fcn -octave_value_typeinfo::do_lookup_unary_class_op (octave_value::unary_op op) -{ - void *f = unary_class_ops.checkelem (static_cast<int> (op)); - return reinterpret_cast<octave_value_typeinfo::unary_class_op_fcn> (f); -} - -octave_value_typeinfo::unary_op_fcn -octave_value_typeinfo::do_lookup_unary_op (octave_value::unary_op op, int t) -{ - void *f = unary_ops.checkelem (static_cast<int> (op), t); - return reinterpret_cast<octave_value_typeinfo::unary_op_fcn> (f); -} - -octave_value_typeinfo::non_const_unary_op_fcn -octave_value_typeinfo::do_lookup_non_const_unary_op - (octave_value::unary_op op, int t) +namespace octave { - void *f = non_const_unary_ops.checkelem (static_cast<int> (op), t); - return reinterpret_cast<octave_value_typeinfo::non_const_unary_op_fcn> (f); -} + type_info::type_info (int init_tab_sz) + : num_types (0), types (dim_vector (init_tab_sz, 1), ""), + vals (dim_vector (init_tab_sz, 1)), + unary_class_ops (dim_vector (octave_value::num_unary_ops, 1), nullptr), + unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr), + non_const_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr), + binary_class_ops (dim_vector (octave_value::num_binary_ops, 1), nullptr), + binary_ops (dim_vector (octave_value::num_binary_ops, init_tab_sz, init_tab_sz), nullptr), + compound_binary_class_ops (dim_vector (octave_value::num_compound_binary_ops, 1), nullptr), + compound_binary_ops (dim_vector (octave_value::num_compound_binary_ops, init_tab_sz, init_tab_sz), nullptr), + cat_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr), + assign_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz, init_tab_sz), nullptr), + assignany_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz), nullptr), + pref_assign_conv (dim_vector (init_tab_sz, init_tab_sz), -1), + widening_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr) + { + install_types (*this); + + install_ops (*this); + } + + int type_info::register_type (const std::string& t_name, + const std::string& /* c_name */, + const octave_value& val, + bool abort_on_duplicate) + { + int i = 0; + + for (i = 0; i < num_types; i++) + { + if (t_name == types (i)) + { + if (abort_on_duplicate) + { + std::cerr << "duplicate type " << t_name << std::endl; + abort (); + } + + warning ("duplicate type %s\n", t_name.c_str ()); + + return i; + } + } + + int len = types.numel (); + + if (i == len) + { + len *= 2; + + types.resize (dim_vector (len, 1), ""); + + vals.resize (dim_vector (len, 1), octave_value ()); + + unary_ops.resize + (dim_vector (octave_value::num_unary_ops, len), nullptr); + + non_const_unary_ops.resize + (dim_vector (octave_value::num_unary_ops, len), nullptr); + + binary_ops.resize + (dim_vector (octave_value::num_binary_ops, len, len), nullptr); + + compound_binary_ops.resize + (dim_vector (octave_value::num_compound_binary_ops, len, len), + nullptr); + + cat_ops.resize (dim_vector (len, len), nullptr); + + assign_ops.resize + (dim_vector (octave_value::num_assign_ops, len, len), nullptr); + + assignany_ops.resize + (dim_vector (octave_value::num_assign_ops, len), nullptr); + + pref_assign_conv.resize (dim_vector (len, len), -1); + + widening_ops.resize (dim_vector (len, len), nullptr); + } + + types (i) = t_name; + + vals (i) = val; + + num_types++; + + return i; + } + + bool type_info::register_unary_class_op (octave_value::unary_op op, + type_info::unary_class_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_unary_class_op (op)) + { + std::string op_name = octave_value::unary_op_as_string (op); + + if (abort_on_duplicate) + { + std::cerr << "duplicate unary operator '" << op_name + << "' for class dispatch" << std::endl; + abort (); + } + + warning ("duplicate unary operator '%s' for class dispatch", + op_name.c_str ()); + } + + unary_class_ops.checkelem (static_cast<int> (op)) + = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_unary_op (octave_value::unary_op op, int t, + unary_op_fcn f, bool abort_on_duplicate) + { + if (lookup_unary_op (op, t)) + { + std::string op_name = octave_value::unary_op_as_string (op); + std::string type_name = types(t); + + if (abort_on_duplicate) + { + std::cerr << "duplicate unary operator '" << op_name + << "' for type '" << type_name << "'" << std::endl; + abort (); + } + + warning ("duplicate unary operator '%s' for type '%s'", + op_name.c_str (), type_name.c_str ()); + } + + unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f); + + return false; + } + + bool + type_info::register_non_const_unary_op (octave_value::unary_op op, int t, + type_info::non_const_unary_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_non_const_unary_op (op, t)) + { + std::string op_name = octave_value::unary_op_as_string (op); + std::string type_name = types(t); + + if (abort_on_duplicate) + { + std::cerr << "duplicate unary operator '" << op_name + << "' for type '" << type_name << "'" << std::endl; + abort (); + } + + warning ("duplicate unary operator '%s' for type '%s'", + op_name.c_str (), type_name.c_str ()); + } + + non_const_unary_ops.checkelem (static_cast<int> (op), t) + = reinterpret_cast<void *> (f); + + return false; + } -octave_value_typeinfo::binary_class_op_fcn -octave_value_typeinfo::do_lookup_binary_class_op (octave_value::binary_op op) -{ - void *f = binary_class_ops.checkelem (static_cast<int> (op)); - return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f); -} + bool + type_info::register_binary_class_op (octave_value::binary_op op, + type_info::binary_class_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_binary_class_op (op)) + { + std::string op_name = octave_value::binary_op_as_string (op); + + if (abort_on_duplicate) + { + + std::cerr << "duplicate binary operator '" << op_name + << "' for class dispatch" << std::endl; + abort (); + } + + warning ("duplicate binary operator '%s' for class dispatch", + op_name.c_str ()); + } + + binary_class_ops.checkelem (static_cast<int> (op)) + = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_binary_op (octave_value::binary_op op, + int t1, int t2, + type_info::binary_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_binary_op (op, t1, t2)) + { + std::string op_name = octave_value::binary_op_as_string (op); + std::string t1_name = types(t1); + std::string t2_name = types(t2); + + if (abort_on_duplicate) + { + std::cerr << "duplicate binary operator '" << op_name + << "' for types '" << t1_name << "' and '" + << t2_name << "'" << std::endl; + abort (); + } + + warning ("duplicate binary operator '%s' for types '%s' and '%s'", + op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); + } + + binary_ops.checkelem (static_cast<int> (op), t1, t2) + = reinterpret_cast<void *> (f); + + return false; + } + + bool + type_info::register_binary_class_op (octave_value::compound_binary_op op, + type_info::binary_class_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_binary_class_op (op)) + { + std::string op_name = octave_value::binary_op_fcn_name (op); + + if (abort_on_duplicate) + { + std::cerr << "duplicate compound binary operator '" + << op_name << "' for class dispatch" << std::endl; + abort (); + } + + warning ("duplicate compound binary operator '%s' for class dispatch", + op_name.c_str ()); + } + + compound_binary_class_ops.checkelem (static_cast<int> (op)) + = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_binary_op (octave_value::compound_binary_op op, + int t1, int t2, + type_info::binary_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_binary_op (op, t1, t2)) + { + std::string op_name = octave_value::binary_op_fcn_name (op); + std::string t1_name = types(t1); + std::string t2_name = types(t2); + + if (abort_on_duplicate) + { + std::cerr << "duplicate compound binary operator '" + << op_name << "' for types '" << t1_name + << "' and '" << t2_name << "'" << std::endl; + abort (); + } + + warning ("duplicate compound binary operator '%s' for types '%s' and '%s'", + op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); + } + + compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) + = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_cat_op (int t1, int t2, type_info::cat_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_cat_op (t1, t2)) + { + std::string t1_name = types(t1); + std::string t2_name = types(t2); + + if (abort_on_duplicate) + { + std::cerr << "duplicate concatenation operator for types '" + << t1_name << "' and '" << t2_name << "'" << std::endl; + abort (); + } + + warning ("duplicate concatenation operator for types '%s' and '%s'", + t1_name.c_str (), t1_name.c_str ()); + } + + cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs, + type_info::assign_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_assign_op (op, t_lhs, t_rhs)) + { + std::string op_name = octave_value::assign_op_as_string (op); + std::string t_lhs_name = types(t_lhs); + std::string t_rhs_name = types(t_rhs); + + if (abort_on_duplicate) + { + std::cerr << "duplicate assignment operator '" + << op_name << "' for types '" << t_lhs_name + << "' and '" << t_rhs_name << "'" << std::endl; + abort (); + } + + warning ("duplicate assignment operator '%s' for types '%s' and '%s'", + op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ()); + } + + assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) + = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_assignany_op (octave_value::assign_op op, int t_lhs, + type_info::assignany_op_fcn f, + bool abort_on_duplicate) + { + if (lookup_assignany_op (op, t_lhs)) + { + std::string op_name = octave_value::assign_op_as_string (op); + std::string t_lhs_name = types(t_lhs); -octave_value_typeinfo::binary_op_fcn -octave_value_typeinfo::do_lookup_binary_op (octave_value::binary_op op, - int t1, int t2) -{ - void *f = binary_ops.checkelem (static_cast<int> (op), t1, t2); - return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f); -} + if (abort_on_duplicate) + { + std::cerr << "duplicate assignment operator '" << op_name + << "' for types '" << t_lhs_name << "'" << std::endl; + abort (); + } + + warning ("duplicate assignment operator '%s' for types '%s'", + op_name.c_str (), t_lhs_name.c_str ()); + } + + assignany_ops.checkelem (static_cast<int> (op), t_lhs) + = reinterpret_cast<void *> (f); + + return false; + } + + bool type_info::register_pref_assign_conv (int t_lhs, int t_rhs, + int t_result, + bool abort_on_duplicate) + { + if (lookup_pref_assign_conv (t_lhs, t_rhs) >= 0) + { + std::string t_lhs_name = types(t_lhs); + std::string t_rhs_name = types(t_rhs); + + if (abort_on_duplicate) + { + std::cerr << "overriding assignment conversion for types '" + << t_lhs_name << "' and '" << t_rhs_name << "'" + << std::endl; + abort (); + } + + warning ("overriding assignment conversion for types '%s' and '%s'", + t_lhs_name.c_str (), t_rhs_name.c_str ()); + } + + pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result; + + return false; + } + + bool type_info::register_widening_op (int t, int t_result, + octave_base_value::type_conv_fcn f, + bool abort_on_duplicate) + { + if (lookup_widening_op (t, t_result)) + { + std::string t_name = types(t); + std::string t_result_name = types(t_result); + + if (abort_on_duplicate) + { + std::cerr << "overriding widening op for '" << t_name + << "' to '" << t_result_name << "'" << std::endl; + abort (); + } + + warning ("overriding widening op for '%s' to '%s'", + t_name.c_str (), t_result_name.c_str ()); + } + + widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f); + + return false; + } + + octave_value type_info::lookup_type (const std::string& nm) + { + octave_value retval; + + for (int i = 0; i < num_types; i++) + { + if (nm == types(i)) + { + retval = vals(i); + retval.make_unique (); + break; + } + } + + return retval; + } + + type_info::unary_class_op_fcn + type_info::lookup_unary_class_op (octave_value::unary_op op) + { + void *f = unary_class_ops.checkelem (static_cast<int> (op)); + return reinterpret_cast<type_info::unary_class_op_fcn> (f); + } + + type_info::unary_op_fcn + type_info::lookup_unary_op (octave_value::unary_op op, int t) + { + void *f = unary_ops.checkelem (static_cast<int> (op), t); + return reinterpret_cast<type_info::unary_op_fcn> (f); + } + + type_info::non_const_unary_op_fcn + type_info::lookup_non_const_unary_op (octave_value::unary_op op, int t) + { + void *f = non_const_unary_ops.checkelem (static_cast<int> (op), t); + return reinterpret_cast<type_info::non_const_unary_op_fcn> (f); + } + + type_info::binary_class_op_fcn + type_info::lookup_binary_class_op (octave_value::binary_op op) + { + void *f = binary_class_ops.checkelem (static_cast<int> (op)); + return reinterpret_cast<type_info::binary_class_op_fcn> (f); + } + + type_info::binary_op_fcn + type_info::lookup_binary_op (octave_value::binary_op op, int t1, int t2) + { + void *f = binary_ops.checkelem (static_cast<int> (op), t1, t2); + return reinterpret_cast<type_info::binary_op_fcn> (f); + } + + type_info::binary_class_op_fcn + type_info::lookup_binary_class_op (octave_value::compound_binary_op op) + { + void *f = compound_binary_class_ops.checkelem (static_cast<int> (op)); + return reinterpret_cast<type_info::binary_class_op_fcn> (f); + } + + type_info::binary_op_fcn + type_info::lookup_binary_op (octave_value::compound_binary_op op, + int t1, int t2) + { + void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2); + return reinterpret_cast<type_info::binary_op_fcn> (f); + } + + type_info::cat_op_fcn + type_info::lookup_cat_op (int t1, int t2) + { + void *f = cat_ops.checkelem (t1, t2); + return reinterpret_cast<type_info::cat_op_fcn> (f); + } + + type_info::assign_op_fcn + type_info::lookup_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs) + { + void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs); + return reinterpret_cast<type_info::assign_op_fcn> (f); + } + + type_info::assignany_op_fcn + type_info::lookup_assignany_op (octave_value::assign_op op, int t_lhs) + { + void *f = assignany_ops.checkelem (static_cast<int> (op), t_lhs); + return reinterpret_cast<type_info::assignany_op_fcn> (f); + } + + int + type_info::lookup_pref_assign_conv (int t_lhs, int t_rhs) + { + return pref_assign_conv.checkelem (t_lhs, t_rhs); + } + + octave_base_value::type_conv_fcn + type_info::lookup_widening_op (int t, int t_result) + { + void *f = widening_ops.checkelem (t, t_result); + return reinterpret_cast<octave_base_value::type_conv_fcn> (f); + } + + string_vector + type_info::installed_type_names (void) const + { + string_vector retval (num_types); -octave_value_typeinfo::binary_class_op_fcn -octave_value_typeinfo::do_lookup_binary_class_op (octave_value::compound_binary_op op) -{ - void *f = compound_binary_class_ops.checkelem (static_cast<int> (op)); - return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f); + for (int i = 0; i < num_types; i++) + retval(i) = types(i); + + return retval; + } + + octave_scalar_map + type_info::unary_ops_map (void) const + { + octave_scalar_map retval; + + int len = std::min (static_cast<int> (non_const_unary_ops.columns ()), + num_types); + + dim_vector tab_dims (1, len); + + for (int j = 0; j < octave_value::num_unary_ops; j++) + { + boolNDArray tab (tab_dims); + + for (int i = 0; i < len; i++) + tab.xelem (i) = (unary_ops(j,i) != nullptr); + + octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j); + + retval.setfield (octave_value::unary_op_as_string (op_id), tab); + } + + return retval; + } + + octave_scalar_map + type_info::non_const_unary_ops_map (void) const + { + octave_scalar_map retval; + + int len = std::min (static_cast<int> (non_const_unary_ops.columns ()), + num_types); + + dim_vector tab_dims (1, len); + + for (int j = 0; j < octave_value::num_unary_ops; j++) + { + boolNDArray tab (tab_dims); + + for (int i = 0; i < len; i++) + tab.xelem (i) = (non_const_unary_ops(j,i) != nullptr); + + octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j); + + retval.setfield (octave_value::unary_op_as_string (op_id), tab); + } + + return retval; + } + + octave_scalar_map + type_info::binary_ops_map (void) const + { + octave_scalar_map retval; + + int len = std::min (static_cast<int> (binary_ops.columns ()), num_types); + + dim_vector tab_dims (len, len); + + for (int k = 0; k < octave_value::num_binary_ops; k++) + { + boolNDArray tab (tab_dims); + + for (int j = 0; j < len; j++) + for (int i = 0; i < len; i++) + tab.xelem (j,i) = (binary_ops(k,j,i) != nullptr); + + octave_value::binary_op op_id = static_cast<octave_value::binary_op> (k); + + retval.setfield (octave_value::binary_op_as_string (op_id), tab); + } + + return retval; + } + + octave_scalar_map + type_info::compound_binary_ops_map (void) const + { + octave_scalar_map retval; + + int len = std::min (static_cast<int> (compound_binary_ops.columns ()), + num_types); + + dim_vector tab_dims (len, len); + + for (int k = 0; k < octave_value::num_compound_binary_ops; k++) + { + boolNDArray tab (tab_dims); + + for (int j = 0; j < len; j++) + for (int i = 0; i < len; i++) + tab.xelem (j,i) = (compound_binary_ops(k,j,i) != nullptr); + + octave_value::compound_binary_op op_id + = static_cast<octave_value::compound_binary_op> (k); + + retval.setfield (octave_value::binary_op_fcn_name (op_id), tab); + } + + return retval; + } + + octave_scalar_map + type_info::assign_ops_map (void) const + { + octave_scalar_map retval; + + int len = std::min (static_cast<int> (assign_ops.columns ()), num_types); + + dim_vector tab_dims (len, len); + + for (int k = 0; k < octave_value::num_assign_ops; k++) + { + boolNDArray tab (tab_dims); + + for (int j = 0; j < len; j++) + for (int i = 0; i < len; i++) + tab.xelem (j,i) = (assign_ops(k,j,i) != nullptr); + + octave_value::assign_op op_id = static_cast<octave_value::assign_op> (k); + + retval.setfield (octave_value::assign_op_as_string (op_id), tab); + } + + return retval; + } + + octave_scalar_map + type_info::assignany_ops_map (void) const + { + octave_scalar_map retval; + + int len = std::min (static_cast<int> (assignany_ops.columns ()), num_types); + + dim_vector tab_dims (1, len); + + for (int j = 0; j < octave_value::num_assign_ops; j++) + { + boolNDArray tab (tab_dims); + + for (int i = 0; i < len; i++) + tab.xelem (i) = (assignany_ops(j,i) != nullptr); + + octave_value::assign_op op_id = static_cast<octave_value::assign_op> (j); + + retval.setfield (octave_value::assign_op_as_string (op_id), tab); + } + + return retval; + } + + octave_scalar_map + type_info::installed_type_info (void) const + { + octave_scalar_map retval; + + retval.setfield ("types", octave_value (Cell (installed_type_names ()))); + retval.setfield ("unary_ops", unary_ops_map ()); + retval.setfield ("non_const_unary_ops", non_const_unary_ops_map ()); + retval.setfield ("binary_ops", binary_ops_map ()); + retval.setfield ("compound_binary_ops", compound_binary_ops_map ()); + retval.setfield ("cat_ops", as_bool_nd_array (cat_ops)); + retval.setfield ("assign_ops", assign_ops_map ()); + retval.setfield ("assignany_ops", assignany_ops_map ()); + retval.setfield ("pref_assign_conv", as_nd_array (pref_assign_conv)); + retval.setfield ("widening_ops", as_bool_nd_array (widening_ops)); + + return retval; + } } -octave_value_typeinfo::binary_op_fcn -octave_value_typeinfo::do_lookup_binary_op (octave_value::compound_binary_op op, - int t1, int t2) -{ - void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2); - return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f); -} - -octave_value_typeinfo::cat_op_fcn -octave_value_typeinfo::do_lookup_cat_op (int t1, int t2) +namespace octave_value_typeinfo { - void *f = cat_ops.checkelem (t1, t2); - return reinterpret_cast<octave_value_typeinfo::cat_op_fcn> (f); -} + int register_type (const std::string& t_name, const std::string& c_name, + const octave_value& val) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_type"); + + return type_info.register_type (t_name, c_name, val); + } + + bool register_unary_class_op (octave_value::unary_op op, + unary_class_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_unary_class_op"); + + return type_info.register_unary_class_op (op, f); + } + + bool register_unary_op (octave_value::unary_op op, + int t, unary_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_unary_op"); + + return type_info.register_unary_op (op, t, f); + } + + bool register_non_const_unary_op (octave_value::unary_op op, + int t, non_const_unary_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_non_const_unary_op"); + + return type_info.register_non_const_unary_op (op, t, f); + } + + bool register_binary_class_op (octave_value::binary_op op, + binary_class_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_binary_class_op"); + + return type_info.register_binary_class_op (op, f); + } + + bool register_binary_op (octave_value::binary_op op, + int t1, int t2, binary_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_binary_op"); + + return type_info.register_binary_op (op, t1, t2, f); + } + + bool register_binary_class_op (octave_value::compound_binary_op op, + binary_class_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_binary_class_op"); + + return type_info.register_binary_class_op (op, f); + } + + bool register_binary_op (octave_value::compound_binary_op op, + int t1, int t2, binary_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_binary_op"); + + return type_info.register_binary_op (op, t1, t2, f); + } + + bool register_cat_op (int t1, int t2, cat_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_cat_op"); + + return type_info.register_cat_op (t1, t2, f); + } + + bool register_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs, assign_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_assign_op"); + + return type_info.register_assign_op (op, t_lhs, t_rhs, f); + } + + bool register_assignany_op (octave_value::assign_op op, + int t_lhs, assignany_op_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_assignany_op"); + + return type_info.register_assignany_op (op, t_lhs, f); + } + + bool register_pref_assign_conv (int t_lhs, int t_rhs, int t_result) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_pref_assign_conv"); + + return type_info.register_pref_assign_conv (t_lhs, t_rhs, t_result); + } + + bool register_widening_op (int t, int t_result, + octave_base_value::type_conv_fcn f) + { + octave::type_info& type_info + = octave::__get_type_info__ ("register_widening_op"); + + return type_info.register_widening_op (t, t_result, f); + } + + octave_value lookup_type (const std::string& nm) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_type"); -octave_value_typeinfo::assign_op_fcn -octave_value_typeinfo::do_lookup_assign_op (octave_value::assign_op op, - int t_lhs, int t_rhs) -{ - void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs); - return reinterpret_cast<octave_value_typeinfo::assign_op_fcn> (f); + return type_info.lookup_type (nm); + } + + unary_class_op_fcn lookup_unary_class_op (octave_value::unary_op op) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_unary_class_op"); + + return type_info.lookup_unary_class_op (op); + } + + unary_op_fcn lookup_unary_op (octave_value::unary_op op, int t) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_unary_op"); + + return type_info.lookup_unary_op (op, t); + } + + non_const_unary_op_fcn + lookup_non_const_unary_op (octave_value::unary_op op, int t) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_non_const_unary_op"); + + return type_info.lookup_non_const_unary_op (op, t); + } + + binary_class_op_fcn + lookup_binary_class_op (octave_value::binary_op op) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_binary_class_op"); + + return type_info.lookup_binary_class_op (op); + } + + binary_op_fcn + lookup_binary_op (octave_value::binary_op op, int t1, int t2) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_binary_op"); + + return type_info.lookup_binary_op (op, t1, t2); + } + + binary_class_op_fcn + lookup_binary_class_op (octave_value::compound_binary_op op) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_binary_class_op"); + + return type_info.lookup_binary_class_op (op); + } + + binary_op_fcn + lookup_binary_op (octave_value::compound_binary_op op, int t1, int t2) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_binary_op"); + + return type_info.lookup_binary_op (op, t1, t2); + } + + cat_op_fcn lookup_cat_op (int t1, int t2) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_cat_op"); + + return type_info.lookup_cat_op (t1, t2); + } + + assign_op_fcn + lookup_assign_op (octave_value::assign_op op, int t_lhs, int t_rhs) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_assign_op"); + + return type_info.lookup_assign_op (op, t_lhs, t_rhs); + } + + assignany_op_fcn + lookup_assignany_op (octave_value::assign_op op, int t_lhs) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_assignany_op"); + + return type_info.lookup_assignany_op (op, t_lhs); + } + + int lookup_pref_assign_conv (int t_lhs, int t_rhs) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_pref_assign_conv"); + + return type_info.lookup_pref_assign_conv (t_lhs, t_rhs); + } + + octave_base_value::type_conv_fcn + lookup_widening_op (int t, int t_result) + { + octave::type_info& type_info + = octave::__get_type_info__ ("lookup_widening_op"); + + return type_info.lookup_widening_op (t, t_result); + } + + string_vector installed_type_names (void) + { + octave::type_info& type_info + = octave::__get_type_info__ ("installed_type_names"); + + return type_info.installed_type_names (); + } + + octave_scalar_map installed_type_info (void) + { + octave::type_info& type_info + = octave::__get_type_info__ ("installed_type_info"); + + return type_info.installed_type_info (); + } } -octave_value_typeinfo::assignany_op_fcn -octave_value_typeinfo::do_lookup_assignany_op (octave_value::assign_op op, - int t_lhs) -{ - void *f = assignany_ops.checkelem (static_cast<int> (op), t_lhs); - return reinterpret_cast<octave_value_typeinfo::assignany_op_fcn> (f); -} - -int -octave_value_typeinfo::do_lookup_pref_assign_conv (int t_lhs, int t_rhs) -{ - return pref_assign_conv.checkelem (t_lhs, t_rhs); -} - -octave_base_value::type_conv_fcn -octave_value_typeinfo::do_lookup_widening_op (int t, int t_result) -{ - void *f = widening_ops.checkelem (t, t_result); - return reinterpret_cast<octave_base_value::type_conv_fcn> (f); -} - -string_vector -octave_value_typeinfo::do_installed_type_names (void) const -{ - string_vector retval (num_types); - - for (int i = 0; i < num_types; i++) - retval(i) = types(i); - - return retval; -} - -DEFUN (typeinfo, args, , - doc: /* -*- texinfo -*- +DEFMETHOD (typeinfo, interp, args, , + doc: /* -*- texinfo -*- @deftypefn {} {} typeinfo () @deftypefnx {} {} typeinfo (@var{expr}) @@ -588,7 +1015,11 @@ print_usage (); if (nargin == 0) - return ovl (Cell (octave_value_typeinfo::installed_type_names ())); + { + octave::type_info& type_info = interp.get_type_info (); + + return ovl (Cell (type_info.installed_type_names ())); + } else return ovl (args(0).type_name ()); } @@ -689,200 +1120,8 @@ %!error typeinfo ("foo", 1) */ -static boolNDArray -as_bool_nd_array (const Array<void *>& x) -{ - boolNDArray retval (x.dims ()); - - for (octave_idx_type i = 0; i < x.numel (); i++) - retval.xelem (i) = x(i); - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::unary_ops_map (void) const -{ - octave_scalar_map retval; - - int len = std::min (static_cast<int> (non_const_unary_ops.columns ()), - num_types); - - dim_vector tab_dims (1, len); - - for (int j = 0; j < octave_value::num_unary_ops; j++) - { - boolNDArray tab (tab_dims); - - for (int i = 0; i < len; i++) - tab.xelem (i) = (unary_ops(j,i) != nullptr); - - octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j); - - retval.setfield (octave_value::unary_op_as_string (op_id), tab); - } - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::non_const_unary_ops_map (void) const -{ - octave_scalar_map retval; - - int len = std::min (static_cast<int> (non_const_unary_ops.columns ()), - num_types); - - dim_vector tab_dims (1, len); - - for (int j = 0; j < octave_value::num_unary_ops; j++) - { - boolNDArray tab (tab_dims); - - for (int i = 0; i < len; i++) - tab.xelem (i) = (non_const_unary_ops(j,i) != nullptr); - - octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j); - - retval.setfield (octave_value::unary_op_as_string (op_id), tab); - } - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::binary_ops_map (void) const -{ - octave_scalar_map retval; - - int len = std::min (static_cast<int> (binary_ops.columns ()), num_types); - - dim_vector tab_dims (len, len); - - for (int k = 0; k < octave_value::num_binary_ops; k++) - { - boolNDArray tab (tab_dims); - - for (int j = 0; j < len; j++) - for (int i = 0; i < len; i++) - tab.xelem (j,i) = (binary_ops(k,j,i) != nullptr); - - octave_value::binary_op op_id = static_cast<octave_value::binary_op> (k); - - retval.setfield (octave_value::binary_op_as_string (op_id), tab); - } - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::compound_binary_ops_map (void) const -{ - octave_scalar_map retval; - - int len = std::min (static_cast<int> (compound_binary_ops.columns ()), - num_types); - - dim_vector tab_dims (len, len); - - for (int k = 0; k < octave_value::num_compound_binary_ops; k++) - { - boolNDArray tab (tab_dims); - - for (int j = 0; j < len; j++) - for (int i = 0; i < len; i++) - tab.xelem (j,i) = (compound_binary_ops(k,j,i) != nullptr); - - octave_value::compound_binary_op op_id - = static_cast<octave_value::compound_binary_op> (k); - - retval.setfield (octave_value::binary_op_fcn_name (op_id), tab); - } - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::assign_ops_map (void) const -{ - octave_scalar_map retval; - - int len = std::min (static_cast<int> (assign_ops.columns ()), num_types); - - dim_vector tab_dims (len, len); - - for (int k = 0; k < octave_value::num_assign_ops; k++) - { - boolNDArray tab (tab_dims); - - for (int j = 0; j < len; j++) - for (int i = 0; i < len; i++) - tab.xelem (j,i) = (assign_ops(k,j,i) != nullptr); - - octave_value::assign_op op_id = static_cast<octave_value::assign_op> (k); - - retval.setfield (octave_value::assign_op_as_string (op_id), tab); - } - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::assignany_ops_map (void) const -{ - octave_scalar_map retval; - - int len = std::min (static_cast<int> (assignany_ops.columns ()), num_types); - - dim_vector tab_dims (1, len); - - for (int j = 0; j < octave_value::num_assign_ops; j++) - { - boolNDArray tab (tab_dims); - - for (int i = 0; i < len; i++) - tab.xelem (i) = (assignany_ops(j,i) != nullptr); - - octave_value::assign_op op_id = static_cast<octave_value::assign_op> (j); - - retval.setfield (octave_value::assign_op_as_string (op_id), tab); - } - - return retval; -} - -static NDArray -as_nd_array (const Array<int>& x) -{ - NDArray retval (x.dims ()); - - for (int i = 0; i < x.numel (); i++) - retval.xelem(i) = x(i); - - return retval; -} - -octave_scalar_map -octave_value_typeinfo::do_installed_type_info (void) const -{ - octave_scalar_map retval; - - retval.setfield ("types", octave_value (Cell (do_installed_type_names ()))); - retval.setfield ("unary_ops", unary_ops_map ()); - retval.setfield ("non_const_unary_ops", non_const_unary_ops_map ()); - retval.setfield ("binary_ops", binary_ops_map ()); - retval.setfield ("compound_binary_ops", compound_binary_ops_map ()); - retval.setfield ("cat_ops", as_bool_nd_array (cat_ops)); - retval.setfield ("assign_ops", assign_ops_map ()); - retval.setfield ("assignany_ops", assignany_ops_map ()); - retval.setfield ("pref_assign_conv", as_nd_array (pref_assign_conv)); - retval.setfield ("widening_ops", as_bool_nd_array (widening_ops)); - - return retval; -} - -DEFUN (__dump_typeinfo__, args, , - doc: /* -*- texinfo -*- +DEFMETHOD (__dump_typeinfo__, interp, args, , + doc: /* -*- texinfo -*- @deftypefn {} {} __dump_typeinfo__ () Undocumented internal function. @end deftypefn */) @@ -890,5 +1129,7 @@ if (args.length () > 0) print_usage (); - return ovl (octave_value_typeinfo::installed_type_info ()); + octave::type_info& type_info = interp.get_type_info (); + + return ovl (type_info.installed_type_info ()); }
--- a/libinterp/octave-value/ov-typeinfo.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov-typeinfo.h Fri Jan 05 18:44:53 2018 -0500 @@ -34,296 +34,341 @@ class string_vector; -class -OCTINTERP_API -octave_value_typeinfo +namespace octave { -public: + class type_info + { + public: - typedef octave_value (*unary_class_op_fcn) (const octave_value&); + typedef octave_value (*unary_class_op_fcn) (const octave_value&); - typedef octave_value (*unary_op_fcn) (const octave_base_value&); + typedef octave_value (*unary_op_fcn) (const octave_base_value&); - typedef void (*non_const_unary_op_fcn) (octave_base_value&); + typedef void (*non_const_unary_op_fcn) (octave_base_value&); - typedef octave_value (*binary_class_op_fcn) + typedef octave_value (*binary_class_op_fcn) (const octave_value&, const octave_value&); - typedef octave_value (*binary_op_fcn) + typedef octave_value (*binary_op_fcn) (const octave_base_value&, const octave_base_value&); - typedef octave_value (*cat_op_fcn) + typedef octave_value (*cat_op_fcn) (octave_base_value&, const octave_base_value&, const Array<octave_idx_type>& ra_idx); - typedef octave_value (*assign_op_fcn) + typedef octave_value (*assign_op_fcn) (octave_base_value&, const octave_value_list&, const octave_base_value&); - typedef octave_value (*assignany_op_fcn) + typedef octave_value (*assignany_op_fcn) (octave_base_value&, const octave_value_list&, const octave_value&); - static bool instance_ok (void); + explicit type_info (int init_tab_sz = 16); - static int register_type (const std::string&, const std::string&, - const octave_value&); + // No copying! + + type_info (const type_info&) = delete; - static bool register_unary_class_op (octave_value::unary_op, - unary_class_op_fcn); + type_info& operator = (const type_info&) = delete; - static bool register_unary_op (octave_value::unary_op, int, unary_op_fcn); + ~type_info (void) = default; - static bool register_non_const_unary_op (octave_value::unary_op, int, - non_const_unary_op_fcn); + // It is intentional that there is no install_type function. - static bool register_binary_class_op (octave_value::binary_op, - binary_class_op_fcn); + bool install_unary_class_op (octave_value::unary_op op, + unary_class_op_fcn f) + { + return register_unary_class_op (op, f, true); + } - static bool register_binary_op (octave_value::binary_op, int, int, - binary_op_fcn); + bool install_unary_op (octave_value::unary_op op, int t, unary_op_fcn f) + { + return register_unary_op (op, t, f, true); + } - static bool register_binary_class_op (octave_value::compound_binary_op, - binary_class_op_fcn); + bool install_non_const_unary_op (octave_value::unary_op op, int t, + non_const_unary_op_fcn f) + { + return register_non_const_unary_op (op, t, f, true); + } - static bool register_binary_op (octave_value::compound_binary_op, int, int, - binary_op_fcn); - - static bool register_cat_op (int, int, cat_op_fcn); - - static bool register_assign_op (octave_value::assign_op, int, int, - assign_op_fcn); + bool install_binary_class_op (octave_value::binary_op op, + binary_class_op_fcn f) + { + return register_binary_class_op (op, f, true); + } - static bool register_assignany_op (octave_value::assign_op, int, - assignany_op_fcn); - - static bool register_pref_assign_conv (int, int, int); + bool install_binary_op (octave_value::binary_op op, int t1, int t2, + binary_op_fcn f) + { + return register_binary_op (op, t1, t2, f, true); + } - static bool - register_widening_op (int, int, octave_base_value::type_conv_fcn); + bool install_binary_class_op (octave_value::compound_binary_op op, + binary_class_op_fcn f) + { + return register_binary_class_op (op, f, true); + } - static octave_value - lookup_type (const std::string& nm) - { - return instance->do_lookup_type (nm); - } + bool install_binary_op (octave_value::compound_binary_op op, + int t_lhs, int t_rhs, binary_op_fcn f) + { + return register_binary_op (op, t_lhs, t_rhs, f, true); + } - static unary_class_op_fcn - lookup_unary_class_op (octave_value::unary_op op) - { - return instance->do_lookup_unary_class_op (op); - } + bool install_cat_op (int t1, int t2, cat_op_fcn f) + { + return register_cat_op (t1, t2, f, true); + } + + bool install_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs, assign_op_fcn f) + { + return register_assign_op (op, t_lhs, t_rhs, f, true); + } - static unary_op_fcn - lookup_unary_op (octave_value::unary_op op, int t) - { - return instance->do_lookup_unary_op (op, t); - } + bool install_assignany_op (octave_value::assign_op op, int t_lhs, + assignany_op_fcn f) + { + return register_assignany_op (op, t_lhs, f, true); + } - static non_const_unary_op_fcn - lookup_non_const_unary_op (octave_value::unary_op op, int t) - { - return instance->do_lookup_non_const_unary_op (op, t); - } + bool install_pref_assign_conv (int t_lhs, int t_rhs, int t_result) + { + return register_pref_assign_conv (t_lhs, t_rhs, t_result, true); + } - static binary_class_op_fcn - lookup_binary_class_op (octave_value::binary_op op) - { - return instance->do_lookup_binary_class_op (op); - } + bool install_widening_op (int t, int t_result, + octave_base_value::type_conv_fcn f) + { + return register_widening_op (t, t_result, f, true); + } + + int register_type (const std::string&, const std::string&, + const octave_value&, bool abort_on_duplicate = false); - static binary_op_fcn - lookup_binary_op (octave_value::binary_op op, int t1, int t2) - { - return instance->do_lookup_binary_op (op, t1, t2); - } + bool register_unary_class_op (octave_value::unary_op, unary_class_op_fcn, + bool abort_on_duplicate = false); + + bool register_unary_op (octave_value::unary_op, int, unary_op_fcn, + bool abort_on_duplicate = false); + + bool register_non_const_unary_op (octave_value::unary_op, int, + non_const_unary_op_fcn, + bool abort_on_duplicate = false); - static binary_class_op_fcn - lookup_binary_class_op (octave_value::compound_binary_op op) - { - return instance->do_lookup_binary_class_op (op); - } + bool register_binary_class_op (octave_value::binary_op, + binary_class_op_fcn, + bool abort_on_duplicate = false); + + bool register_binary_op (octave_value::binary_op, int, int, + binary_op_fcn, bool abort_on_duplicate = false); - static binary_op_fcn - lookup_binary_op (octave_value::compound_binary_op op, int t1, int t2) - { - return instance->do_lookup_binary_op (op, t1, t2); - } + bool register_binary_class_op (octave_value::compound_binary_op, + binary_class_op_fcn, + bool abort_on_duplicate = false); - static cat_op_fcn - lookup_cat_op (int t1, int t2) - { - return instance->do_lookup_cat_op (t1, t2); - } + bool register_binary_op (octave_value::compound_binary_op, int, int, + binary_op_fcn, bool abort_on_duplicate = false); + + bool register_cat_op (int, int, cat_op_fcn, + bool abort_on_duplicate = false); + + bool register_assign_op (octave_value::assign_op, int, int, assign_op_fcn, + bool abort_on_duplicate = false); - static assign_op_fcn - lookup_assign_op (octave_value::assign_op op, int t_lhs, int t_rhs) - { - return instance->do_lookup_assign_op (op, t_lhs, t_rhs); - } + bool register_assignany_op (octave_value::assign_op, int, assignany_op_fcn, + bool abort_on_duplicate = false); + + bool register_pref_assign_conv (int, int, int, + bool abort_on_duplicate = false); + + bool register_widening_op (int, int, octave_base_value::type_conv_fcn, + bool abort_on_duplicate = false); - static assignany_op_fcn - lookup_assignany_op (octave_value::assign_op op, int t_lhs) - { - return instance->do_lookup_assignany_op (op, t_lhs); - } + octave_value lookup_type (const std::string& nm); + + unary_class_op_fcn lookup_unary_class_op (octave_value::unary_op); - static int - lookup_pref_assign_conv (int t_lhs, int t_rhs) - { - return instance->do_lookup_pref_assign_conv (t_lhs, t_rhs); - } + unary_op_fcn lookup_unary_op (octave_value::unary_op, int); + + non_const_unary_op_fcn + lookup_non_const_unary_op (octave_value::unary_op, int); + + binary_class_op_fcn lookup_binary_class_op (octave_value::binary_op); - static octave_base_value::type_conv_fcn - lookup_widening_op (int t, int t_result) - { - return instance->do_lookup_widening_op (t, t_result); - } + binary_op_fcn lookup_binary_op (octave_value::binary_op, int, int); + + binary_class_op_fcn + lookup_binary_class_op (octave_value::compound_binary_op); + + binary_op_fcn + lookup_binary_op (octave_value::compound_binary_op, int, int); + + cat_op_fcn lookup_cat_op (int, int); - static string_vector installed_type_names (void) - { - return instance->do_installed_type_names (); - } + assign_op_fcn lookup_assign_op (octave_value::assign_op, int, int); + + assignany_op_fcn lookup_assignany_op (octave_value::assign_op, int); - static octave_scalar_map installed_type_info (void) - { - return instance->do_installed_type_info (); - } + int lookup_pref_assign_conv (int, int); -protected: + octave_base_value::type_conv_fcn lookup_widening_op (int, int); + + string_vector installed_type_names (void) const; - octave_value_typeinfo (void) - : num_types (0), types (dim_vector (init_tab_sz, 1), ""), - vals (dim_vector (init_tab_sz, 1)), - unary_class_ops (dim_vector (octave_value::num_unary_ops, 1), nullptr), - unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr), - non_const_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr), - binary_class_ops (dim_vector (octave_value::num_binary_ops, 1), nullptr), - binary_ops (dim_vector (octave_value::num_binary_ops, init_tab_sz, init_tab_sz), nullptr), - compound_binary_class_ops (dim_vector (octave_value::num_compound_binary_ops, 1), nullptr), - compound_binary_ops (dim_vector (octave_value::num_compound_binary_ops, init_tab_sz, init_tab_sz), nullptr), - cat_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr), - assign_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz, init_tab_sz), nullptr), - assignany_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz), nullptr), - pref_assign_conv (dim_vector (init_tab_sz, init_tab_sz), -1), - widening_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr) { } + octave_scalar_map installed_type_info (void) const; + + octave_scalar_map unary_ops_map (void) const; + + octave_scalar_map non_const_unary_ops_map (void) const; + + octave_scalar_map binary_ops_map (void) const; + + octave_scalar_map compound_binary_ops_map (void) const; + + octave_scalar_map assign_ops_map (void) const; + + octave_scalar_map assignany_ops_map (void) const; + + private: + + int num_types; - // No copying! + Array<std::string> types; - octave_value_typeinfo (const octave_value_typeinfo&) = delete; + Array<octave_value> vals; - octave_value_typeinfo& operator = (const octave_value_typeinfo&) = delete; + Array<void *> unary_class_ops; - ~octave_value_typeinfo (void) = default; + Array<void *> unary_ops; -private: + Array<void *> non_const_unary_ops; - static const int init_tab_sz; + Array<void *> binary_class_ops; - static octave_value_typeinfo *instance; + Array<void *> binary_ops; - static void cleanup_instance (void) { delete instance; instance = nullptr; } + Array<void *> compound_binary_class_ops; + + Array<void *> compound_binary_ops; - int num_types; + Array<void *> cat_ops; - Array<std::string> types; + Array<void *> assign_ops; - Array<octave_value> vals; + Array<void *> assignany_ops; - Array<void *> unary_class_ops; + Array<int> pref_assign_conv; - Array<void *> unary_ops; - - Array<void *> non_const_unary_ops; + Array<void *> widening_ops; + }; +} - Array<void *> binary_class_ops; +namespace octave_value_typeinfo +{ + typedef octave::type_info::unary_class_op_fcn unary_class_op_fcn; - Array<void *> binary_ops; + typedef octave::type_info::unary_op_fcn unary_op_fcn; - Array<void *> compound_binary_class_ops; + typedef octave::type_info::non_const_unary_op_fcn non_const_unary_op_fcn; - Array<void *> compound_binary_ops; + typedef octave::type_info::binary_class_op_fcn binary_class_op_fcn; - Array<void *> cat_ops; + typedef octave::type_info::binary_op_fcn binary_op_fcn; - Array<void *> assign_ops; + typedef octave::type_info::cat_op_fcn cat_op_fcn; + + typedef octave::type_info::assign_op_fcn assign_op_fcn; - Array<void *> assignany_ops; - - Array<int> pref_assign_conv; + typedef octave::type_info::assignany_op_fcn assignany_op_fcn; - Array<void *> widening_ops; + extern int register_type (const std::string& t_name, + const std::string& c_name, + const octave_value& val); - int do_register_type (const std::string&, const std::string&, - const octave_value&); - - bool do_register_unary_class_op (octave_value::unary_op, unary_class_op_fcn); + OCTAVE_DEPRECATED(4.4, "use octave::type_info::register_unary_class_op instead") + extern bool register_unary_class_op (octave_value::unary_op op, + unary_class_op_fcn f); - bool do_register_unary_op (octave_value::unary_op, int, unary_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_unary_op instead") + extern bool register_unary_op (octave_value::unary_op op, + int t, unary_op_fcn f); - bool do_register_non_const_unary_op (octave_value::unary_op, int, - non_const_unary_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_non_const_unary_op instead") + extern bool register_non_const_unary_op (octave_value::unary_op op, + int t, non_const_unary_op_fcn f); - bool do_register_binary_class_op (octave_value::binary_op, - binary_class_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_class_op instead") + extern bool register_binary_class_op (octave_value::binary_op op, + binary_class_op_fcn f); - bool do_register_binary_op (octave_value::binary_op, int, int, - binary_op_fcn); - - bool do_register_binary_class_op (octave_value::compound_binary_op, - binary_class_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_op instead") + extern bool register_binary_op (octave_value::binary_op op, + int t1, int t2, binary_op_fcn f); - bool do_register_binary_op (octave_value::compound_binary_op, int, int, - binary_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_class_op instead") + extern bool register_binary_class_op (octave_value::compound_binary_op op, + binary_class_op_fcn f); - bool do_register_cat_op (int, int, cat_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_binary_op instead") + extern bool register_binary_op (octave_value::compound_binary_op op, + int t1, int t2, binary_op_fcn f); - bool do_register_assign_op (octave_value::assign_op, int, int, - assign_op_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_cat_op instead") + extern bool register_cat_op (int t1, int t2, cat_op_fcn f); - bool do_register_assignany_op (octave_value::assign_op, int, - assignany_op_fcn); - - bool do_register_pref_assign_conv (int, int, int); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_assign_op instead") + extern bool register_assign_op (octave_value::assign_op op, + int t_lhs, int t_rhs, assign_op_fcn f); - bool do_register_widening_op (int, int, octave_base_value::type_conv_fcn); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_assignany_op instead") + extern bool register_assignany_op (octave_value::assign_op op, + int t_lhs, assignany_op_fcn f); - octave_value do_lookup_type (const std::string& nm); - - unary_class_op_fcn do_lookup_unary_class_op (octave_value::unary_op); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_pref_assign_conv instead") + extern bool register_pref_assign_conv (int t_lhs, int t_rhs, int t_result); - unary_op_fcn do_lookup_unary_op (octave_value::unary_op, int); + OCTAVE_DEPRECATED (4.4, "use octave::type_info::register_widening_op instead") + extern bool register_widening_op (int t, int t_result, + octave_base_value::type_conv_fcn f); - non_const_unary_op_fcn do_lookup_non_const_unary_op - (octave_value::unary_op, int); + extern octave_value lookup_type (const std::string& nm); - binary_class_op_fcn do_lookup_binary_class_op (octave_value::binary_op); - - binary_op_fcn do_lookup_binary_op (octave_value::binary_op, int, int); + extern unary_class_op_fcn lookup_unary_class_op (octave_value::unary_op op); - binary_class_op_fcn do_lookup_binary_class_op (octave_value::compound_binary_op); + extern unary_op_fcn lookup_unary_op (octave_value::unary_op op, int t); + + extern non_const_unary_op_fcn + lookup_non_const_unary_op (octave_value::unary_op op, int t); - binary_op_fcn do_lookup_binary_op (octave_value::compound_binary_op, - int, int); + extern binary_class_op_fcn + lookup_binary_class_op (octave_value::binary_op op); - cat_op_fcn do_lookup_cat_op (int, int); - - assign_op_fcn do_lookup_assign_op (octave_value::assign_op, int, int); + extern binary_op_fcn + lookup_binary_op (octave_value::binary_op op, int t1, int t2); - assignany_op_fcn do_lookup_assignany_op (octave_value::assign_op, int); - - int do_lookup_pref_assign_conv (int, int); + extern binary_class_op_fcn + lookup_binary_class_op (octave_value::compound_binary_op op); - octave_base_value::type_conv_fcn do_lookup_widening_op (int, int); + extern binary_op_fcn + lookup_binary_op (octave_value::compound_binary_op op, int t1, int t2); - string_vector do_installed_type_names (void) const; + extern cat_op_fcn lookup_cat_op (int t1, int t2); + + extern assign_op_fcn + lookup_assign_op (octave_value::assign_op op, int t_lhs, int t_rhs); - octave_scalar_map do_installed_type_info (void) const; + extern assignany_op_fcn + lookup_assignany_op (octave_value::assign_op op, int t_lhs); + + extern int lookup_pref_assign_conv (int t_lhs, int t_rhs); - octave_scalar_map unary_ops_map (void) const; - octave_scalar_map non_const_unary_ops_map (void) const; - octave_scalar_map binary_ops_map (void) const; - octave_scalar_map compound_binary_ops_map (void) const; - octave_scalar_map assign_ops_map (void) const; - octave_scalar_map assignany_ops_map (void) const; -}; + extern octave_base_value::type_conv_fcn + lookup_widening_op (int t, int t_result); + + extern string_vector installed_type_names (void); + + extern octave_scalar_map installed_type_info (void); +} #endif
--- 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, ,
--- a/libinterp/octave-value/ov.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/octave-value/ov.h Fri Jan 05 18:44:53 2018 -0500 @@ -42,6 +42,11 @@ #include "oct-time.h" #include "str-vec.h" +namespace octave +{ + class type_info; +} + class Cell; class mxArray; class octave_map; @@ -1604,7 +1609,7 @@ OV_COMP_BINOP_FN (op_herm_mul) OV_COMP_BINOP_FN (op_mul_herm) -extern OCTINTERP_API void install_types (void); +extern OCTINTERP_API void install_types (octave::type_info&); // Templated value extractors. template <typename Value>
--- a/libinterp/operators/mk-ops.sh Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/mk-ops.sh Fri Jan 05 18:44:53 2018 -0500 @@ -27,27 +27,29 @@ # include "config.h" #endif -extern void install_base_type_conversions (void); +#include "ov-typeinfo.h" + +extern void install_base_type_conversions (octave::type_info&); EOF for file in "$@"; do f=`echo $file | $SED 's,^\./,,; s%^libinterp/operators/op-%%; s%\.cc%%; s%-%_%g'` - echo "extern void install_${f}_ops (void);" + echo "extern void install_${f}_ops (octave::type_info&);" done cat << \EOF void -install_ops (void) +install_ops (octave::type_info& ti) { - install_base_type_conversions (); + install_base_type_conversions (ti); EOF for file in "$@"; do f=`echo $file | $SED 's,^\./,,; s%^libinterp/operators/op-%%; s%\.cc%%; s%-%_%g'` - echo " install_${f}_ops ();" + echo " install_${f}_ops (ti);" done cat << \EOF
--- a/libinterp/operators/op-b-b.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-b-b.cc Fri Jan 05 18:44:53 2018 -0500 @@ -75,28 +75,28 @@ DEFNDCATOP_FN (f_b, float_scalar, bool, float_array, float_array, concat) void -install_b_b_ops (void) +install_b_b_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_bool, not); - INSTALL_UNOP (op_uplus, octave_bool, uplus); - INSTALL_UNOP (op_uminus, octave_bool, uminus); - INSTALL_UNOP (op_transpose, octave_bool, transpose); - INSTALL_UNOP (op_hermitian, octave_bool, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_bool, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_bool, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_bool, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_bool, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_bool, hermitian); - INSTALL_BINOP (op_eq, octave_bool, octave_bool, eq); - INSTALL_BINOP (op_ne, octave_bool, octave_bool, ne); - INSTALL_BINOP (op_el_and, octave_bool, octave_bool, el_and); - INSTALL_BINOP (op_el_or, octave_bool, octave_bool, el_or); + INSTALL_BINOP_TI (ti, op_eq, octave_bool, octave_bool, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_bool, octave_bool, ne); + INSTALL_BINOP_TI (ti, op_el_and, octave_bool, octave_bool, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_bool, octave_bool, el_or); - INSTALL_CATOP (octave_bool, octave_bool, b_b); - INSTALL_CATOP (octave_bool, octave_scalar, b_s); - INSTALL_CATOP (octave_scalar, octave_bool, s_b); - INSTALL_CATOP (octave_bool, octave_float_scalar, b_f); - INSTALL_CATOP (octave_float_scalar, octave_bool, f_b); + INSTALL_CATOP_TI (ti, octave_bool, octave_bool, b_b); + INSTALL_CATOP_TI (ti, octave_bool, octave_scalar, b_s); + INSTALL_CATOP_TI (ti, octave_scalar, octave_bool, s_b); + INSTALL_CATOP_TI (ti, octave_bool, octave_float_scalar, b_f); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_bool, f_b); - INSTALL_ASSIGNCONV (octave_bool, octave_bool, octave_bool_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_bool, octave_bool, octave_bool_matrix); - INSTALL_ASSIGNCONV (octave_bool, octave_null_matrix, octave_bool_matrix); - INSTALL_ASSIGNCONV (octave_bool, octave_null_str, octave_bool_matrix); - INSTALL_ASSIGNCONV (octave_bool, octave_null_sq_str, octave_bool_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_bool, octave_null_matrix, octave_bool_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_bool, octave_null_str, octave_bool_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_bool, octave_null_sq_str, octave_bool_matrix); }
--- a/libinterp/operators/op-b-bm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-b-bm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -62,20 +62,20 @@ } void -install_b_bm_ops (void) +install_b_bm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_el_and, octave_bool, octave_bool_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_bool, octave_bool_matrix, el_or); - INSTALL_BINOP (op_el_and_not, octave_bool, octave_bool_matrix, el_and_not); - INSTALL_BINOP (op_el_or_not, octave_bool, octave_bool_matrix, el_or_not); + INSTALL_BINOP_TI (ti, op_el_and, octave_bool, octave_bool_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_bool, octave_bool_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_and_not, octave_bool, octave_bool_matrix, el_and_not); + INSTALL_BINOP_TI (ti, op_el_or_not, octave_bool, octave_bool_matrix, el_or_not); - INSTALL_CATOP (octave_bool, octave_bool_matrix, b_bm); - INSTALL_CATOP (octave_bool, octave_matrix, b_m); - INSTALL_CATOP (octave_scalar, octave_bool_matrix, s_bm); - INSTALL_CATOP (octave_bool, octave_float_matrix, b_fm); - INSTALL_CATOP (octave_float_scalar, octave_bool_matrix, f_bm); + INSTALL_CATOP_TI (ti, octave_bool, octave_bool_matrix, b_bm); + INSTALL_CATOP_TI (ti, octave_bool, octave_matrix, b_m); + INSTALL_CATOP_TI (ti, octave_scalar, octave_bool_matrix, s_bm); + INSTALL_CATOP_TI (ti, octave_bool, octave_float_matrix, b_fm); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_bool_matrix, f_bm); - INSTALL_ASSIGNCONV (octave_bool, octave_bool_matrix, octave_bool_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_bool, octave_bool_matrix, octave_bool_matrix); - INSTALL_WIDENOP (octave_bool, octave_bool_matrix, bool_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_bool, octave_bool_matrix, bool_matrix_conv); }
--- a/libinterp/operators/op-b-sbm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-b-sbm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -81,21 +81,21 @@ } void -install_b_sbm_ops (void) +install_b_sbm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_eq, octave_bool, octave_sparse_bool_matrix, eq); - INSTALL_BINOP (op_ne, octave_bool, octave_sparse_bool_matrix, ne); + INSTALL_BINOP_TI (ti, op_eq, octave_bool, octave_sparse_bool_matrix, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_bool, octave_sparse_bool_matrix, ne); - INSTALL_BINOP (op_el_and, octave_bool, octave_sparse_bool_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_bool, octave_sparse_bool_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_bool, octave_sparse_bool_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_bool, octave_sparse_bool_matrix, el_or); - INSTALL_CATOP (octave_bool, octave_sparse_bool_matrix, b_sbm); - INSTALL_CATOP (octave_bool, octave_sparse_matrix, b_sm); - INSTALL_CATOP (octave_scalar, octave_sparse_bool_matrix, s_sbm); + INSTALL_CATOP_TI (ti, octave_bool, octave_sparse_bool_matrix, b_sbm); + INSTALL_CATOP_TI (ti, octave_bool, octave_sparse_matrix, b_sm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_sparse_bool_matrix, s_sbm); - INSTALL_ASSIGNCONV (octave_bool, octave_sparse_bool_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_bool, octave_sparse_bool_matrix, octave_bool_matrix); - INSTALL_WIDENOP (octave_bool, octave_sparse_bool_matrix, + INSTALL_WIDENOP_TI (ti, octave_bool, octave_sparse_bool_matrix, sparse_bool_matrix_conv); }
--- a/libinterp/operators/op-bm-b.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-bm-b.cc Fri Jan 05 18:44:53 2018 -0500 @@ -82,39 +82,39 @@ } void -install_bm_b_ops (void) +install_bm_b_ops (octave::type_info& ti) { - INSTALL_BINOP (op_el_and, octave_bool_matrix, octave_bool, el_and); - INSTALL_BINOP (op_el_or, octave_bool_matrix, octave_bool, el_or); - INSTALL_BINOP (op_el_not_and, octave_bool_matrix, octave_bool, el_not_and); - INSTALL_BINOP (op_el_not_or, octave_bool_matrix, octave_bool, el_not_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_bool_matrix, octave_bool, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_bool_matrix, octave_bool, el_or); + INSTALL_BINOP_TI (ti, op_el_not_and, octave_bool_matrix, octave_bool, el_not_and); + INSTALL_BINOP_TI (ti, op_el_not_or, octave_bool_matrix, octave_bool, el_not_or); - INSTALL_CATOP (octave_bool_matrix, octave_bool, bm_b); - INSTALL_CATOP (octave_bool_matrix, octave_scalar, bm_s); - INSTALL_CATOP (octave_matrix, octave_bool, m_b); - INSTALL_CATOP (octave_bool_matrix, octave_float_scalar, bm_f); - INSTALL_CATOP (octave_float_matrix, octave_bool, fm_b); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_bool, bm_b); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_scalar, bm_s); + INSTALL_CATOP_TI (ti, octave_matrix, octave_bool, m_b); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_float_scalar, bm_f); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_bool, fm_b); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_bool, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_bool, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int8_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int8_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int16_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int16_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int32_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int32_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int64_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int64_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint8_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint8_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint16_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint16_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint32_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint32_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint64_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint64_scalar, conv_and_assign); }
--- a/libinterp/operators/op-bm-bm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-bm-bm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -123,78 +123,78 @@ } void -install_bm_bm_ops (void) +install_bm_bm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_bool_matrix, not); - INSTALL_UNOP (op_uplus, octave_bool_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_bool_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_bool_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_bool_matrix, transpose); + INSTALL_UNOP_TI (ti, op_not, octave_bool_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_bool_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_bool_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_bool_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_bool_matrix, transpose); - INSTALL_NCUNOP (op_not, octave_bool_matrix, invert); + INSTALL_NCUNOP_TI (ti, op_not, octave_bool_matrix, invert); - INSTALL_BINOP (op_eq, octave_bool_matrix, octave_bool_matrix, eq); - INSTALL_BINOP (op_ne, octave_bool_matrix, octave_bool_matrix, ne); + INSTALL_BINOP_TI (ti, op_eq, octave_bool_matrix, octave_bool_matrix, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_bool_matrix, octave_bool_matrix, ne); - INSTALL_BINOP (op_el_and, octave_bool_matrix, octave_bool_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_bool_matrix, octave_bool_matrix, el_or); - INSTALL_BINOP (op_el_not_and, octave_bool_matrix, octave_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_bool_matrix, octave_bool_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_bool_matrix, octave_bool_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_not_and, octave_bool_matrix, octave_bool_matrix, el_not_and); - INSTALL_BINOP (op_el_not_or, octave_bool_matrix, octave_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_not_or, octave_bool_matrix, octave_bool_matrix, el_not_or); - INSTALL_BINOP (op_el_and_not, octave_bool_matrix, octave_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_and_not, octave_bool_matrix, octave_bool_matrix, el_and_not); - INSTALL_BINOP (op_el_or_not, octave_bool_matrix, octave_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_or_not, octave_bool_matrix, octave_bool_matrix, el_or_not); - INSTALL_CATOP (octave_bool_matrix, octave_bool_matrix, bm_bm); - INSTALL_CATOP (octave_bool_matrix, octave_matrix, bm_m); - INSTALL_CATOP (octave_matrix, octave_bool_matrix, m_bm); - INSTALL_CATOP (octave_bool_matrix, octave_float_matrix, bm_fm); - INSTALL_CATOP (octave_float_matrix, octave_bool_matrix, fm_bm); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_bool_matrix, bm_bm); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_matrix, bm_m); + INSTALL_CATOP_TI (ti, octave_matrix, octave_bool_matrix, m_bm); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_float_matrix, bm_fm); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_bool_matrix, fm_bm); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_bool_matrix, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_bool_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_char_matrix_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_char_matrix_str, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_char_matrix_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_char_matrix_sq_str, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_range, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_range, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_sparse_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_sparse_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int8_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int8_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int16_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int16_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int32_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int32_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_int64_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_int64_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint8_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint8_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint16_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint16_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint32_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint32_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_uint64_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_uint64_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_null_sq_str, null_assign); - INSTALL_ASSIGNOP (op_el_and_eq, octave_bool_matrix, octave_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_and_eq, octave_bool_matrix, octave_bool_matrix, assign_and); - INSTALL_ASSIGNOP (op_el_or_eq, octave_bool_matrix, octave_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_or_eq, octave_bool_matrix, octave_bool_matrix, assign_or); }
--- a/libinterp/operators/op-bm-sbm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-bm-sbm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -84,25 +84,25 @@ DEFNDASSIGNOP_FN (assign, bool_matrix, sparse_bool_matrix, bool_array, assign) void -install_bm_sbm_ops (void) +install_bm_sbm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_eq, octave_bool_matrix, octave_sparse_bool_matrix, eq); - INSTALL_BINOP (op_ne, octave_bool_matrix, octave_sparse_bool_matrix, ne); + INSTALL_BINOP_TI (ti, op_eq, octave_bool_matrix, octave_sparse_bool_matrix, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_bool_matrix, octave_sparse_bool_matrix, ne); - INSTALL_BINOP (op_el_and, octave_bool_matrix, octave_sparse_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_bool_matrix, octave_sparse_bool_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_bool_matrix, octave_sparse_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_bool_matrix, octave_sparse_bool_matrix, el_or); - INSTALL_CATOP (octave_bool_matrix, octave_sparse_bool_matrix, bm_sbm); - INSTALL_CATOP (octave_bool_matrix, octave_sparse_matrix, bm_sm); - INSTALL_CATOP (octave_matrix, octave_sparse_bool_matrix, m_sbm); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_sparse_bool_matrix, bm_sbm); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_sparse_matrix, bm_sm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_sparse_bool_matrix, m_sbm); - INSTALL_ASSIGNOP (op_asn_eq, octave_bool_matrix, octave_sparse_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_bool_matrix, octave_sparse_bool_matrix, assign) - INSTALL_ASSIGNCONV (octave_bool_matrix, octave_sparse_bool_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_bool_matrix, octave_sparse_bool_matrix, octave_bool_matrix); - INSTALL_WIDENOP (octave_bool_matrix, octave_sparse_bool_matrix, + INSTALL_WIDENOP_TI (ti, octave_bool_matrix, octave_sparse_bool_matrix, sparse_bool_matrix_conv); }
--- a/libinterp/operators/op-cdm-cdm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cdm-cdm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -91,26 +91,26 @@ } void -install_cdm_cdm_ops (void) +install_cdm_cdm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_uplus, octave_complex_diag_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_complex_diag_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_complex_diag_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_complex_diag_matrix, hermitian); + INSTALL_UNOP_TI (ti, op_uplus, octave_complex_diag_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_complex_diag_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_complex_diag_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_complex_diag_matrix, hermitian); - INSTALL_BINOP (op_add, octave_complex_diag_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex_diag_matrix, octave_complex_diag_matrix, add); - INSTALL_BINOP (op_sub, octave_complex_diag_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_complex_diag_matrix, octave_complex_diag_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex_diag_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_complex_diag_matrix, octave_complex_diag_matrix, mul); - INSTALL_BINOP (op_div, octave_complex_diag_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_complex_diag_matrix, octave_complex_diag_matrix, div); - INSTALL_BINOP (op_ldiv, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_diag_matrix, octave_complex_diag_matrix, ldiv); - INSTALL_ASSIGNCONV (octave_complex_diag_matrix, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex_diag_matrix, octave_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_complex_diag_matrix, octave_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_complex_diag_matrix, octave_complex_matrix, complex_diag_matrix_to_complex_matrix); }
--- a/libinterp/operators/op-cell.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cell.cc Fri Jan 05 18:44:53 2018 -0500 @@ -53,16 +53,16 @@ DEFNULLASSIGNOP_FN (null_assign, cell, delete_elements) void -install_cell_ops (void) +install_cell_ops (octave::type_info& ti) { - INSTALL_UNOP (op_transpose, octave_cell, transpose); - INSTALL_UNOP (op_hermitian, octave_cell, transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_cell, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_cell, transpose); - INSTALL_CATOP (octave_cell, octave_cell, c_c); + INSTALL_CATOP_TI (ti, octave_cell, octave_cell, c_c); - INSTALL_ASSIGNANYOP (op_asn_eq, octave_cell, assign); + INSTALL_ASSIGNANYOP_TI (ti, op_asn_eq, octave_cell, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_cell, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_cell, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_cell, octave_null_sq_str, null_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_cell, octave_null_matrix, null_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_cell, octave_null_str, null_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_cell, octave_null_sq_str, null_assign); }
--- a/libinterp/operators/op-chm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-chm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -96,14 +96,14 @@ } void -install_chm_ops (void) +install_chm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_transpose, octave_char_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_char_matrix, transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_char_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_char_matrix, transpose); - INSTALL_CATOP (octave_char_matrix, octave_char_matrix, chm_chm); - INSTALL_CATOP (octave_char_matrix, octave_scalar, chm_s); - INSTALL_CATOP (octave_char_matrix, octave_matrix, chm_m); - INSTALL_CATOP (octave_scalar, octave_char_matrix, s_chm); - INSTALL_CATOP (octave_matrix, octave_char_matrix, m_chm); + INSTALL_CATOP_TI (ti, octave_char_matrix, octave_char_matrix, chm_chm); + INSTALL_CATOP_TI (ti, octave_char_matrix, octave_scalar, chm_s); + INSTALL_CATOP_TI (ti, octave_char_matrix, octave_matrix, chm_m); + INSTALL_CATOP_TI (ti, octave_scalar, octave_char_matrix, s_chm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_char_matrix, m_chm); }
--- a/libinterp/operators/op-class.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-class.cc Fri Jan 05 18:44:53 2018 -0500 @@ -126,39 +126,37 @@ DEF_CLASS_BINOP (and) DEF_CLASS_BINOP (or) -#define INSTALL_CLASS_UNOP(op, f) \ - octave_value_typeinfo::register_unary_class_op \ - (octave_value::op, oct_unop_ ## f) +#define INSTALL_CLASS_UNOP_TI(ti, op, f) \ + ti.install_unary_class_op (octave_value::op, oct_unop_ ## f) -#define INSTALL_CLASS_BINOP(op, f) \ - octave_value_typeinfo::register_binary_class_op \ - (octave_value::op, oct_binop_ ## f) +#define INSTALL_CLASS_BINOP_TI(ti, op, f) \ + ti.install_binary_class_op (octave_value::op, oct_binop_ ## f) void -install_class_ops (void) +install_class_ops (octave::type_info& ti) { - INSTALL_CLASS_UNOP (op_not, not); - INSTALL_CLASS_UNOP (op_uplus, uplus); - INSTALL_CLASS_UNOP (op_uminus, uminus); - INSTALL_CLASS_UNOP (op_transpose, transpose); - INSTALL_CLASS_UNOP (op_hermitian, ctranspose); + INSTALL_CLASS_UNOP_TI (ti, op_not, not); + INSTALL_CLASS_UNOP_TI (ti, op_uplus, uplus); + INSTALL_CLASS_UNOP_TI (ti, op_uminus, uminus); + INSTALL_CLASS_UNOP_TI (ti, op_transpose, transpose); + INSTALL_CLASS_UNOP_TI (ti, op_hermitian, ctranspose); - INSTALL_CLASS_BINOP (op_add, plus); - INSTALL_CLASS_BINOP (op_sub, minus); - INSTALL_CLASS_BINOP (op_mul, mtimes); - INSTALL_CLASS_BINOP (op_div, mrdivide); - INSTALL_CLASS_BINOP (op_pow, mpower); - INSTALL_CLASS_BINOP (op_ldiv, mldivide); - INSTALL_CLASS_BINOP (op_lt, lt); - INSTALL_CLASS_BINOP (op_le, le); - INSTALL_CLASS_BINOP (op_eq, eq); - INSTALL_CLASS_BINOP (op_ge, ge); - INSTALL_CLASS_BINOP (op_gt, gt); - INSTALL_CLASS_BINOP (op_ne, ne); - INSTALL_CLASS_BINOP (op_el_mul, times); - INSTALL_CLASS_BINOP (op_el_div, rdivide); - INSTALL_CLASS_BINOP (op_el_pow, power); - INSTALL_CLASS_BINOP (op_el_ldiv, ldivide); - INSTALL_CLASS_BINOP (op_el_and, and); - INSTALL_CLASS_BINOP (op_el_or, or); + INSTALL_CLASS_BINOP_TI (ti, op_add, plus); + INSTALL_CLASS_BINOP_TI (ti, op_sub, minus); + INSTALL_CLASS_BINOP_TI (ti, op_mul, mtimes); + INSTALL_CLASS_BINOP_TI (ti, op_div, mrdivide); + INSTALL_CLASS_BINOP_TI (ti, op_pow, mpower); + INSTALL_CLASS_BINOP_TI (ti, op_ldiv, mldivide); + INSTALL_CLASS_BINOP_TI (ti, op_lt, lt); + INSTALL_CLASS_BINOP_TI (ti, op_le, le); + INSTALL_CLASS_BINOP_TI (ti, op_eq, eq); + INSTALL_CLASS_BINOP_TI (ti, op_ge, ge); + INSTALL_CLASS_BINOP_TI (ti, op_gt, gt); + INSTALL_CLASS_BINOP_TI (ti, op_ne, ne); + INSTALL_CLASS_BINOP_TI (ti, op_el_mul, times); + INSTALL_CLASS_BINOP_TI (ti, op_el_div, rdivide); + INSTALL_CLASS_BINOP_TI (ti, op_el_pow, power); + INSTALL_CLASS_BINOP_TI (ti, op_el_ldiv, ldivide); + INSTALL_CLASS_BINOP_TI (ti, op_el_and, and); + INSTALL_CLASS_BINOP_TI (ti, op_el_or, or); }
--- a/libinterp/operators/op-cm-cm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cm-cm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -237,73 +237,73 @@ complex_array, quotient_eq) void -install_cm_cm_ops (void) +install_cm_cm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_complex_matrix, not); - INSTALL_UNOP (op_uplus, octave_complex_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_complex_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_complex_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_complex_matrix, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_complex_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_complex_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_complex_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_complex_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_complex_matrix, hermitian); - INSTALL_NCUNOP (op_incr, octave_complex_matrix, incr); - INSTALL_NCUNOP (op_decr, octave_complex_matrix, decr); - INSTALL_NCUNOP (op_uminus, octave_complex_matrix, changesign); + INSTALL_NCUNOP_TI (ti, op_incr, octave_complex_matrix, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_complex_matrix, decr); + INSTALL_NCUNOP_TI (ti, op_uminus, octave_complex_matrix, changesign); - INSTALL_BINOP (op_add, octave_complex_matrix, octave_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_complex_matrix, octave_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex_matrix, octave_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_complex_matrix, octave_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_complex_matrix, octave_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex_matrix, octave_complex_matrix, ldiv); - INSTALL_BINOP (op_trans_mul, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex_matrix, octave_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex_matrix, octave_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex_matrix, octave_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex_matrix, octave_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex_matrix, octave_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_matrix, octave_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_trans_mul, octave_complex_matrix, octave_complex_matrix, trans_mul); - INSTALL_BINOP (op_mul_trans, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_trans, octave_complex_matrix, octave_complex_matrix, mul_trans); - INSTALL_BINOP (op_herm_mul, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_herm_mul, octave_complex_matrix, octave_complex_matrix, herm_mul); - INSTALL_BINOP (op_mul_herm, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_herm, octave_complex_matrix, octave_complex_matrix, mul_herm); - INSTALL_BINOP (op_trans_ldiv, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_trans_ldiv, octave_complex_matrix, octave_complex_matrix, trans_ldiv); - INSTALL_BINOP (op_herm_ldiv, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_herm_ldiv, octave_complex_matrix, octave_complex_matrix, herm_ldiv); - INSTALL_BINOP (op_lt, octave_complex_matrix, octave_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_complex_matrix, octave_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_complex_matrix, octave_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex_matrix, octave_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex_matrix, octave_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex_matrix, octave_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_complex_matrix, octave_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex_matrix, octave_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex_matrix, octave_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex_matrix, octave_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex_matrix, octave_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex_matrix, octave_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex_matrix, octave_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_complex_matrix, octave_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex_matrix, octave_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex_matrix, octave_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_complex_matrix, octave_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex_matrix, octave_complex_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex_matrix, octave_complex_matrix, el_or); - INSTALL_CATOP (octave_complex_matrix, octave_complex_matrix, cm_cm); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_complex_matrix, cm_cm); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_complex_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_null_sq_str, null_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_complex_matrix, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_complex_matrix, octave_complex_matrix, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_complex_matrix, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_complex_matrix, octave_complex_matrix, assign_sub); - INSTALL_ASSIGNOP (op_el_mul_eq, octave_complex_matrix, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_mul_eq, octave_complex_matrix, octave_complex_matrix, assign_el_mul); - INSTALL_ASSIGNOP (op_el_div_eq, octave_complex_matrix, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_div_eq, octave_complex_matrix, octave_complex_matrix, assign_el_div); }
--- a/libinterp/operators/op-cm-cs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cm-cs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -131,39 +131,39 @@ DEFNDASSIGNOP_OP (assign_div, complex_matrix, complex_scalar, complex, /=) void -install_cm_cs_ops (void) +install_cm_cs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex_matrix, octave_complex, add); - INSTALL_BINOP (op_sub, octave_complex_matrix, octave_complex, sub); - INSTALL_BINOP (op_mul, octave_complex_matrix, octave_complex, mul); - INSTALL_BINOP (op_div, octave_complex_matrix, octave_complex, div); - INSTALL_BINOP (op_pow, octave_complex_matrix, octave_complex, pow); - INSTALL_BINOP (op_ldiv, octave_complex_matrix, octave_complex, ldiv); - INSTALL_BINOP (op_lt, octave_complex_matrix, octave_complex, lt); - INSTALL_BINOP (op_le, octave_complex_matrix, octave_complex, le); - INSTALL_BINOP (op_eq, octave_complex_matrix, octave_complex, eq); - INSTALL_BINOP (op_ge, octave_complex_matrix, octave_complex, ge); - INSTALL_BINOP (op_gt, octave_complex_matrix, octave_complex, gt); - INSTALL_BINOP (op_ne, octave_complex_matrix, octave_complex, ne); - INSTALL_BINOP (op_el_mul, octave_complex_matrix, octave_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_complex_matrix, octave_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_complex_matrix, octave_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex_matrix, octave_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex_matrix, octave_complex, el_and); - INSTALL_BINOP (op_el_or, octave_complex_matrix, octave_complex, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex_matrix, octave_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex_matrix, octave_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex_matrix, octave_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex_matrix, octave_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex_matrix, octave_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_matrix, octave_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex_matrix, octave_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex_matrix, octave_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex_matrix, octave_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex_matrix, octave_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex_matrix, octave_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex_matrix, octave_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex_matrix, octave_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex_matrix, octave_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex_matrix, octave_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex_matrix, octave_complex, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex_matrix, octave_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex_matrix, octave_complex, el_or); - INSTALL_CATOP (octave_complex_matrix, octave_complex, cm_cs); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_complex, cm_cs); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_complex, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, octave_complex, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_complex, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_complex, sgl_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_complex_matrix, octave_complex_scalar, + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_complex_matrix, octave_complex_scalar, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_complex_matrix, octave_complex_scalar, + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_complex_matrix, octave_complex_scalar, assign_sub); - INSTALL_ASSIGNOP (op_mul_eq, octave_complex_matrix, octave_complex_scalar, + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_complex_matrix, octave_complex_scalar, assign_mul); - INSTALL_ASSIGNOP (op_div_eq, octave_complex_matrix, octave_complex_scalar, + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_complex_matrix, octave_complex_scalar, assign_div); }
--- a/libinterp/operators/op-cm-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cm-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,30 +120,30 @@ DEFNDASSIGNOP_FN (assign, complex_matrix, matrix, complex_array, assign) void -install_cm_m_ops (void) +install_cm_m_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex_matrix, octave_matrix, add); - INSTALL_BINOP (op_sub, octave_complex_matrix, octave_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex_matrix, octave_matrix, mul); - INSTALL_BINOP (op_div, octave_complex_matrix, octave_matrix, div); - INSTALL_BINOP (op_pow, octave_complex_matrix, octave_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex_matrix, octave_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_complex_matrix, octave_matrix, lt); - INSTALL_BINOP (op_le, octave_complex_matrix, octave_matrix, le); - INSTALL_BINOP (op_eq, octave_complex_matrix, octave_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex_matrix, octave_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex_matrix, octave_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex_matrix, octave_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex_matrix, octave_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex_matrix, octave_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex_matrix, octave_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex_matrix, octave_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex_matrix, octave_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex_matrix, octave_matrix, el_or); - INSTALL_BINOP (op_mul_trans, octave_complex_matrix, octave_matrix, mul_trans); - INSTALL_BINOP (op_mul_herm, octave_complex_matrix, octave_matrix, mul_trans); + INSTALL_BINOP_TI (ti, op_add, octave_complex_matrix, octave_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex_matrix, octave_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex_matrix, octave_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex_matrix, octave_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex_matrix, octave_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_matrix, octave_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex_matrix, octave_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex_matrix, octave_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex_matrix, octave_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex_matrix, octave_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex_matrix, octave_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex_matrix, octave_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex_matrix, octave_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex_matrix, octave_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex_matrix, octave_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex_matrix, octave_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex_matrix, octave_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex_matrix, octave_matrix, el_or); + INSTALL_BINOP_TI (ti, op_mul_trans, octave_complex_matrix, octave_matrix, mul_trans); + INSTALL_BINOP_TI (ti, op_mul_herm, octave_complex_matrix, octave_matrix, mul_trans); - INSTALL_CATOP (octave_complex_matrix, octave_matrix, cm_m); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_matrix, cm_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_matrix, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_matrix, assign); }
--- a/libinterp/operators/op-cm-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cm-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -121,33 +121,33 @@ DEFNDASSIGNOP_OP (assign_div, complex_matrix, scalar, scalar, /=) void -install_cm_s_ops (void) +install_cm_s_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex_matrix, octave_scalar, add); - INSTALL_BINOP (op_sub, octave_complex_matrix, octave_scalar, sub); - INSTALL_BINOP (op_mul, octave_complex_matrix, octave_scalar, mul); - INSTALL_BINOP (op_div, octave_complex_matrix, octave_scalar, div); - INSTALL_BINOP (op_pow, octave_complex_matrix, octave_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_complex_matrix, octave_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_complex_matrix, octave_scalar, lt); - INSTALL_BINOP (op_le, octave_complex_matrix, octave_scalar, le); - INSTALL_BINOP (op_eq, octave_complex_matrix, octave_scalar, eq); - INSTALL_BINOP (op_ge, octave_complex_matrix, octave_scalar, ge); - INSTALL_BINOP (op_gt, octave_complex_matrix, octave_scalar, gt); - INSTALL_BINOP (op_ne, octave_complex_matrix, octave_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_complex_matrix, octave_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_complex_matrix, octave_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_complex_matrix, octave_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex_matrix, octave_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex_matrix, octave_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_complex_matrix, octave_scalar, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex_matrix, octave_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex_matrix, octave_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex_matrix, octave_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex_matrix, octave_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex_matrix, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_matrix, octave_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex_matrix, octave_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex_matrix, octave_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex_matrix, octave_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex_matrix, octave_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex_matrix, octave_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex_matrix, octave_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex_matrix, octave_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex_matrix, octave_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex_matrix, octave_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex_matrix, octave_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex_matrix, octave_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex_matrix, octave_scalar, el_or); - INSTALL_CATOP (octave_complex_matrix, octave_scalar, cm_s); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_scalar, cm_s); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_scalar, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_scalar, assign); - INSTALL_ASSIGNOP (op_mul_eq, octave_complex_matrix, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_complex_matrix, octave_scalar, assign_mul); - INSTALL_ASSIGNOP (op_div_eq, octave_complex_matrix, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_complex_matrix, octave_scalar, assign_div); }
--- a/libinterp/operators/op-cm-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cm-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -156,57 +156,57 @@ complex_array, assign) void -install_cm_scm_ops (void) +install_cm_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex_matrix, octave_sparse_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_complex_matrix, octave_sparse_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_complex_matrix, octave_sparse_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_complex_matrix, octave_sparse_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_complex_matrix, octave_sparse_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_matrix, octave_sparse_complex_matrix, ldiv); - INSTALL_BINOP (op_mul_trans, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_trans, octave_complex_matrix, octave_sparse_complex_matrix, mul_trans); - INSTALL_BINOP (op_mul_herm, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_herm, octave_complex_matrix, octave_sparse_complex_matrix, mul_herm); - INSTALL_BINOP (op_lt, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_complex_matrix, octave_sparse_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_le, octave_complex_matrix, octave_sparse_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_complex_matrix, octave_sparse_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_ge, octave_complex_matrix, octave_sparse_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_gt, octave_complex_matrix, octave_sparse_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_complex_matrix, octave_sparse_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex_matrix, octave_sparse_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_complex_matrix, octave_sparse_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex_matrix, octave_sparse_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex_matrix, octave_sparse_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_complex_matrix, octave_sparse_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_complex_matrix, octave_sparse_complex_matrix, el_or); - INSTALL_CATOP (octave_complex_matrix, + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_sparse_complex_matrix, cm_scm); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_sparse_complex_matrix, assign) - INSTALL_ASSIGNCONV (octave_complex_matrix, octave_sparse_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex_matrix, octave_sparse_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_complex_matrix, octave_sparse_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_complex_matrix, octave_sparse_complex_matrix, sparse_complex_matrix_conv); }
--- a/libinterp/operators/op-cm-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cm-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -141,38 +141,38 @@ DEFNDASSIGNOP_FN (assign, complex_matrix, sparse_matrix, complex_array, assign) void -install_cm_sm_ops (void) +install_cm_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex_matrix, octave_sparse_matrix, add); - INSTALL_BINOP (op_sub, octave_complex_matrix, octave_sparse_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex_matrix, octave_sparse_matrix, mul); - INSTALL_BINOP (op_div, octave_complex_matrix, octave_sparse_matrix, div); - INSTALL_BINOP (op_pow, octave_complex_matrix, octave_sparse_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex_matrix, octave_sparse_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_complex_matrix, octave_sparse_matrix, lt); - INSTALL_BINOP (op_le, octave_complex_matrix, octave_sparse_matrix, le); - INSTALL_BINOP (op_eq, octave_complex_matrix, octave_sparse_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex_matrix, octave_sparse_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex_matrix, octave_sparse_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex_matrix, octave_sparse_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex_matrix, octave_sparse_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex_matrix, octave_sparse_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex_matrix, octave_sparse_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex_matrix, octave_sparse_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex_matrix, octave_sparse_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_matrix, octave_sparse_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex_matrix, octave_sparse_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex_matrix, octave_sparse_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex_matrix, octave_sparse_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex_matrix, octave_sparse_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex_matrix, octave_sparse_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex_matrix, octave_sparse_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex_matrix, octave_sparse_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_complex_matrix, octave_sparse_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex_matrix, octave_sparse_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex_matrix, octave_sparse_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_complex_matrix, octave_sparse_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_complex_matrix, octave_sparse_matrix, el_or); - INSTALL_CATOP (octave_complex_matrix, octave_sparse_matrix, cm_sm); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_sparse_matrix, cm_sm); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_sparse_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_sparse_matrix, assign); - INSTALL_ASSIGNCONV (octave_complex_matrix, octave_sparse_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex_matrix, octave_sparse_matrix, octave_complex_matrix) }
--- a/libinterp/operators/op-cs-cm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cs-cm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -121,31 +121,31 @@ } void -install_cs_cm_ops (void) +install_cs_cm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex, octave_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_complex, octave_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex, octave_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_complex, octave_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_complex, octave_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex, octave_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_complex, octave_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_complex, octave_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_complex, octave_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex, octave_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex, octave_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex, octave_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex, octave_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex, octave_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex, octave_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex, octave_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex, octave_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex, octave_complex_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex, octave_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex, octave_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex, octave_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex, octave_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex, octave_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex, octave_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex, octave_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex, octave_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex, octave_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex, octave_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex, octave_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex, octave_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex, octave_complex_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex, octave_complex_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_complex_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex, octave_complex_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex, octave_complex_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex, octave_complex_matrix, el_or); - INSTALL_CATOP (octave_complex, octave_complex_matrix, cs_cm); + INSTALL_CATOP_TI (ti, octave_complex, octave_complex_matrix, cs_cm); - INSTALL_ASSIGNCONV (octave_complex, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_complex, octave_complex_matrix, complex_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_complex, octave_complex_matrix, complex_matrix_conv); }
--- a/libinterp/operators/op-cs-cs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cs-cs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -154,43 +154,43 @@ DEFNDCATOP_FN (cs_cs, complex, complex, complex_array, complex_array, concat) void -install_cs_cs_ops (void) +install_cs_cs_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_complex, not); - INSTALL_UNOP (op_uplus, octave_complex, uplus); - INSTALL_UNOP (op_uminus, octave_complex, uminus); - INSTALL_UNOP (op_transpose, octave_complex, transpose); - INSTALL_UNOP (op_hermitian, octave_complex, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_complex, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_complex, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_complex, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_complex, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_complex, hermitian); - INSTALL_NCUNOP (op_incr, octave_complex, incr); - INSTALL_NCUNOP (op_decr, octave_complex, decr); + INSTALL_NCUNOP_TI (ti, op_incr, octave_complex, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_complex, decr); - INSTALL_BINOP (op_add, octave_complex, octave_complex, add); - INSTALL_BINOP (op_sub, octave_complex, octave_complex, sub); - INSTALL_BINOP (op_mul, octave_complex, octave_complex, mul); - INSTALL_BINOP (op_div, octave_complex, octave_complex, div); - INSTALL_BINOP (op_pow, octave_complex, octave_complex, pow); - INSTALL_BINOP (op_ldiv, octave_complex, octave_complex, ldiv); - INSTALL_BINOP (op_lt, octave_complex, octave_complex, lt); - INSTALL_BINOP (op_le, octave_complex, octave_complex, le); - INSTALL_BINOP (op_eq, octave_complex, octave_complex, eq); - INSTALL_BINOP (op_ge, octave_complex, octave_complex, ge); - INSTALL_BINOP (op_gt, octave_complex, octave_complex, gt); - INSTALL_BINOP (op_ne, octave_complex, octave_complex, ne); - INSTALL_BINOP (op_el_mul, octave_complex, octave_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_complex, octave_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_complex, octave_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex, octave_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex, octave_complex, el_and); - INSTALL_BINOP (op_el_or, octave_complex, octave_complex, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex, octave_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex, octave_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex, octave_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex, octave_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex, octave_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex, octave_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex, octave_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex, octave_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex, octave_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex, octave_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex, octave_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex, octave_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex, octave_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex, octave_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex, octave_complex, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex, octave_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex, octave_complex, el_or); - INSTALL_CATOP (octave_complex, octave_complex, cs_cs); + INSTALL_CATOP_TI (ti, octave_complex, octave_complex, cs_cs); - INSTALL_ASSIGNCONV (octave_complex, octave_complex, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_complex, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_null_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_null_matrix, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_null_str, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_null_sq_str, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_null_str, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_null_sq_str, octave_complex_matrix); }
--- a/libinterp/operators/op-cs-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cs-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -106,28 +106,28 @@ DEFNDCATOP_FN (cs_m, complex, matrix, complex_array, array, concat) void -install_cs_m_ops (void) +install_cs_m_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex, octave_matrix, add); - INSTALL_BINOP (op_sub, octave_complex, octave_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex, octave_matrix, mul); - INSTALL_BINOP (op_div, octave_complex, octave_matrix, div); - INSTALL_BINOP (op_pow, octave_complex, octave_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex, octave_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_complex, octave_matrix, lt); - INSTALL_BINOP (op_le, octave_complex, octave_matrix, le); - INSTALL_BINOP (op_eq, octave_complex, octave_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex, octave_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex, octave_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex, octave_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex, octave_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex, octave_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex, octave_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex, octave_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex, octave_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex, octave_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex, octave_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex, octave_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex, octave_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex, octave_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex, octave_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex, octave_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex, octave_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex, octave_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex, octave_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex, octave_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex, octave_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex, octave_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex, octave_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex, octave_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex, octave_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex, octave_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex, octave_matrix, el_or); - INSTALL_CATOP (octave_complex, octave_matrix, cs_m); + INSTALL_CATOP_TI (ti, octave_complex, octave_matrix, cs_m); - INSTALL_ASSIGNCONV (octave_complex, octave_matrix, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_matrix, octave_complex_matrix); }
--- a/libinterp/operators/op-cs-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cs-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -125,28 +125,28 @@ DEFNDCATOP_FN (cs_s, complex, scalar, complex_array, array, concat) void -install_cs_s_ops (void) +install_cs_s_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex, octave_scalar, add); - INSTALL_BINOP (op_sub, octave_complex, octave_scalar, sub); - INSTALL_BINOP (op_mul, octave_complex, octave_scalar, mul); - INSTALL_BINOP (op_div, octave_complex, octave_scalar, div); - INSTALL_BINOP (op_pow, octave_complex, octave_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_complex, octave_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_complex, octave_scalar, lt); - INSTALL_BINOP (op_le, octave_complex, octave_scalar, le); - INSTALL_BINOP (op_eq, octave_complex, octave_scalar, eq); - INSTALL_BINOP (op_ge, octave_complex, octave_scalar, ge); - INSTALL_BINOP (op_gt, octave_complex, octave_scalar, gt); - INSTALL_BINOP (op_ne, octave_complex, octave_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_complex, octave_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_complex, octave_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_complex, octave_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex, octave_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex, octave_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_complex, octave_scalar, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex, octave_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex, octave_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex, octave_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex, octave_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex, octave_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex, octave_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex, octave_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex, octave_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex, octave_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex, octave_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex, octave_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex, octave_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex, octave_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex, octave_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex, octave_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex, octave_scalar, el_or); - INSTALL_CATOP (octave_complex, octave_scalar, cs_s); + INSTALL_CATOP_TI (ti, octave_complex, octave_scalar, cs_s); - INSTALL_ASSIGNCONV (octave_complex, octave_scalar, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_scalar, octave_complex_matrix); }
--- a/libinterp/operators/op-cs-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cs-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -143,39 +143,39 @@ } void -install_cs_scm_ops (void) +install_cs_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex, octave_sparse_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_complex, octave_sparse_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex, octave_sparse_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_complex, octave_sparse_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_complex, octave_sparse_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex, octave_sparse_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex, octave_sparse_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex, octave_sparse_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex, octave_sparse_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex, octave_sparse_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex, octave_sparse_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_complex, octave_sparse_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_complex, octave_sparse_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_complex, octave_sparse_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex, octave_sparse_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex, octave_sparse_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex, octave_sparse_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_complex, octave_sparse_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex, octave_sparse_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex, octave_sparse_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex, octave_sparse_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex, octave_sparse_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex, octave_sparse_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex, octave_sparse_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_complex, octave_sparse_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_sparse_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex, octave_sparse_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_complex, octave_sparse_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_complex, octave_sparse_complex_matrix, el_or); - INSTALL_CATOP (octave_complex, octave_sparse_complex_matrix, cs_scm); + INSTALL_CATOP_TI (ti, octave_complex, octave_sparse_complex_matrix, cs_scm); - INSTALL_ASSIGNCONV (octave_complex, octave_sparse_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_sparse_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_complex, octave_sparse_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_complex, octave_sparse_complex_matrix, sparse_complex_matrix_conv); }
--- a/libinterp/operators/op-cs-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-cs-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -141,31 +141,31 @@ } void -install_cs_sm_ops (void) +install_cs_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_complex, octave_sparse_matrix, add); - INSTALL_BINOP (op_sub, octave_complex, octave_sparse_matrix, sub); - INSTALL_BINOP (op_mul, octave_complex, octave_sparse_matrix, mul); - INSTALL_BINOP (op_div, octave_complex, octave_sparse_matrix, div); - INSTALL_BINOP (op_pow, octave_complex, octave_sparse_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_complex, octave_sparse_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_complex, octave_sparse_matrix, lt); - INSTALL_BINOP (op_le, octave_complex, octave_sparse_matrix, le); - INSTALL_BINOP (op_eq, octave_complex, octave_sparse_matrix, eq); - INSTALL_BINOP (op_ge, octave_complex, octave_sparse_matrix, ge); - INSTALL_BINOP (op_gt, octave_complex, octave_sparse_matrix, gt); - INSTALL_BINOP (op_ne, octave_complex, octave_sparse_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_complex, octave_sparse_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_complex, octave_sparse_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_complex, octave_sparse_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_complex, octave_sparse_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_complex, octave_sparse_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_complex, octave_sparse_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_complex, octave_sparse_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_complex, octave_sparse_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_complex, octave_sparse_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_complex, octave_sparse_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_complex, octave_sparse_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex, octave_sparse_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_complex, octave_sparse_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_complex, octave_sparse_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_complex, octave_sparse_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_complex, octave_sparse_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_complex, octave_sparse_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_complex, octave_sparse_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_complex, octave_sparse_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_complex, octave_sparse_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_sparse_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_complex, octave_sparse_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_complex, octave_sparse_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_complex, octave_sparse_matrix, el_or); - INSTALL_CATOP (octave_complex, octave_sparse_matrix, cs_sm); + INSTALL_CATOP_TI (ti, octave_complex, octave_sparse_matrix, cs_sm); - INSTALL_ASSIGNCONV (octave_complex, octave_sparse_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_sparse_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_complex, octave_sparse_matrix, sparse_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_complex, octave_sparse_matrix, sparse_matrix_conv); }
--- a/libinterp/operators/op-dm-dm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-dm-dm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -78,19 +78,19 @@ } void -install_dm_dm_ops (void) +install_dm_dm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_uplus, octave_diag_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_diag_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_diag_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_diag_matrix, transpose); + INSTALL_UNOP_TI (ti, op_uplus, octave_diag_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_diag_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_diag_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_diag_matrix, transpose); - INSTALL_BINOP (op_add, octave_diag_matrix, octave_diag_matrix, add); - INSTALL_BINOP (op_sub, octave_diag_matrix, octave_diag_matrix, sub); - INSTALL_BINOP (op_mul, octave_diag_matrix, octave_diag_matrix, mul); - INSTALL_BINOP (op_div, octave_diag_matrix, octave_diag_matrix, div); - INSTALL_BINOP (op_ldiv, octave_diag_matrix, octave_diag_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_diag_matrix, octave_diag_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_diag_matrix, octave_diag_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_diag_matrix, octave_diag_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_diag_matrix, octave_diag_matrix, div); + INSTALL_BINOP_TI (ti, op_ldiv, octave_diag_matrix, octave_diag_matrix, ldiv); - INSTALL_ASSIGNCONV (octave_diag_matrix, octave_matrix, octave_matrix); - INSTALL_WIDENOP (octave_diag_matrix, octave_matrix, diag_matrix_to_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_diag_matrix, octave_matrix, octave_matrix); + INSTALL_WIDENOP_TI (ti, octave_diag_matrix, octave_matrix, diag_matrix_to_matrix); }
--- a/libinterp/operators/op-dm-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-dm-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -549,58 +549,58 @@ } void -install_dm_scm_ops (void) +install_dm_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_mul, octave_diag_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_diag_matrix, octave_sparse_complex_matrix, mul_dm_scm); - INSTALL_BINOP (op_mul, octave_complex_diag_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_complex_diag_matrix, octave_sparse_matrix, mul_cdm_sm); - INSTALL_BINOP (op_mul, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_complex_diag_matrix, octave_sparse_complex_matrix, mul_cdm_scm); - INSTALL_BINOP (op_ldiv, octave_diag_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_diag_matrix, octave_sparse_complex_matrix, ldiv_dm_scm); - INSTALL_BINOP (op_ldiv, octave_complex_diag_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_diag_matrix, octave_sparse_matrix, ldiv_cdm_sm); - INSTALL_BINOP (op_ldiv, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_complex_diag_matrix, octave_sparse_complex_matrix, ldiv_cdm_scm); - INSTALL_BINOP (op_add, octave_diag_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_diag_matrix, octave_sparse_complex_matrix, add_dm_scm); - INSTALL_BINOP (op_add, octave_complex_diag_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex_diag_matrix, octave_sparse_matrix, add_cdm_sm); - INSTALL_BINOP (op_add, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_complex_diag_matrix, octave_sparse_complex_matrix, add_cdm_scm); - INSTALL_BINOP (op_sub, octave_diag_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_diag_matrix, octave_sparse_complex_matrix, sub_dm_scm); - INSTALL_BINOP (op_sub, octave_complex_diag_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_complex_diag_matrix, octave_sparse_matrix, sub_cdm_sm); - INSTALL_BINOP (op_sub, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_complex_diag_matrix, octave_sparse_complex_matrix, sub_cdm_scm); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, octave_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_diag_matrix, mul_scm_dm); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_complex_diag_matrix, mul_sm_cdm); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_complex_diag_matrix, mul_scm_cdm); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, octave_diag_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_diag_matrix, div_scm_dm); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_complex_diag_matrix, div_sm_cdm); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_complex_diag_matrix, div_scm_cdm); - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, octave_diag_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_diag_matrix, add_scm_dm); - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_complex_diag_matrix, add_sm_cdm); - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_complex_diag_matrix, add_scm_cdm); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, octave_diag_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_diag_matrix, sub_scm_dm); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_complex_diag_matrix, sub_sm_cdm); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_complex_diag_matrix, sub_scm_cdm); }
--- a/libinterp/operators/op-dm-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-dm-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -186,19 +186,19 @@ } void -install_dm_sm_ops (void) +install_dm_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_mul, octave_diag_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_diag_matrix, octave_sparse_matrix, mul_dm_sm); - INSTALL_BINOP (op_add, octave_diag_matrix, octave_sparse_matrix, add_dm_sm); - INSTALL_BINOP (op_sub, octave_diag_matrix, octave_sparse_matrix, sub_dm_sm); - INSTALL_BINOP (op_ldiv, octave_diag_matrix, octave_sparse_matrix, ldiv_dm_sm); + INSTALL_BINOP_TI (ti, op_add, octave_diag_matrix, octave_sparse_matrix, add_dm_sm); + INSTALL_BINOP_TI (ti, op_sub, octave_diag_matrix, octave_sparse_matrix, sub_dm_sm); + INSTALL_BINOP_TI (ti, op_ldiv, octave_diag_matrix, octave_sparse_matrix, ldiv_dm_sm); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_diag_matrix, mul_sm_dm); - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_diag_matrix, add_sm_dm); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_diag_matrix, sub_sm_dm); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_diag_matrix, div_sm_dm); + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_diag_matrix, add_sm_dm); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_diag_matrix, sub_sm_dm); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_diag_matrix, div_sm_dm); }
--- a/libinterp/operators/op-dm-template.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-dm-template.cc Fri Jan 05 18:44:53 2018 -0500 @@ -82,20 +82,20 @@ #define INST_NAME CONCAT3(install_, SHORT_NAME, _ops) void -INST_NAME (void) +INST_NAME (octave::type_info& ti) { - INSTALL_BINOP (op_add, OCTAVE_LMATRIX, OCTAVE_RMATRIX, add); - INSTALL_BINOP (op_sub, OCTAVE_LMATRIX, OCTAVE_RMATRIX, sub); - INSTALL_BINOP (op_mul, OCTAVE_LMATRIX, OCTAVE_RMATRIX, mul); + INSTALL_BINOP_TI (ti, op_add, OCTAVE_LMATRIX, OCTAVE_RMATRIX, add); + INSTALL_BINOP_TI (ti, op_sub, OCTAVE_LMATRIX, OCTAVE_RMATRIX, sub); + INSTALL_BINOP_TI (ti, op_mul, OCTAVE_LMATRIX, OCTAVE_RMATRIX, mul); #if defined (DEFINEDIV) - INSTALL_BINOP (op_div, OCTAVE_LMATRIX, OCTAVE_RMATRIX, div); + INSTALL_BINOP_TI (ti, op_div, OCTAVE_LMATRIX, OCTAVE_RMATRIX, div); #endif #if defined (DEFINELDIV) - INSTALL_BINOP (op_ldiv, OCTAVE_LMATRIX, OCTAVE_RMATRIX, ldiv); + INSTALL_BINOP_TI (ti, op_ldiv, OCTAVE_LMATRIX, OCTAVE_RMATRIX, ldiv); #endif #if defined (DEFINENULLASSIGNCONV) - INSTALL_ASSIGNCONV (OCTAVE_LMATRIX, octave_null_matrix, OCTAVE_LDMATRIX); - INSTALL_ASSIGNCONV (OCTAVE_LMATRIX, octave_null_str, OCTAVE_LDMATRIX); - INSTALL_ASSIGNCONV (OCTAVE_LMATRIX, octave_null_sq_str, OCTAVE_LDMATRIX); + INSTALL_ASSIGNCONV_TI (ti, OCTAVE_LMATRIX, octave_null_matrix, OCTAVE_LDMATRIX); + INSTALL_ASSIGNCONV_TI (ti, OCTAVE_LMATRIX, octave_null_str, OCTAVE_LDMATRIX); + INSTALL_ASSIGNCONV_TI (ti, OCTAVE_LMATRIX, octave_null_sq_str, OCTAVE_LDMATRIX); #endif }
--- a/libinterp/operators/op-dms-template.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-dms-template.cc Fri Jan 05 18:44:53 2018 -0500 @@ -86,11 +86,11 @@ #define INST_NAME CONCAT3(install_, SHORT_NAME, _ops) void -INST_NAME (void) +INST_NAME (octave::type_info& ti) { - INSTALL_BINOP (op_mul, OCTAVE_MATRIX, OCTAVE_SCALAR, dmsmul); - INSTALL_BINOP (op_div, OCTAVE_MATRIX, OCTAVE_SCALAR, dmsdiv); - INSTALL_BINOP (op_mul, OCTAVE_SCALAR, OCTAVE_MATRIX, sdmmul); - INSTALL_BINOP (op_ldiv, OCTAVE_SCALAR, OCTAVE_MATRIX, sdmldiv); - INSTALL_BINOP (op_pow, OCTAVE_MATRIX, OCTAVE_SCALAR, dmspow); + INSTALL_BINOP_TI (ti, op_mul, OCTAVE_MATRIX, OCTAVE_SCALAR, dmsmul); + INSTALL_BINOP_TI (ti, op_div, OCTAVE_MATRIX, OCTAVE_SCALAR, dmsdiv); + INSTALL_BINOP_TI (ti, op_mul, OCTAVE_SCALAR, OCTAVE_MATRIX, sdmmul); + INSTALL_BINOP_TI (ti, op_ldiv, OCTAVE_SCALAR, OCTAVE_MATRIX, sdmldiv); + INSTALL_BINOP_TI (ti, op_pow, OCTAVE_MATRIX, OCTAVE_SCALAR, dmspow); }
--- a/libinterp/operators/op-fcdm-fcdm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcdm-fcdm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -91,26 +91,26 @@ } void -install_fcdm_fcdm_ops (void) +install_fcdm_fcdm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_uplus, octave_float_complex_diag_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_float_complex_diag_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_float_complex_diag_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_float_complex_diag_matrix, hermitian); + INSTALL_UNOP_TI (ti, op_uplus, octave_float_complex_diag_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_float_complex_diag_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_float_complex_diag_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_float_complex_diag_matrix, hermitian); - INSTALL_BINOP (op_add, octave_float_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex_diag_matrix, octave_float_complex_diag_matrix, add); - INSTALL_BINOP (op_sub, octave_float_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex_diag_matrix, octave_float_complex_diag_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex_diag_matrix, octave_float_complex_diag_matrix, mul); - INSTALL_BINOP (op_div, octave_float_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_float_complex_diag_matrix, octave_float_complex_diag_matrix, div); - INSTALL_BINOP (op_ldiv, octave_float_complex_diag_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex_diag_matrix, octave_float_complex_diag_matrix, ldiv); - INSTALL_ASSIGNCONV (octave_float_complex_diag_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex_diag_matrix, octave_float_complex_matrix, octave_float_complex_matrix); - INSTALL_WIDENOP (octave_float_complex_diag_matrix, octave_complex_diag_matrix, + INSTALL_WIDENOP_TI (ti, octave_float_complex_diag_matrix, octave_complex_diag_matrix, float_complex_diag_matrix_to_complex_diag_matrix); }
--- a/libinterp/operators/op-fcm-fcm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcm-fcm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -253,97 +253,97 @@ float_complex_array, quotient_eq) void -install_fcm_fcm_ops (void) +install_fcm_fcm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_float_complex_matrix, not); - INSTALL_UNOP (op_uplus, octave_float_complex_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_float_complex_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_float_complex_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_float_complex_matrix, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_float_complex_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_float_complex_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_float_complex_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_float_complex_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_float_complex_matrix, hermitian); - INSTALL_NCUNOP (op_incr, octave_float_complex_matrix, incr); - INSTALL_NCUNOP (op_decr, octave_float_complex_matrix, decr); - INSTALL_NCUNOP (op_uminus, octave_float_complex_matrix, changesign); + INSTALL_NCUNOP_TI (ti, op_incr, octave_float_complex_matrix, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_float_complex_matrix, decr); + INSTALL_NCUNOP_TI (ti, op_uminus, octave_float_complex_matrix, changesign); - INSTALL_BINOP (op_add, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex_matrix, octave_float_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex_matrix, octave_float_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex_matrix, octave_float_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_float_complex_matrix, octave_float_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex_matrix, octave_float_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex_matrix, octave_float_complex_matrix, ldiv); - INSTALL_BINOP (op_trans_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_trans_mul, octave_float_complex_matrix, octave_float_complex_matrix, trans_mul); - INSTALL_BINOP (op_mul_trans, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_trans, octave_float_complex_matrix, octave_float_complex_matrix, mul_trans); - INSTALL_BINOP (op_herm_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_herm_mul, octave_float_complex_matrix, octave_float_complex_matrix, herm_mul); - INSTALL_BINOP (op_mul_herm, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_herm, octave_float_complex_matrix, octave_float_complex_matrix, mul_herm); - INSTALL_BINOP (op_trans_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_trans_ldiv, octave_float_complex_matrix, octave_float_complex_matrix, trans_ldiv); - INSTALL_BINOP (op_herm_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_herm_ldiv, octave_float_complex_matrix, octave_float_complex_matrix, herm_ldiv); - INSTALL_BINOP (op_lt, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex_matrix, octave_float_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_le, octave_float_complex_matrix, octave_float_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex_matrix, octave_float_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex_matrix, octave_float_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex_matrix, octave_float_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex_matrix, octave_float_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex_matrix, octave_float_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex_matrix, octave_float_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex_matrix, octave_float_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex_matrix, octave_float_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex_matrix, octave_float_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex_matrix, octave_float_complex_matrix, el_or); - INSTALL_CATOP (octave_float_complex_matrix, + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_float_complex_matrix, fcm_fcm); - INSTALL_CATOP (octave_complex_matrix, + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_float_complex_matrix, cm_fcm); - INSTALL_CATOP (octave_float_complex_matrix, + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_complex_matrix, fcm_cm); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_float_complex_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_complex_matrix, sgl_clx_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_matrix, sgl_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_float_complex_matrix, dbl_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_null_sq_str, null_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_float_complex_matrix, octave_float_complex_matrix, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_float_complex_matrix, octave_float_complex_matrix, assign_sub); - INSTALL_ASSIGNOP (op_el_mul_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_mul_eq, octave_float_complex_matrix, octave_float_complex_matrix, assign_el_mul); - INSTALL_ASSIGNOP (op_el_div_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_div_eq, octave_float_complex_matrix, octave_float_complex_matrix, assign_el_div); }
--- a/libinterp/operators/op-fcm-fcs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcm-fcs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -151,54 +151,54 @@ float_complex, /=) void -install_fcm_fcs_ops (void) +install_fcm_fcs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex_matrix, octave_float_complex, add); - INSTALL_BINOP (op_sub, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex_matrix, octave_float_complex, sub); - INSTALL_BINOP (op_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex_matrix, octave_float_complex, mul); - INSTALL_BINOP (op_div, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_float_complex_matrix, octave_float_complex, div); - INSTALL_BINOP (op_pow, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex_matrix, octave_float_complex, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex_matrix, octave_float_complex, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex_matrix, octave_float_complex, lt); - INSTALL_BINOP (op_le, octave_float_complex_matrix, octave_float_complex, le); - INSTALL_BINOP (op_eq, octave_float_complex_matrix, octave_float_complex, eq); - INSTALL_BINOP (op_ge, octave_float_complex_matrix, octave_float_complex, ge); - INSTALL_BINOP (op_gt, octave_float_complex_matrix, octave_float_complex, gt); - INSTALL_BINOP (op_ne, octave_float_complex_matrix, octave_float_complex, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex_matrix, octave_float_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex_matrix, octave_float_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex_matrix, octave_float_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex_matrix, octave_float_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex_matrix, octave_float_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex_matrix, octave_float_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex_matrix, octave_float_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex_matrix, octave_float_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex_matrix, octave_float_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex_matrix, octave_float_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex_matrix, octave_float_complex, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex_matrix, octave_float_complex, el_or); - INSTALL_CATOP (octave_float_complex_matrix, octave_float_complex, fcm_fcs); - INSTALL_CATOP (octave_complex_matrix, octave_float_complex, cm_fcs); - INSTALL_CATOP (octave_float_complex_matrix, octave_complex, fcm_cs); + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_float_complex, fcm_fcs); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_float_complex, cm_fcs); + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_complex, fcm_cs); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_float_complex, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_float_complex, dbl_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_float_complex_matrix, octave_float_complex_scalar, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_float_complex_matrix, octave_float_complex_scalar, assign_sub); - INSTALL_ASSIGNOP (op_mul_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_float_complex_matrix, octave_float_complex_scalar, assign_mul); - INSTALL_ASSIGNOP (op_div_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_float_complex_matrix, octave_float_complex_scalar, assign_div); }
--- a/libinterp/operators/op-fcm-fm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcm-fm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -149,44 +149,44 @@ complex_array, assign) void -install_fcm_fm_ops (void) +install_fcm_fm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_complex_matrix, octave_float_matrix, add); - INSTALL_BINOP (op_sub, octave_float_complex_matrix, octave_float_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_complex_matrix, octave_float_matrix, mul); - INSTALL_BINOP (op_div, octave_float_complex_matrix, octave_float_matrix, div); - INSTALL_BINOP (op_pow, octave_float_complex_matrix, octave_float_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex_matrix, octave_float_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex_matrix, octave_float_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex_matrix, octave_float_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_complex_matrix, octave_float_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex_matrix, octave_float_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex_matrix, octave_float_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex_matrix, octave_float_matrix, lt); - INSTALL_BINOP (op_le, octave_float_complex_matrix, octave_float_matrix, le); - INSTALL_BINOP (op_eq, octave_float_complex_matrix, octave_float_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_complex_matrix, octave_float_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_complex_matrix, octave_float_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_complex_matrix, octave_float_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex_matrix, octave_float_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex_matrix, octave_float_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex_matrix, octave_float_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex_matrix, octave_float_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex_matrix, octave_float_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex_matrix, octave_float_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex_matrix, octave_float_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex_matrix, octave_float_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex_matrix, octave_float_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex_matrix, octave_float_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex_matrix, octave_float_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex_matrix, octave_float_matrix, el_or); - INSTALL_BINOP (op_mul_trans, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_trans, octave_float_complex_matrix, octave_float_matrix, mul_trans); - INSTALL_BINOP (op_mul_herm, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul_herm, octave_float_complex_matrix, octave_float_matrix, mul_trans); - INSTALL_CATOP (octave_float_complex_matrix, octave_float_matrix, fcm_fm); - INSTALL_CATOP (octave_complex_matrix, octave_float_matrix, cm_fm); - INSTALL_CATOP (octave_float_complex_matrix, octave_matrix, fcm_m); + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_float_matrix, fcm_fm); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_float_matrix, cm_fm); + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_matrix, fcm_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_float_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_float_matrix, dbl_assign); }
--- a/libinterp/operators/op-fcm-fs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcm-fs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -151,45 +151,45 @@ float_scalar, /=) void -install_fcm_fs_ops (void) +install_fcm_fs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_complex_matrix, octave_float_scalar, add); - INSTALL_BINOP (op_sub, octave_float_complex_matrix, octave_float_scalar, sub); - INSTALL_BINOP (op_mul, octave_float_complex_matrix, octave_float_scalar, mul); - INSTALL_BINOP (op_div, octave_float_complex_matrix, octave_float_scalar, div); - INSTALL_BINOP (op_pow, octave_float_complex_matrix, octave_float_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex_matrix, octave_float_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex_matrix, octave_float_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex_matrix, octave_float_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_complex_matrix, octave_float_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex_matrix, octave_float_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex_matrix, octave_float_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex_matrix, octave_float_scalar, lt); - INSTALL_BINOP (op_le, octave_float_complex_matrix, octave_float_scalar, le); - INSTALL_BINOP (op_eq, octave_float_complex_matrix, octave_float_scalar, eq); - INSTALL_BINOP (op_ge, octave_float_complex_matrix, octave_float_scalar, ge); - INSTALL_BINOP (op_gt, octave_float_complex_matrix, octave_float_scalar, gt); - INSTALL_BINOP (op_ne, octave_float_complex_matrix, octave_float_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex_matrix, octave_float_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex_matrix, octave_float_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex_matrix, octave_float_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex_matrix, octave_float_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex_matrix, octave_float_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex_matrix, octave_float_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex_matrix, octave_float_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex_matrix, octave_float_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex_matrix, octave_float_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex_matrix, octave_float_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex_matrix, octave_float_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex_matrix, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex_matrix, octave_float_scalar, el_or); - INSTALL_CATOP (octave_float_complex_matrix, octave_float_scalar, fcm_fs); - INSTALL_CATOP (octave_complex_matrix, octave_float_scalar, cm_fs); - INSTALL_CATOP (octave_float_complex_matrix, octave_scalar, fcm_s); + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_float_scalar, fcm_fs); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_float_scalar, cm_fs); + INSTALL_CATOP_TI (ti, octave_float_complex_matrix, octave_scalar, fcm_s); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_float_scalar, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_float_scalar, dbl_assign); - INSTALL_ASSIGNOP (op_mul_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_float_complex_matrix, octave_float_scalar, assign_mul); - INSTALL_ASSIGNOP (op_div_eq, octave_float_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_float_complex_matrix, octave_float_scalar, assign_div); }
--- a/libinterp/operators/op-fcn.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcn.cc Fri Jan 05 18:44:53 2018 -0500 @@ -49,8 +49,8 @@ } void -install_fcn_ops (void) +install_fcn_ops (octave::type_info& ti) { - INSTALL_BINOP (op_eq, octave_fcn_handle, octave_fcn_handle, eq); - INSTALL_BINOP (op_ne, octave_fcn_handle, octave_fcn_handle, ne); + INSTALL_BINOP_TI (ti, op_eq, octave_fcn_handle, octave_fcn_handle, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_fcn_handle, octave_fcn_handle, ne); }
--- a/libinterp/operators/op-fcs-fcm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcs-fcm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -137,49 +137,49 @@ } void -install_fcs_fcm_ops (void) +install_fcs_fcm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex, octave_float_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex, octave_float_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex, octave_float_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_float_complex, octave_float_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex, octave_float_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex, octave_float_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex, octave_float_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_float_complex, octave_float_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_float_complex, octave_float_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_complex, octave_float_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_complex, octave_float_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_complex, octave_float_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex, octave_float_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex, octave_float_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex, octave_float_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex, octave_float_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex, octave_float_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex, octave_float_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex, octave_float_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex, octave_float_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex, octave_float_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex, octave_float_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex, octave_float_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex, octave_float_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex, octave_float_complex_matrix, el_or); - INSTALL_CATOP (octave_float_complex, octave_float_complex_matrix, fcs_fcm); - INSTALL_CATOP (octave_complex, octave_float_complex_matrix, cs_fcm); - INSTALL_CATOP (octave_float_complex, octave_complex_matrix, fcs_cm); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_float_complex_matrix, fcs_fcm); + INSTALL_CATOP_TI (ti, octave_complex, octave_float_complex_matrix, cs_fcm); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_complex_matrix, fcs_cm); - INSTALL_ASSIGNCONV (octave_float_complex, octave_float_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_float_complex_matrix, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_float_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_float_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_float_complex, octave_float_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_float_complex, octave_float_complex_matrix, float_complex_matrix_conv); }
--- a/libinterp/operators/op-fcs-fcs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcs-fcs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -161,51 +161,51 @@ float_complex_array, concat) void -install_fcs_fcs_ops (void) +install_fcs_fcs_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_float_complex, not); - INSTALL_UNOP (op_uplus, octave_float_complex, uplus); - INSTALL_UNOP (op_uminus, octave_float_complex, uminus); - INSTALL_UNOP (op_transpose, octave_float_complex, transpose); - INSTALL_UNOP (op_hermitian, octave_float_complex, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_float_complex, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_float_complex, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_float_complex, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_float_complex, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_float_complex, hermitian); - INSTALL_NCUNOP (op_incr, octave_float_complex, incr); - INSTALL_NCUNOP (op_decr, octave_float_complex, decr); + INSTALL_NCUNOP_TI (ti, op_incr, octave_float_complex, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_float_complex, decr); - INSTALL_BINOP (op_add, octave_float_complex, octave_float_complex, add); - INSTALL_BINOP (op_sub, octave_float_complex, octave_float_complex, sub); - INSTALL_BINOP (op_mul, octave_float_complex, octave_float_complex, mul); - INSTALL_BINOP (op_div, octave_float_complex, octave_float_complex, div); - INSTALL_BINOP (op_pow, octave_float_complex, octave_float_complex, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex, octave_float_complex, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex, octave_float_complex, lt); - INSTALL_BINOP (op_le, octave_float_complex, octave_float_complex, le); - INSTALL_BINOP (op_eq, octave_float_complex, octave_float_complex, eq); - INSTALL_BINOP (op_ge, octave_float_complex, octave_float_complex, ge); - INSTALL_BINOP (op_gt, octave_float_complex, octave_float_complex, gt); - INSTALL_BINOP (op_ne, octave_float_complex, octave_float_complex, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex, octave_float_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex, octave_float_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex, octave_float_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex, octave_float_complex, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex, octave_float_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex, octave_float_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex, octave_float_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_complex, octave_float_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex, octave_float_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex, octave_float_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex, octave_float_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex, octave_float_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex, octave_float_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex, octave_float_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex, octave_float_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex, octave_float_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex, octave_float_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex, octave_float_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex, octave_float_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex, octave_float_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex, octave_float_complex, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex, octave_float_complex, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex, octave_float_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex, octave_float_complex, el_or); - INSTALL_CATOP (octave_float_complex, octave_float_complex, fcs_fcs); - INSTALL_CATOP (octave_complex, octave_float_complex, cs_fcs); - INSTALL_CATOP (octave_float_complex, octave_complex, fcs_cs); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_float_complex, fcs_fcs); + INSTALL_CATOP_TI (ti, octave_complex, octave_float_complex, cs_fcs); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_complex, fcs_cs); - INSTALL_ASSIGNCONV (octave_float_complex, octave_float_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_float_complex, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_float_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_float_complex, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_complex, octave_null_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_null_matrix, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_complex, octave_null_str, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_null_str, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_complex, octave_null_sq_str, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_null_sq_str, octave_float_complex_matrix); }
--- a/libinterp/operators/op-fcs-fm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcs-fm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -125,34 +125,34 @@ float_array, concat) void -install_fcs_fm_ops (void) +install_fcs_fm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_complex, octave_float_matrix, add); - INSTALL_BINOP (op_sub, octave_float_complex, octave_float_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_complex, octave_float_matrix, mul); - INSTALL_BINOP (op_div, octave_float_complex, octave_float_matrix, div); - INSTALL_BINOP (op_pow, octave_float_complex, octave_float_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex, octave_float_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex, octave_float_matrix, lt); - INSTALL_BINOP (op_le, octave_float_complex, octave_float_matrix, le); - INSTALL_BINOP (op_eq, octave_float_complex, octave_float_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_complex, octave_float_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_complex, octave_float_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_complex, octave_float_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex, octave_float_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex, octave_float_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex, octave_float_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex, octave_float_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex, octave_float_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex, octave_float_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_complex, octave_float_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex, octave_float_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex, octave_float_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex, octave_float_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex, octave_float_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex, octave_float_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex, octave_float_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex, octave_float_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex, octave_float_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex, octave_float_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex, octave_float_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex, octave_float_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex, octave_float_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex, octave_float_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex, octave_float_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex, octave_float_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex, octave_float_matrix, el_or); - INSTALL_CATOP (octave_float_complex, octave_float_matrix, fcs_fm); - INSTALL_CATOP (octave_complex, octave_float_matrix, cs_fm); - INSTALL_CATOP (octave_float_complex, octave_matrix, fcs_m); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_float_matrix, fcs_fm); + INSTALL_CATOP_TI (ti, octave_complex, octave_float_matrix, cs_fm); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_matrix, fcs_m); - INSTALL_ASSIGNCONV (octave_float_complex, octave_float_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_float_matrix, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_float_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_float_matrix, octave_complex_matrix); }
--- a/libinterp/operators/op-fcs-fs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fcs-fs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -135,37 +135,37 @@ float_array, concat) void -install_fcs_fs_ops (void) +install_fcs_fs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_complex, octave_float_scalar, add); - INSTALL_BINOP (op_sub, octave_float_complex, octave_float_scalar, sub); - INSTALL_BINOP (op_mul, octave_float_complex, octave_float_scalar, mul); - INSTALL_BINOP (op_div, octave_float_complex, octave_float_scalar, div); - INSTALL_BINOP (op_pow, octave_float_complex, octave_float_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_float_complex, octave_float_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_float_complex, octave_float_scalar, lt); - INSTALL_BINOP (op_le, octave_float_complex, octave_float_scalar, le); - INSTALL_BINOP (op_eq, octave_float_complex, octave_float_scalar, eq); - INSTALL_BINOP (op_ge, octave_float_complex, octave_float_scalar, ge); - INSTALL_BINOP (op_gt, octave_float_complex, octave_float_scalar, gt); - INSTALL_BINOP (op_ne, octave_float_complex, octave_float_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_float_complex, octave_float_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_float_complex, octave_float_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_float_complex, octave_float_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_complex, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_add, octave_float_complex, octave_float_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_complex, octave_float_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_complex, octave_float_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_complex, octave_float_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_complex, octave_float_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_complex, octave_float_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_complex, octave_float_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_complex, octave_float_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_complex, octave_float_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_complex, octave_float_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_complex, octave_float_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_complex, octave_float_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_complex, octave_float_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_complex, octave_float_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_complex, octave_float_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_complex, octave_float_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_complex, octave_float_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_float_complex, octave_float_scalar, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_complex, octave_float_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_complex, octave_float_scalar, el_or); - INSTALL_CATOP (octave_float_complex, octave_float_scalar, fcs_fs); - INSTALL_CATOP (octave_complex, octave_float_scalar, cs_fs); - INSTALL_CATOP (octave_float_complex, octave_scalar, fcs_s); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_float_scalar, fcs_fs); + INSTALL_CATOP_TI (ti, octave_complex, octave_float_scalar, cs_fs); + INSTALL_CATOP_TI (ti, octave_float_complex, octave_scalar, fcs_s); - INSTALL_ASSIGNCONV (octave_float_complex, octave_float_scalar, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_float_scalar, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_complex, octave_float_scalar, + INSTALL_ASSIGNCONV_TI (ti, octave_complex, octave_float_scalar, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_complex, octave_scalar, + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex, octave_scalar, octave_float_complex_matrix); }
--- a/libinterp/operators/op-fdm-fdm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fdm-fdm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -84,26 +84,26 @@ } void -install_fdm_fdm_ops (void) +install_fdm_fdm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_uplus, octave_float_diag_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_float_diag_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_float_diag_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_float_diag_matrix, transpose); + INSTALL_UNOP_TI (ti, op_uplus, octave_float_diag_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_float_diag_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_float_diag_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_float_diag_matrix, transpose); - INSTALL_BINOP (op_add, octave_float_diag_matrix, octave_float_diag_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_diag_matrix, octave_float_diag_matrix, add); - INSTALL_BINOP (op_sub, octave_float_diag_matrix, octave_float_diag_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_float_diag_matrix, octave_float_diag_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_diag_matrix, octave_float_diag_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_float_diag_matrix, octave_float_diag_matrix, mul); - INSTALL_BINOP (op_div, octave_float_diag_matrix, octave_float_diag_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_float_diag_matrix, octave_float_diag_matrix, div); - INSTALL_BINOP (op_ldiv, octave_float_diag_matrix, octave_float_diag_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_diag_matrix, octave_float_diag_matrix, ldiv); - INSTALL_ASSIGNCONV (octave_float_diag_matrix, octave_float_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_diag_matrix, octave_float_matrix, octave_float_matrix); - INSTALL_WIDENOP (octave_float_diag_matrix, octave_float_matrix, + INSTALL_WIDENOP_TI (ti, octave_float_diag_matrix, octave_float_matrix, float_diag_matrix_to_float_matrix); }
--- a/libinterp/operators/op-fm-fcm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fm-fcm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -168,51 +168,51 @@ } void -install_fm_fcm_ops (void) +install_fm_fcm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_matrix, octave_float_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_float_matrix, octave_float_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_matrix, octave_float_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_float_matrix, octave_float_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_float_matrix, octave_float_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_matrix, octave_float_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_matrix, octave_float_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_matrix, octave_float_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_matrix, octave_float_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_matrix, octave_float_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_matrix, octave_float_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_matrix, octave_float_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_float_matrix, octave_float_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_float_matrix, octave_float_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_matrix, octave_float_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_matrix, octave_float_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_matrix, octave_float_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_float_matrix, octave_float_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_matrix, octave_float_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_matrix, octave_float_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_matrix, octave_float_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_matrix, octave_float_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_matrix, octave_float_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_matrix, octave_float_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_matrix, octave_float_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_matrix, octave_float_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_matrix, octave_float_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_matrix, octave_float_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_matrix, octave_float_complex_matrix, el_or); - INSTALL_BINOP (op_trans_mul, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_trans_mul, octave_float_matrix, octave_float_complex_matrix, trans_mul); - INSTALL_BINOP (op_herm_mul, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_herm_mul, octave_float_matrix, octave_float_complex_matrix, trans_mul); - INSTALL_BINOP (op_trans_ldiv, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_trans_ldiv, octave_float_matrix, octave_float_complex_matrix, trans_ldiv); - INSTALL_BINOP (op_herm_ldiv, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_herm_ldiv, octave_float_matrix, octave_float_complex_matrix, trans_ldiv); - INSTALL_CATOP (octave_float_matrix, octave_float_complex_matrix, fm_fcm); - INSTALL_CATOP (octave_matrix, octave_float_complex_matrix, m_fcm); - INSTALL_CATOP (octave_float_matrix, octave_complex_matrix, fm_cm); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_float_complex_matrix, fm_fcm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_float_complex_matrix, m_fcm); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_complex_matrix, fm_cm); - INSTALL_ASSIGNCONV (octave_float_matrix, octave_float_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_matrix, octave_float_complex_matrix, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_matrix, octave_float_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_float_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_float_matrix, octave_float_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_float_matrix, octave_float_complex_matrix, float_complex_matrix_conv); }
--- a/libinterp/operators/op-fm-fcs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fm-fcs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -134,34 +134,34 @@ float_complex_array, concat) void -install_fm_fcs_ops (void) +install_fm_fcs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_matrix, octave_float_complex, add); - INSTALL_BINOP (op_sub, octave_float_matrix, octave_float_complex, sub); - INSTALL_BINOP (op_mul, octave_float_matrix, octave_float_complex, mul); - INSTALL_BINOP (op_div, octave_float_matrix, octave_float_complex, div); - INSTALL_BINOP (op_pow, octave_float_matrix, octave_float_complex, pow); - INSTALL_BINOP (op_ldiv, octave_float_matrix, octave_float_complex, ldiv); - INSTALL_BINOP (op_lt, octave_float_matrix, octave_float_complex, lt); - INSTALL_BINOP (op_le, octave_float_matrix, octave_float_complex, le); - INSTALL_BINOP (op_eq, octave_float_matrix, octave_float_complex, eq); - INSTALL_BINOP (op_ge, octave_float_matrix, octave_float_complex, ge); - INSTALL_BINOP (op_gt, octave_float_matrix, octave_float_complex, gt); - INSTALL_BINOP (op_ne, octave_float_matrix, octave_float_complex, ne); - INSTALL_BINOP (op_el_mul, octave_float_matrix, octave_float_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_float_matrix, octave_float_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_float_matrix, octave_float_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_matrix, octave_float_complex, + INSTALL_BINOP_TI (ti, op_add, octave_float_matrix, octave_float_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_matrix, octave_float_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_matrix, octave_float_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_matrix, octave_float_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_matrix, octave_float_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_matrix, octave_float_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_matrix, octave_float_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_matrix, octave_float_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_matrix, octave_float_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_matrix, octave_float_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_matrix, octave_float_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_matrix, octave_float_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_matrix, octave_float_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_matrix, octave_float_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_matrix, octave_float_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_matrix, octave_float_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_matrix, octave_float_complex, el_and); - INSTALL_BINOP (op_el_or, octave_float_matrix, octave_float_complex, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_matrix, octave_float_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_matrix, octave_float_complex, el_or); - INSTALL_CATOP (octave_float_matrix, octave_float_complex, fm_fcs); - INSTALL_CATOP (octave_matrix, octave_float_complex, m_fcs); - INSTALL_CATOP (octave_float_matrix, octave_complex, fm_cs); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_float_complex, fm_fcs); + INSTALL_CATOP_TI (ti, octave_matrix, octave_float_complex, m_fcs); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_complex, fm_cs); - INSTALL_ASSIGNCONV (octave_float_matrix, octave_float_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_float_matrix, octave_float_complex, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_matrix, octave_float_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_float_complex, octave_complex_matrix); }
--- a/libinterp/operators/op-fm-fm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fm-fm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -187,79 +187,79 @@ quotient_eq) void -install_fm_fm_ops (void) +install_fm_fm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_float_matrix, not); - INSTALL_UNOP (op_uplus, octave_float_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_float_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_float_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_float_matrix, transpose); + INSTALL_UNOP_TI (ti, op_not, octave_float_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_float_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_float_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_float_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_float_matrix, transpose); - INSTALL_NCUNOP (op_incr, octave_float_matrix, incr); - INSTALL_NCUNOP (op_decr, octave_float_matrix, decr); - INSTALL_NCUNOP (op_uminus, octave_float_matrix, changesign); + INSTALL_NCUNOP_TI (ti, op_incr, octave_float_matrix, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_float_matrix, decr); + INSTALL_NCUNOP_TI (ti, op_uminus, octave_float_matrix, changesign); - INSTALL_BINOP (op_add, octave_float_matrix, octave_float_matrix, add); - INSTALL_BINOP (op_sub, octave_float_matrix, octave_float_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_matrix, octave_float_matrix, mul); - INSTALL_BINOP (op_div, octave_float_matrix, octave_float_matrix, div); - INSTALL_BINOP (op_pow, octave_float_matrix, octave_float_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_matrix, octave_float_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_matrix, octave_float_matrix, lt); - INSTALL_BINOP (op_le, octave_float_matrix, octave_float_matrix, le); - INSTALL_BINOP (op_eq, octave_float_matrix, octave_float_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_matrix, octave_float_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_matrix, octave_float_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_matrix, octave_float_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_matrix, octave_float_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_matrix, octave_float_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_matrix, octave_float_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_matrix, octave_float_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_matrix, octave_float_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_matrix, octave_float_matrix, el_or); - INSTALL_BINOP (op_el_and_not, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_float_matrix, octave_float_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_matrix, octave_float_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_matrix, octave_float_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_matrix, octave_float_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_matrix, octave_float_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_matrix, octave_float_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_matrix, octave_float_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_matrix, octave_float_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_matrix, octave_float_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_matrix, octave_float_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_matrix, octave_float_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_matrix, octave_float_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_matrix, octave_float_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_matrix, octave_float_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_matrix, octave_float_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_matrix, octave_float_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_matrix, octave_float_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_matrix, octave_float_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_and_not, octave_float_matrix, octave_float_matrix, el_and_not); - INSTALL_BINOP (op_el_or_not, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_or_not, octave_float_matrix, octave_float_matrix, el_or_not); - INSTALL_BINOP (op_el_not_and, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_not_and, octave_float_matrix, octave_float_matrix, el_not_and); - INSTALL_BINOP (op_el_not_or, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_el_not_or, octave_float_matrix, octave_float_matrix, el_not_or); - INSTALL_BINOP (op_trans_mul, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_trans_mul, octave_float_matrix, octave_float_matrix, trans_mul); - INSTALL_BINOP (op_mul_trans, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_mul_trans, octave_float_matrix, octave_float_matrix, mul_trans); - INSTALL_BINOP (op_herm_mul, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_herm_mul, octave_float_matrix, octave_float_matrix, trans_mul); - INSTALL_BINOP (op_mul_herm, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_mul_herm, octave_float_matrix, octave_float_matrix, mul_trans); - INSTALL_BINOP (op_trans_ldiv, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_trans_ldiv, octave_float_matrix, octave_float_matrix, trans_ldiv); - INSTALL_BINOP (op_herm_ldiv, octave_float_matrix, octave_float_matrix, + INSTALL_BINOP_TI (ti, op_herm_ldiv, octave_float_matrix, octave_float_matrix, trans_ldiv); - INSTALL_CATOP (octave_float_matrix, octave_float_matrix, fm_fm); - INSTALL_CATOP (octave_matrix, octave_float_matrix, m_fm); - INSTALL_CATOP (octave_float_matrix, octave_matrix, fm_m); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_float_matrix, fm_fm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_float_matrix, m_fm); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_matrix, fm_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_float_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_float_matrix, dbl_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_null_sq_str, null_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_float_matrix, octave_float_matrix, + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_float_matrix, octave_float_matrix, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_float_matrix, octave_float_matrix, + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_float_matrix, octave_float_matrix, assign_sub); - INSTALL_ASSIGNOP (op_el_mul_eq, octave_float_matrix, octave_float_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_mul_eq, octave_float_matrix, octave_float_matrix, assign_el_mul); - INSTALL_ASSIGNOP (op_el_div_eq, octave_float_matrix, octave_float_matrix, + INSTALL_ASSIGNOP_TI (ti, op_el_div_eq, octave_float_matrix, octave_float_matrix, assign_el_div); }
--- a/libinterp/operators/op-fm-fs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fm-fs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -131,41 +131,41 @@ DEFNDASSIGNOP_OP (assign_div, float_matrix, float_scalar, float_scalar, /=) void -install_fm_fs_ops (void) +install_fm_fs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_matrix, octave_float_scalar, add); - INSTALL_BINOP (op_sub, octave_float_matrix, octave_float_scalar, sub); - INSTALL_BINOP (op_mul, octave_float_matrix, octave_float_scalar, mul); - INSTALL_BINOP (op_div, octave_float_matrix, octave_float_scalar, div); - INSTALL_BINOP (op_pow, octave_float_matrix, octave_float_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_float_matrix, octave_float_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_float_matrix, octave_float_scalar, lt); - INSTALL_BINOP (op_le, octave_float_matrix, octave_float_scalar, le); - INSTALL_BINOP (op_eq, octave_float_matrix, octave_float_scalar, eq); - INSTALL_BINOP (op_ge, octave_float_matrix, octave_float_scalar, ge); - INSTALL_BINOP (op_gt, octave_float_matrix, octave_float_scalar, gt); - INSTALL_BINOP (op_ne, octave_float_matrix, octave_float_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_float_matrix, octave_float_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_float_matrix, octave_float_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_float_matrix, octave_float_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_matrix, octave_float_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_matrix, octave_float_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_float_matrix, octave_float_scalar, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_float_matrix, octave_float_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_matrix, octave_float_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_matrix, octave_float_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_matrix, octave_float_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_matrix, octave_float_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_matrix, octave_float_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_matrix, octave_float_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_matrix, octave_float_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_matrix, octave_float_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_matrix, octave_float_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_matrix, octave_float_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_matrix, octave_float_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_matrix, octave_float_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_matrix, octave_float_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_matrix, octave_float_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_matrix, octave_float_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_matrix, octave_float_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_matrix, octave_float_scalar, el_or); - INSTALL_CATOP (octave_float_matrix, octave_float_scalar, fm_fs); - INSTALL_CATOP (octave_matrix, octave_float_scalar, m_fs); - INSTALL_CATOP (octave_float_matrix, octave_scalar, fm_s); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_float_scalar, fm_fs); + INSTALL_CATOP_TI (ti, octave_matrix, octave_float_scalar, m_fs); + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_scalar, fm_s); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_float_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_float_scalar, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_float_scalar, dbl_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_float_scalar, dbl_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_float_matrix, octave_float_scalar, + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_float_matrix, octave_float_scalar, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_float_matrix, octave_float_scalar, + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_float_matrix, octave_float_scalar, assign_sub); - INSTALL_ASSIGNOP (op_mul_eq, octave_float_matrix, octave_float_scalar, + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_float_matrix, octave_float_scalar, assign_mul); - INSTALL_ASSIGNOP (op_div_eq, octave_float_matrix, octave_float_scalar, + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_float_matrix, octave_float_scalar, assign_div); }
--- a/libinterp/operators/op-fs-fcm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fs-fcm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -143,43 +143,43 @@ } void -install_fs_fcm_ops (void) +install_fs_fcm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_scalar, octave_float_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_float_scalar, octave_float_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_scalar, octave_float_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_float_scalar, octave_float_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_float_scalar, octave_float_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_add, octave_float_scalar, octave_float_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_scalar, octave_float_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_scalar, octave_float_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_scalar, octave_float_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_scalar, octave_float_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_scalar, octave_float_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_scalar, octave_float_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_float_scalar, octave_float_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_float_scalar, octave_float_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_scalar, octave_float_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_scalar, octave_float_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_scalar, octave_float_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_lt, octave_float_scalar, octave_float_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_scalar, octave_float_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_scalar, octave_float_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_scalar, octave_float_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_scalar, octave_float_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_scalar, octave_float_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_scalar, octave_float_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_div, octave_float_scalar, octave_float_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_scalar, octave_float_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_scalar, octave_float_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_and, octave_float_scalar, octave_float_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_scalar, + INSTALL_BINOP_TI (ti, op_el_or, octave_float_scalar, octave_float_complex_matrix, el_or); - INSTALL_CATOP (octave_float_scalar, octave_float_complex_matrix, fs_fcm); - INSTALL_CATOP (octave_scalar, octave_float_complex_matrix, s_fcm); - INSTALL_CATOP (octave_float_scalar, octave_complex_matrix, fs_cm); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_float_complex_matrix, fs_fcm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_float_complex_matrix, s_fcm); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_complex_matrix, fs_cm); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_float_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_float_complex_matrix, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_float_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_float_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_float_scalar, octave_float_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_float_scalar, octave_float_complex_matrix, float_complex_matrix_conv); }
--- a/libinterp/operators/op-fs-fcs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fs-fcs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -137,34 +137,34 @@ float_complex_array, concat) void -install_fs_fcs_ops (void) +install_fs_fcs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_scalar, octave_float_complex, add); - INSTALL_BINOP (op_sub, octave_float_scalar, octave_float_complex, sub); - INSTALL_BINOP (op_mul, octave_float_scalar, octave_float_complex, mul); - INSTALL_BINOP (op_div, octave_float_scalar, octave_float_complex, div); - INSTALL_BINOP (op_pow, octave_float_scalar, octave_float_complex, pow); - INSTALL_BINOP (op_ldiv, octave_float_scalar, octave_float_complex, ldiv); - INSTALL_BINOP (op_lt, octave_float_scalar, octave_float_complex, lt); - INSTALL_BINOP (op_le, octave_float_scalar, octave_float_complex, le); - INSTALL_BINOP (op_eq, octave_float_scalar, octave_float_complex, eq); - INSTALL_BINOP (op_ge, octave_float_scalar, octave_float_complex, ge); - INSTALL_BINOP (op_gt, octave_float_scalar, octave_float_complex, gt); - INSTALL_BINOP (op_ne, octave_float_scalar, octave_float_complex, ne); - INSTALL_BINOP (op_el_mul, octave_float_scalar, octave_float_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_float_scalar, octave_float_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_float_scalar, octave_float_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_scalar, octave_float_complex, + INSTALL_BINOP_TI (ti, op_add, octave_float_scalar, octave_float_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_scalar, octave_float_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_scalar, octave_float_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_scalar, octave_float_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_scalar, octave_float_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_scalar, octave_float_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_scalar, octave_float_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_scalar, octave_float_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_scalar, octave_float_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_scalar, octave_float_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_scalar, octave_float_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_scalar, octave_float_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_scalar, octave_float_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_scalar, octave_float_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_scalar, octave_float_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_scalar, octave_float_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_scalar, octave_float_complex, el_and); - INSTALL_BINOP (op_el_or, octave_float_scalar, octave_float_complex, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_scalar, octave_float_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_scalar, octave_float_complex, el_or); - INSTALL_CATOP (octave_float_scalar, octave_float_complex, fs_fcs); - INSTALL_CATOP (octave_scalar, octave_float_complex, s_fcs); - INSTALL_CATOP (octave_float_scalar, octave_complex, fs_cs); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_float_complex, fs_fcs); + INSTALL_CATOP_TI (ti, octave_scalar, octave_float_complex, s_fcs); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_complex, fs_cs); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_float_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_float_complex, octave_float_complex_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_float_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_float_complex, octave_complex_matrix); }
--- a/libinterp/operators/op-fs-fm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fs-fm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -125,34 +125,34 @@ } void -install_fs_fm_ops (void) +install_fs_fm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_float_scalar, octave_float_matrix, add); - INSTALL_BINOP (op_sub, octave_float_scalar, octave_float_matrix, sub); - INSTALL_BINOP (op_mul, octave_float_scalar, octave_float_matrix, mul); - INSTALL_BINOP (op_div, octave_float_scalar, octave_float_matrix, div); - INSTALL_BINOP (op_pow, octave_float_scalar, octave_float_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_float_scalar, octave_float_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_float_scalar, octave_float_matrix, lt); - INSTALL_BINOP (op_le, octave_float_scalar, octave_float_matrix, le); - INSTALL_BINOP (op_eq, octave_float_scalar, octave_float_matrix, eq); - INSTALL_BINOP (op_ge, octave_float_scalar, octave_float_matrix, ge); - INSTALL_BINOP (op_gt, octave_float_scalar, octave_float_matrix, gt); - INSTALL_BINOP (op_ne, octave_float_scalar, octave_float_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_float_scalar, octave_float_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_float_scalar, octave_float_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_float_scalar, octave_float_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_scalar, octave_float_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_scalar, octave_float_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_float_scalar, octave_float_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_float_scalar, octave_float_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_scalar, octave_float_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_scalar, octave_float_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_scalar, octave_float_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_scalar, octave_float_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_scalar, octave_float_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_scalar, octave_float_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_scalar, octave_float_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_scalar, octave_float_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_scalar, octave_float_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_scalar, octave_float_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_scalar, octave_float_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_scalar, octave_float_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_scalar, octave_float_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_scalar, octave_float_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_scalar, octave_float_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_scalar, octave_float_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_scalar, octave_float_matrix, el_or); - INSTALL_CATOP (octave_float_scalar, octave_float_matrix, fs_fm); - INSTALL_CATOP (octave_scalar, octave_float_matrix, s_fm); - INSTALL_CATOP (octave_float_scalar, octave_matrix, fs_m); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_float_matrix, fs_fm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_float_matrix, s_fm); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_matrix, fs_m); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_float_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_float_matrix, octave_float_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_float_matrix, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_float_matrix, octave_matrix); - INSTALL_WIDENOP (octave_float_scalar, octave_float_matrix, matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_float_scalar, octave_float_matrix, matrix_conv); }
--- a/libinterp/operators/op-fs-fs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-fs-fs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -138,48 +138,48 @@ DEFNDCATOP_FN (fs_s, float_scalar, scalar, float_array, float_array, concat) void -install_fs_fs_ops (void) +install_fs_fs_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_float_scalar, not); - INSTALL_UNOP (op_uplus, octave_float_scalar, uplus); - INSTALL_UNOP (op_uminus, octave_float_scalar, uminus); - INSTALL_UNOP (op_transpose, octave_float_scalar, transpose); - INSTALL_UNOP (op_hermitian, octave_float_scalar, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_float_scalar, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_float_scalar, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_float_scalar, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_float_scalar, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_float_scalar, hermitian); - INSTALL_NCUNOP (op_incr, octave_float_scalar, incr); - INSTALL_NCUNOP (op_decr, octave_float_scalar, decr); + INSTALL_NCUNOP_TI (ti, op_incr, octave_float_scalar, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_float_scalar, decr); - INSTALL_BINOP (op_add, octave_float_scalar, octave_float_scalar, add); - INSTALL_BINOP (op_sub, octave_float_scalar, octave_float_scalar, sub); - INSTALL_BINOP (op_mul, octave_float_scalar, octave_float_scalar, mul); - INSTALL_BINOP (op_div, octave_float_scalar, octave_float_scalar, div); - INSTALL_BINOP (op_pow, octave_float_scalar, octave_float_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_float_scalar, octave_float_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_float_scalar, octave_float_scalar, lt); - INSTALL_BINOP (op_le, octave_float_scalar, octave_float_scalar, le); - INSTALL_BINOP (op_eq, octave_float_scalar, octave_float_scalar, eq); - INSTALL_BINOP (op_ge, octave_float_scalar, octave_float_scalar, ge); - INSTALL_BINOP (op_gt, octave_float_scalar, octave_float_scalar, gt); - INSTALL_BINOP (op_ne, octave_float_scalar, octave_float_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_float_scalar, octave_float_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_float_scalar, octave_float_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_float_scalar, octave_float_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_float_scalar, octave_float_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_float_scalar, octave_float_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_float_scalar, octave_float_scalar, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_float_scalar, octave_float_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_float_scalar, octave_float_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_float_scalar, octave_float_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_float_scalar, octave_float_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_float_scalar, octave_float_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_float_scalar, octave_float_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_float_scalar, octave_float_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_float_scalar, octave_float_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_float_scalar, octave_float_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_float_scalar, octave_float_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_float_scalar, octave_float_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_float_scalar, octave_float_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_float_scalar, octave_float_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_float_scalar, octave_float_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_float_scalar, octave_float_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_float_scalar, octave_float_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_float_scalar, octave_float_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_float_scalar, octave_float_scalar, el_or); - INSTALL_CATOP (octave_float_scalar, octave_float_scalar, fs_fs); - INSTALL_CATOP (octave_scalar, octave_float_scalar, s_fs); - INSTALL_CATOP (octave_float_scalar, octave_scalar, fs_s); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_float_scalar, fs_fs); + INSTALL_CATOP_TI (ti, octave_scalar, octave_float_scalar, s_fs); + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_scalar, fs_s); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_float_scalar, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_float_scalar, octave_float_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_float_scalar, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_float_scalar, octave_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_null_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_null_matrix, octave_float_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_null_str, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_null_str, octave_float_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_null_sq_str, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_null_sq_str, octave_float_matrix); }
--- a/libinterp/operators/op-i16-i16.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-i16-i16.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (int16, uint64) void -install_i16_i16_ops (void) +install_i16_i16_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (int16);
--- a/libinterp/operators/op-i32-i32.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-i32-i32.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (int32, uint64) void -install_i32_i32_ops (void) +install_i32_i32_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (int32);
--- a/libinterp/operators/op-i64-i64.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-i64-i64.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (int64, uint64) void -install_i64_i64_ops (void) +install_i64_i64_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (int64);
--- a/libinterp/operators/op-i8-i8.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-i8-i8.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (int8, uint64) void -install_i8_i8_ops (void) +install_i8_i8_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (int8);
--- a/libinterp/operators/op-int-concat.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-int-concat.cc Fri Jan 05 18:44:53 2018 -0500 @@ -182,7 +182,7 @@ OCTAVE_CHAR_INT_CONCAT_FN (uint64) void -install_int_concat_ops (void) +install_int_concat_ops (octave::type_info& ti) { OCTAVE_INSTALL_CONCAT_FN2 (int8, int16); OCTAVE_INSTALL_CONCAT_FN2 (int8, int32);
--- a/libinterp/operators/op-int.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-int.h Fri Jan 05 18:44:53 2018 -0500 @@ -81,10 +81,10 @@ DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _m_m, T1 ## _matrix, T2 ## _matrix, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) #define OCTAVE_INSTALL_CONCAT_FN2(T1, T2) \ - INSTALL_CATOP (octave_ ## T1 ## _scalar, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _s_s) \ - INSTALL_CATOP (octave_ ## T1 ## _scalar, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _s_m) \ - INSTALL_CATOP (octave_ ## T1 ## _matrix, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _m_s) \ - INSTALL_CATOP (octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _m_m) + INSTALL_CATOP_TI (ti, octave_ ## T1 ## _scalar, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _s_s) \ + INSTALL_CATOP_TI (ti, octave_ ## T1 ## _scalar, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_ ## T1 ## _matrix, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _m_m) #define OCTAVE_DOUBLE_INT_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (double ## _ ## TYPE ## _s_s, scalar, TYPE ## _scalar, TYPE ## NDArray, , array, TYPE ## _array, concat) \ @@ -93,10 +93,10 @@ DEFNDCATOP_FN2 (double ## _ ## TYPE ## _m_m, matrix, TYPE ## _matrix, TYPE ## NDArray, , array, TYPE ## _array, concat) #define OCTAVE_INSTALL_DOUBLE_INT_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_scalar, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _s_s) \ - INSTALL_CATOP (octave_scalar, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _s_m) \ - INSTALL_CATOP (octave_matrix, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _m_s) \ - INSTALL_CATOP (octave_matrix, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _m_m) + INSTALL_CATOP_TI (ti, octave_scalar, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _s_s) \ + INSTALL_CATOP_TI (ti, octave_scalar, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_matrix, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_matrix, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _m_m) #define OCTAVE_INT_DOUBLE_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (TYPE ## _ ## double ## _s_s, TYPE ## _scalar, scalar, , TYPE ## NDArray, TYPE ## _array, array, concat) \ @@ -105,10 +105,10 @@ DEFNDCATOP_FN2 (TYPE ## _ ## double ## _m_m, TYPE ## _matrix, matrix, , TYPE ## NDArray, TYPE ## _array, array, concat) #define OCTAVE_INSTALL_INT_DOUBLE_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_scalar, TYPE ## _ ## double ## _s_s) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_matrix, TYPE ## _ ## double ## _s_m) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_scalar, TYPE ## _ ## double ## _m_s) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_matrix, TYPE ## _ ## double ## _m_m) + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_scalar, TYPE ## _ ## double ## _s_s) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_matrix, TYPE ## _ ## double ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_scalar, TYPE ## _ ## double ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_matrix, TYPE ## _ ## double ## _m_m) #define OCTAVE_FLOAT_INT_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (float ## _ ## TYPE ## _s_s, float_scalar, TYPE ## _scalar, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \ @@ -117,10 +117,10 @@ DEFNDCATOP_FN2 (float ## _ ## TYPE ## _m_m, float_matrix, TYPE ## _matrix, TYPE ## NDArray, , float_array, TYPE ## _array, concat) #define OCTAVE_INSTALL_FLOAT_INT_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_float_scalar, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _s_s) \ - INSTALL_CATOP (octave_float_scalar, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _s_m) \ - INSTALL_CATOP (octave_float_matrix, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _m_s) \ - INSTALL_CATOP (octave_float_matrix, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _m_m) + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _s_s) \ + INSTALL_CATOP_TI (ti, octave_float_scalar, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_float_matrix, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _m_m) #define OCTAVE_INT_FLOAT_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (TYPE ## _ ## float ## _s_s, TYPE ## _scalar, float_scalar, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \ @@ -129,10 +129,10 @@ DEFNDCATOP_FN2 (TYPE ## _ ## float ## _m_m, TYPE ## _matrix, float_matrix, , TYPE ## NDArray, TYPE ## _array, float_array, concat) #define OCTAVE_INSTALL_INT_FLOAT_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_float_scalar, TYPE ## _ ## float ## _s_s) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_float_matrix, TYPE ## _ ## float ## _s_m) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_float_scalar, TYPE ## _ ## float ## _m_s) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_float_matrix, TYPE ## _ ## float ## _m_m) + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_float_scalar, TYPE ## _ ## float ## _s_s) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_float_matrix, TYPE ## _ ## float ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_float_scalar, TYPE ## _ ## float ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_float_matrix, TYPE ## _ ## float ## _m_m) // For compatibility, concatenation with a character always returns a // character. @@ -142,20 +142,20 @@ DEFNDCHARCATOP_FN (char ## _ ## TYPE ## _m_m, char_matrix, TYPE ## _matrix, concat) #define OCTAVE_INSTALL_CHAR_INT_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_char_matrix_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \ - INSTALL_CATOP (octave_char_matrix_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) \ - INSTALL_CATOP (octave_char_matrix_sq_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \ - INSTALL_CATOP (octave_char_matrix_sq_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) + INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) \ + INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) #define OCTAVE_INT_CHAR_CONCAT_FN(TYPE) \ DEFNDCHARCATOP_FN (TYPE ## _ ## char ## _s_m, TYPE ## _scalar, char_matrix, concat) \ DEFNDCHARCATOP_FN (TYPE ## _ ## char ## _m_m, TYPE ## _matrix, char_matrix, concat) #define OCTAVE_INSTALL_INT_CHAR_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_char_matrix_str, TYPE ## _ ## char ## _s_m) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_char_matrix_str, TYPE ## _ ## char ## _m_m) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_char_matrix_sq_str, TYPE ## _ ## char ## _s_m) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_char_matrix_sq_str, TYPE ## _ ## char ## _m_m) + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_char_matrix_str, TYPE ## _ ## char ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_char_matrix_str, TYPE ## _ ## char ## _m_m) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_char_matrix_sq_str, TYPE ## _ ## char ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_char_matrix_sq_str, TYPE ## _ ## char ## _m_m) #define OCTAVE_CONCAT_FN(TYPE) \ DEFNDCATOP_FN (TYPE ## _s_s, TYPE ## _scalar, TYPE ## _scalar, TYPE ## _array, TYPE ## _array, concat) \ @@ -164,10 +164,10 @@ DEFNDCATOP_FN (TYPE ## _m_m, TYPE ## _matrix, TYPE ## _matrix, TYPE ## _array, TYPE ## _array, concat) #define OCTAVE_INSTALL_CONCAT_FN(TYPE) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, TYPE ## _s_s) \ - INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_m) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _scalar, TYPE ## _m_s) \ - INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix, TYPE ## _m_m) + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, TYPE ## _s_s) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_m) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _scalar, TYPE ## _m_s) \ + INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix, TYPE ## _m_m) // scalar unary ops. #define OCTAVE_S_INT_UNOPS(TYPE) \ @@ -893,38 +893,38 @@ OCTAVE_INT_NULL_ASSIGN_OPS(TYPE) #define OCTAVE_INSTALL_S_INT_UNOPS(TYPE) \ - INSTALL_UNOP (op_not, octave_ ## TYPE ## _scalar, s_not); \ - INSTALL_UNOP (op_uplus, octave_ ## TYPE ## _scalar, s_uplus); \ - INSTALL_UNOP (op_uminus, octave_ ## TYPE ## _scalar, s_uminus); \ - INSTALL_UNOP (op_transpose, octave_ ## TYPE ## _scalar, s_transpose); \ - INSTALL_UNOP (op_hermitian, octave_ ## TYPE ## _scalar, s_hermitian); \ + INSTALL_UNOP_TI (ti, op_not, octave_ ## TYPE ## _scalar, s_not); \ + INSTALL_UNOP_TI (ti, op_uplus, octave_ ## TYPE ## _scalar, s_uplus); \ + INSTALL_UNOP_TI (ti, op_uminus, octave_ ## TYPE ## _scalar, s_uminus); \ + INSTALL_UNOP_TI (ti, op_transpose, octave_ ## TYPE ## _scalar, s_transpose); \ + INSTALL_UNOP_TI (ti, op_hermitian, octave_ ## TYPE ## _scalar, s_hermitian); \ \ - INSTALL_NCUNOP (op_incr, octave_ ## TYPE ## _scalar, s_incr); \ - INSTALL_NCUNOP (op_decr, octave_ ## TYPE ## _scalar, s_decr); + INSTALL_NCUNOP_TI (ti, op_incr, octave_ ## TYPE ## _scalar, s_incr); \ + INSTALL_NCUNOP_TI (ti, op_decr, octave_ ## TYPE ## _scalar, s_decr); #define OCTAVE_INSTALL_SS_INT_ARITH_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _add); \ - INSTALL_BINOP (op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _sub); \ - INSTALL_BINOP (op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _mul); \ - INSTALL_BINOP (op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _div); \ - INSTALL_BINOP (op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _pow); \ - INSTALL_BINOP (op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ldiv); \ - INSTALL_BINOP (op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_mul); \ - INSTALL_BINOP (op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_div); \ - INSTALL_BINOP (op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_pow); \ - INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _add); \ + INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _sub); \ + INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _mul); \ + INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _div); \ + INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _pow); \ + INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ldiv); \ + INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_mul); \ + INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_div); \ + INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_pow); \ + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_ldiv); #define OCTAVE_INSTALL_SS_INT_CMP_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _lt); \ - INSTALL_BINOP (op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _le); \ - INSTALL_BINOP (op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _eq); \ - INSTALL_BINOP (op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ge); \ - INSTALL_BINOP (op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _gt); \ - INSTALL_BINOP (op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ne); + INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _lt); \ + INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _le); \ + INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _eq); \ + INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ge); \ + INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _gt); \ + INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ne); #define OCTAVE_INSTALL_SS_INT_BOOL_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_and); \ - INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_and); \ + INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_or); #define OCTAVE_INSTALL_SS_INT_OPS(TYPE) \ OCTAVE_INSTALL_S_INT_UNOPS (TYPE) \ @@ -943,37 +943,37 @@ OCTAVE_INSTALL_SS_INT_BOOL_OPS (xs, , TYPE ## _) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (sfx, TYPE ## _, float_) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (fxs, float_, TYPE ## _) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_scalar, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_scalar, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_complex_scalar, octave_complex_matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_complex_scalar, octave_float_complex_matrix) + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_scalar, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_scalar, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_complex_scalar, octave_complex_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_complex_scalar, octave_float_complex_matrix) #define OCTAVE_INSTALL_SM_INT_ARITH_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _add); \ - INSTALL_BINOP (op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _sub); \ - INSTALL_BINOP (op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _mul); \ - /* INSTALL_BINOP (op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _div); */ \ - /* INSTALL_BINOP (op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _pow); */ \ - INSTALL_BINOP (op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ldiv); \ - INSTALL_BINOP (op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_mul); \ - INSTALL_BINOP (op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_div); \ - INSTALL_BINOP (op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_pow); \ - INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _add); \ + INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _sub); \ + INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _mul); \ + /* INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _div); */ \ + /* INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _pow); */ \ + INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ldiv); \ + INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_mul); \ + INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_div); \ + INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_pow); \ + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_ldiv); #define OCTAVE_INSTALL_SM_INT_CMP_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _lt); \ - INSTALL_BINOP (op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _le); \ - INSTALL_BINOP (op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _eq); \ - INSTALL_BINOP (op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ge); \ - INSTALL_BINOP (op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _gt); \ - INSTALL_BINOP (op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ne); + INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _lt); \ + INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _le); \ + INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _eq); \ + INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ge); \ + INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _gt); \ + INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ne); #define OCTAVE_INSTALL_SM_INT_BOOL_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and); \ - INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or); \ - INSTALL_BINOP (op_el_and_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and_not); \ - INSTALL_BINOP (op_el_or_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or_not); + INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and); \ + INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or); \ + INSTALL_BINOP_TI (ti, op_el_and_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and_not); \ + INSTALL_BINOP_TI (ti, op_el_or_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or_not); #define OCTAVE_INSTALL_SM_INT_OPS(TYPE) \ OCTAVE_INSTALL_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _) \ @@ -991,50 +991,50 @@ OCTAVE_INSTALL_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (fxm, float_, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (smfx, TYPE ## _, float_) \ - INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_ ## TYPE ## _m_conv) \ - INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_complex_matrix, TYPE ## _s_complex_m_conv) \ - INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_float_complex_matrix, TYPE ## _s_float_complex_m_conv) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_matrix, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_matrix, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_complex_matrix, octave_complex_matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_complex_matrix, octave_float_complex_matrix) + INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_ ## TYPE ## _m_conv) \ + INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _scalar, octave_complex_matrix, TYPE ## _s_complex_m_conv) \ + INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _scalar, octave_float_complex_matrix, TYPE ## _s_float_complex_m_conv) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_matrix, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_matrix, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_complex_matrix, octave_complex_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_complex_matrix, octave_float_complex_matrix) #define OCTAVE_INSTALL_MS_INT_ARITH_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _add); \ - INSTALL_BINOP (op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _sub); \ - INSTALL_BINOP (op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _mul); \ - INSTALL_BINOP (op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _div); \ - /* INSTALL_BINOP (op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _pow); */ \ - /* INSTALL_BINOP (op_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ldiv); */ \ + INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _add); \ + INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _sub); \ + INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _mul); \ + INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _div); \ + /* INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _pow); */ \ + /* INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ldiv); */ \ \ - INSTALL_BINOP (op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_mul); \ - INSTALL_BINOP (op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_div); \ - INSTALL_BINOP (op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_pow); \ - INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_ldiv); + INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_mul); \ + INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_div); \ + INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_pow); \ + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_ldiv); #define OCTAVE_INSTALL_MS_INT_CMP_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _lt); \ - INSTALL_BINOP (op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _le); \ - INSTALL_BINOP (op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _eq); \ - INSTALL_BINOP (op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ge); \ - INSTALL_BINOP (op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _gt); \ - INSTALL_BINOP (op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ne); + INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _lt); \ + INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _le); \ + INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _eq); \ + INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ge); \ + INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _gt); \ + INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ne); #define OCTAVE_INSTALL_MS_INT_BOOL_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_and); \ - INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_or); \ - INSTALL_BINOP (op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_and); \ - INSTALL_BINOP (op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_and); \ + INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_or); \ + INSTALL_BINOP_TI (ti, op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_and); \ + INSTALL_BINOP_TI (ti, op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_or); #define OCTAVE_INSTALL_MS_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign) #define OCTAVE_INSTALL_MS_INT_ASSIGNEQ_OPS(PFX, TLHS, TRHS) \ - INSTALL_ASSIGNOP (op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_add) \ - INSTALL_ASSIGNOP (op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_sub) \ - INSTALL_ASSIGNOP (op_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_mul) \ - INSTALL_ASSIGNOP (op_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_div) + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_add) \ + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_sub) \ + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_mul) \ + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_div) #define OCTAVE_INSTALL_MS_INT_OPS(TYPE) \ OCTAVE_INSTALL_MS_INT_ARITH_OPS (ms, TYPE ## _, TYPE ## _) \ @@ -1056,56 +1056,56 @@ OCTAVE_INSTALL_MS_INT_ASSIGNEQ_OPS (mse, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mx, TYPE ## _, ) \ OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mfx, TYPE ## _, float_) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_complex_scalar, octave_complex_matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_float_complex_scalar, octave_float_complex_matrix) + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_complex_scalar, octave_complex_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_float_complex_scalar, octave_float_complex_matrix) #define OCTAVE_INSTALL_M_INT_UNOPS(TYPE) \ - INSTALL_UNOP (op_not, octave_ ## TYPE ## _matrix, m_not); \ - INSTALL_UNOP (op_uplus, octave_ ## TYPE ## _matrix, m_uplus); \ - INSTALL_UNOP (op_uminus, octave_ ## TYPE ## _matrix, m_uminus); \ - INSTALL_UNOP (op_transpose, octave_ ## TYPE ## _matrix, m_transpose); \ - INSTALL_UNOP (op_hermitian, octave_ ## TYPE ## _matrix, m_transpose); \ + INSTALL_UNOP_TI (ti, op_not, octave_ ## TYPE ## _matrix, m_not); \ + INSTALL_UNOP_TI (ti, op_uplus, octave_ ## TYPE ## _matrix, m_uplus); \ + INSTALL_UNOP_TI (ti, op_uminus, octave_ ## TYPE ## _matrix, m_uminus); \ + INSTALL_UNOP_TI (ti, op_transpose, octave_ ## TYPE ## _matrix, m_transpose); \ + INSTALL_UNOP_TI (ti, op_hermitian, octave_ ## TYPE ## _matrix, m_transpose); \ \ - INSTALL_NCUNOP (op_incr, octave_ ## TYPE ## _matrix, m_incr); \ - INSTALL_NCUNOP (op_decr, octave_ ## TYPE ## _matrix, m_decr); \ - INSTALL_NCUNOP (op_uminus, octave_ ## TYPE ## _matrix, m_changesign); + INSTALL_NCUNOP_TI (ti, op_incr, octave_ ## TYPE ## _matrix, m_incr); \ + INSTALL_NCUNOP_TI (ti, op_decr, octave_ ## TYPE ## _matrix, m_decr); \ + INSTALL_NCUNOP_TI (ti, op_uminus, octave_ ## TYPE ## _matrix, m_changesign); #define OCTAVE_INSTALL_MM_INT_ARITH_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _add); \ - INSTALL_BINOP (op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _sub); \ - /* INSTALL_BINOP (op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _mul); */ \ - /* INSTALL_BINOP (op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _div); */ \ - INSTALL_BINOP (op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _pow); \ - /* INSTALL_BINOP (op_ldiv, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_ldiv); */ \ - INSTALL_BINOP (op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_mul); \ - INSTALL_BINOP (op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_div); \ - INSTALL_BINOP (op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_pow); \ - INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _add); \ + INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _sub); \ + /* INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _mul); */ \ + /* INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _div); */ \ + INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _pow); \ + /* INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_ldiv); */ \ + INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_mul); \ + INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_div); \ + INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_pow); \ + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_ldiv); #define OCTAVE_INSTALL_MM_INT_CMP_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _lt); \ - INSTALL_BINOP (op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _le); \ - INSTALL_BINOP (op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _eq); \ - INSTALL_BINOP (op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ge); \ - INSTALL_BINOP (op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _gt); \ - INSTALL_BINOP (op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ne); + INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _lt); \ + INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _le); \ + INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _eq); \ + INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ge); \ + INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _gt); \ + INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ne); #define OCTAVE_INSTALL_MM_INT_BOOL_OPS(PFX, T1, T2) \ - INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and); \ - INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or); \ - INSTALL_BINOP (op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_and); \ - INSTALL_BINOP (op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_or); \ - INSTALL_BINOP (op_el_and_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and_not); \ - INSTALL_BINOP (op_el_or_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or_not); + INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and); \ + INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or); \ + INSTALL_BINOP_TI (ti, op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_and); \ + INSTALL_BINOP_TI (ti, op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_or); \ + INSTALL_BINOP_TI (ti, op_el_and_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and_not); \ + INSTALL_BINOP_TI (ti, op_el_or_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or_not); #define OCTAVE_INSTALL_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign) #define OCTAVE_INSTALL_MM_INT_ASSIGNEQ_OPS(PFX, TLHS, TRHS) \ - INSTALL_ASSIGNOP (op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_add) \ - INSTALL_ASSIGNOP (op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_sub) \ - INSTALL_ASSIGNOP (op_el_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_mul) \ - INSTALL_ASSIGNOP (op_el_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_div) + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_add) \ + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_sub) \ + INSTALL_ASSIGNOP_TI (ti, op_el_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_mul) \ + INSTALL_ASSIGNOP_TI (ti, op_el_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_div) #define OCTAVE_INSTALL_MM_INT_OPS(TYPE) \ OCTAVE_INSTALL_M_INT_UNOPS (TYPE) \ @@ -1128,42 +1128,42 @@ OCTAVE_INSTALL_MM_INT_ASSIGNEQ_OPS (mme, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, ) \ OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmfx, TYPE ## _, float_) \ - INSTALL_WIDENOP (octave_ ## TYPE ## _matrix, octave_complex_matrix, TYPE ## _m_complex_m_conv) \ - INSTALL_WIDENOP (octave_ ## TYPE ## _matrix, octave_float_complex_matrix, TYPE ## _m_float_complex_m_conv) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_complex_matrix, octave_complex_matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_float_complex_matrix, octave_float_complex_matrix) + INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _matrix, octave_complex_matrix, TYPE ## _m_complex_m_conv) \ + INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _matrix, octave_float_complex_matrix, TYPE ## _m_float_complex_m_conv) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_complex_matrix, octave_complex_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_float_complex_matrix, octave_float_complex_matrix) #define OCTAVE_INSTALL_RE_INT_ASSIGN_OPS(TYPE) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_ ## TYPE ## _scalar, TYPE ## ms_assign) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_ ## TYPE ## _matrix, TYPE ## mm_assign) \ - INSTALL_ASSIGNCONV (octave_scalar, octave_ ## TYPE ## _scalar, octave_matrix) \ - INSTALL_ASSIGNCONV (octave_matrix, octave_ ## TYPE ## _matrix, octave_matrix) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_ ## TYPE ## _scalar, TYPE ## ms_assign) \ + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_ ## TYPE ## _matrix, TYPE ## mm_assign) \ + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_ ## TYPE ## _scalar, octave_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_ ## TYPE ## _matrix, octave_matrix) #define OCTAVE_INSTALL_FLT_RE_INT_ASSIGN_OPS(TYPE) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _scalar, TYPE ## fms_assign) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _matrix, TYPE ## fmm_assign) \ - INSTALL_ASSIGNCONV (octave_float_scalar, octave_ ## TYPE ## _scalar, octave_float_matrix) \ - INSTALL_ASSIGNCONV (octave_float_matrix, octave_ ## TYPE ## _matrix, octave_float_matrix) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _scalar, TYPE ## fms_assign) \ + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _matrix, TYPE ## fmm_assign) \ + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_ ## TYPE ## _scalar, octave_float_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_float_matrix, octave_ ## TYPE ## _matrix, octave_float_matrix) #define OCTAVE_INSTALL_CX_INT_ASSIGN_OPS(TYPE) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## cms_assign) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## cmm_assign) \ - INSTALL_ASSIGNCONV (octave_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \ - INSTALL_ASSIGNCONV (octave_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## cms_assign) \ + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## cmm_assign) \ + INSTALL_ASSIGNCONV_TI (ti, octave_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix) #define OCTAVE_INSTALL_FLT_CX_INT_ASSIGN_OPS(TYPE) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## fcms_assign) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## fcmm_assign) \ - INSTALL_ASSIGNCONV (octave_float_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \ - INSTALL_ASSIGNCONV (octave_float_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## fcms_assign) \ + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## fcmm_assign) \ + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_float_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix) #define OCTAVE_INSTALL_INT_NULL_ASSIGN_OPS(TYPE) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_matrix, TYPE ## null_assign) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_str, TYPE ## null_assign) \ - INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_sq_str, TYPE ## null_assign) \ - INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_null_matrix, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_## TYPE ## _scalar, octave_null_str, octave_ ## TYPE ## _matrix) \ - INSTALL_ASSIGNCONV (octave_## TYPE ## _scalar, octave_null_sq_str, octave_ ## TYPE ## _matrix) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_matrix, TYPE ## null_assign) \ + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_str, TYPE ## null_assign) \ + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_sq_str, TYPE ## null_assign) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_null_matrix, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_## TYPE ## _scalar, octave_null_str, octave_ ## TYPE ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_## TYPE ## _scalar, octave_null_sq_str, octave_ ## TYPE ## _matrix) #define OCTAVE_INSTALL_INT_OPS(TYPE) \ OCTAVE_INSTALL_SS_INT_OPS (TYPE) \ @@ -1178,8 +1178,8 @@ OCTAVE_INSTALL_INT_NULL_ASSIGN_OPS(TYPE) #define OCTAVE_INSTALL_SM_INT_ASSIGNCONV(TLHS, TRHS) \ - INSTALL_ASSIGNCONV (octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _scalar, octave_ ## TLHS ## _matrix) \ - INSTALL_ASSIGNCONV (octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _matrix, octave_ ## TLHS ## _matrix) + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _scalar, octave_ ## TLHS ## _matrix) \ + INSTALL_ASSIGNCONV_TI (ti, octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _matrix, octave_ ## TLHS ## _matrix) #define OCTAVE_MIXED_INT_CMP_OPS(T1, T2) \ OCTAVE_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \
--- a/libinterp/operators/op-m-cm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-m-cm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -141,39 +141,39 @@ } void -install_m_cm_ops (void) +install_m_cm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_matrix, octave_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_matrix, octave_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_matrix, octave_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_matrix, octave_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_matrix, octave_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_matrix, octave_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_matrix, octave_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_matrix, octave_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_matrix, octave_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_matrix, octave_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_matrix, octave_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_matrix, octave_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_matrix, octave_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_matrix, octave_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_matrix, octave_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_matrix, octave_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_matrix, octave_complex_matrix, el_or); - INSTALL_BINOP (op_trans_mul, octave_matrix, octave_complex_matrix, trans_mul); - INSTALL_BINOP (op_herm_mul, octave_matrix, octave_complex_matrix, trans_mul); - INSTALL_BINOP (op_trans_ldiv, octave_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_complex_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_complex_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_complex_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_complex_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_complex_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_complex_matrix, el_or); + INSTALL_BINOP_TI (ti, op_trans_mul, octave_matrix, octave_complex_matrix, trans_mul); + INSTALL_BINOP_TI (ti, op_herm_mul, octave_matrix, octave_complex_matrix, trans_mul); + INSTALL_BINOP_TI (ti, op_trans_ldiv, octave_matrix, octave_complex_matrix, trans_ldiv); - INSTALL_BINOP (op_herm_ldiv, octave_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_herm_ldiv, octave_matrix, octave_complex_matrix, trans_ldiv); - INSTALL_CATOP (octave_matrix, octave_complex_matrix, m_cm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_complex_matrix, m_cm); - INSTALL_ASSIGNCONV (octave_matrix, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_complex_matrix, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_matrix, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_matrix, octave_complex_matrix, octave_float_complex_matrix); - INSTALL_WIDENOP (octave_matrix, octave_complex_matrix, complex_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_matrix, octave_complex_matrix, complex_matrix_conv); }
--- a/libinterp/operators/op-m-cs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-m-cs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -116,30 +116,30 @@ DEFNDCATOP_FN (m_cs, matrix, complex, array, complex_array, concat) void -install_m_cs_ops (void) +install_m_cs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_matrix, octave_complex, add); - INSTALL_BINOP (op_sub, octave_matrix, octave_complex, sub); - INSTALL_BINOP (op_mul, octave_matrix, octave_complex, mul); - INSTALL_BINOP (op_div, octave_matrix, octave_complex, div); - INSTALL_BINOP (op_pow, octave_matrix, octave_complex, pow); - INSTALL_BINOP (op_ldiv, octave_matrix, octave_complex, ldiv); - INSTALL_BINOP (op_lt, octave_matrix, octave_complex, lt); - INSTALL_BINOP (op_le, octave_matrix, octave_complex, le); - INSTALL_BINOP (op_eq, octave_matrix, octave_complex, eq); - INSTALL_BINOP (op_ge, octave_matrix, octave_complex, ge); - INSTALL_BINOP (op_gt, octave_matrix, octave_complex, gt); - INSTALL_BINOP (op_ne, octave_matrix, octave_complex, ne); - INSTALL_BINOP (op_el_mul, octave_matrix, octave_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_matrix, octave_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_matrix, octave_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_matrix, octave_complex, el_and); - INSTALL_BINOP (op_el_or, octave_matrix, octave_complex, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_complex, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_complex, el_or); - INSTALL_CATOP (octave_matrix, octave_complex, m_cs); + INSTALL_CATOP_TI (ti, octave_matrix, octave_complex, m_cs); - INSTALL_ASSIGNCONV (octave_matrix, octave_complex, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_matrix, octave_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_complex, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_float_matrix, octave_complex, octave_float_complex_matrix); }
--- a/libinterp/operators/op-m-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-m-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -159,58 +159,58 @@ DEFNDASSIGNOP_FNOP (assign_el_div, matrix, matrix, array, quotient_eq) void -install_m_m_ops (void) +install_m_m_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_matrix, not); - INSTALL_UNOP (op_uplus, octave_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_matrix, transpose); + INSTALL_UNOP_TI (ti, op_not, octave_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_matrix, transpose); - INSTALL_NCUNOP (op_incr, octave_matrix, incr); - INSTALL_NCUNOP (op_decr, octave_matrix, decr); - INSTALL_NCUNOP (op_uminus, octave_matrix, changesign); + INSTALL_NCUNOP_TI (ti, op_incr, octave_matrix, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_matrix, decr); + INSTALL_NCUNOP_TI (ti, op_uminus, octave_matrix, changesign); - INSTALL_BINOP (op_add, octave_matrix, octave_matrix, add); - INSTALL_BINOP (op_sub, octave_matrix, octave_matrix, sub); - INSTALL_BINOP (op_mul, octave_matrix, octave_matrix, mul); - INSTALL_BINOP (op_div, octave_matrix, octave_matrix, div); - INSTALL_BINOP (op_pow, octave_matrix, octave_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_matrix, octave_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_matrix, octave_matrix, lt); - INSTALL_BINOP (op_le, octave_matrix, octave_matrix, le); - INSTALL_BINOP (op_eq, octave_matrix, octave_matrix, eq); - INSTALL_BINOP (op_ge, octave_matrix, octave_matrix, ge); - INSTALL_BINOP (op_gt, octave_matrix, octave_matrix, gt); - INSTALL_BINOP (op_ne, octave_matrix, octave_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_matrix, octave_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_matrix, octave_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_matrix, octave_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_matrix, octave_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_matrix, octave_matrix, el_or); - INSTALL_BINOP (op_el_and_not, octave_matrix, octave_matrix, el_and_not); - INSTALL_BINOP (op_el_or_not, octave_matrix, octave_matrix, el_or_not); - INSTALL_BINOP (op_el_not_and, octave_matrix, octave_matrix, el_not_and); - INSTALL_BINOP (op_el_not_or, octave_matrix, octave_matrix, el_not_or); - INSTALL_BINOP (op_trans_mul, octave_matrix, octave_matrix, trans_mul); - INSTALL_BINOP (op_mul_trans, octave_matrix, octave_matrix, mul_trans); - INSTALL_BINOP (op_herm_mul, octave_matrix, octave_matrix, trans_mul); - INSTALL_BINOP (op_mul_herm, octave_matrix, octave_matrix, mul_trans); - INSTALL_BINOP (op_trans_ldiv, octave_matrix, octave_matrix, trans_ldiv); - INSTALL_BINOP (op_herm_ldiv, octave_matrix, octave_matrix, trans_ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_matrix, el_or); + INSTALL_BINOP_TI (ti, op_el_and_not, octave_matrix, octave_matrix, el_and_not); + INSTALL_BINOP_TI (ti, op_el_or_not, octave_matrix, octave_matrix, el_or_not); + INSTALL_BINOP_TI (ti, op_el_not_and, octave_matrix, octave_matrix, el_not_and); + INSTALL_BINOP_TI (ti, op_el_not_or, octave_matrix, octave_matrix, el_not_or); + INSTALL_BINOP_TI (ti, op_trans_mul, octave_matrix, octave_matrix, trans_mul); + INSTALL_BINOP_TI (ti, op_mul_trans, octave_matrix, octave_matrix, mul_trans); + INSTALL_BINOP_TI (ti, op_herm_mul, octave_matrix, octave_matrix, trans_mul); + INSTALL_BINOP_TI (ti, op_mul_herm, octave_matrix, octave_matrix, mul_trans); + INSTALL_BINOP_TI (ti, op_trans_ldiv, octave_matrix, octave_matrix, trans_ldiv); + INSTALL_BINOP_TI (ti, op_herm_ldiv, octave_matrix, octave_matrix, trans_ldiv); - INSTALL_CATOP (octave_matrix, octave_matrix, m_m); + INSTALL_CATOP_TI (ti, octave_matrix, octave_matrix, m_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_matrix, sgl_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_matrix, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_matrix, sgl_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_null_sq_str, null_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_null_matrix, null_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_null_str, null_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_null_sq_str, null_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_matrix, octave_matrix, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_matrix, octave_matrix, assign_sub); - INSTALL_ASSIGNOP (op_el_mul_eq, octave_matrix, octave_matrix, assign_el_mul); - INSTALL_ASSIGNOP (op_el_div_eq, octave_matrix, octave_matrix, assign_el_div); + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_matrix, octave_matrix, assign_add); + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_matrix, octave_matrix, assign_sub); + INSTALL_ASSIGNOP_TI (ti, op_el_mul_eq, octave_matrix, octave_matrix, assign_el_mul); + INSTALL_ASSIGNOP_TI (ti, op_el_div_eq, octave_matrix, octave_matrix, assign_el_div); }
--- a/libinterp/operators/op-m-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-m-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,42 +120,37 @@ DEFNDASSIGNOP_OP (assign_div, matrix, scalar, scalar, /=) void -install_m_s_ops (void) +install_m_s_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_matrix, octave_scalar, add); - INSTALL_BINOP (op_sub, octave_matrix, octave_scalar, sub); - INSTALL_BINOP (op_mul, octave_matrix, octave_scalar, mul); - INSTALL_BINOP (op_div, octave_matrix, octave_scalar, div); - INSTALL_BINOP (op_pow, octave_matrix, octave_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_matrix, octave_scalar, ldiv); - - // INSTALL_BINOP (op_lt, octave_matrix, octave_scalar, lt); - - octave_value_typeinfo::register_binary_op - (octave_value::op_lt, octave_matrix::static_type_id (), - octave_scalar::static_type_id (), oct_binop_lt); + INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_scalar, ldiv); - INSTALL_BINOP (op_le, octave_matrix, octave_scalar, le); - INSTALL_BINOP (op_eq, octave_matrix, octave_scalar, eq); - INSTALL_BINOP (op_ge, octave_matrix, octave_scalar, ge); - INSTALL_BINOP (op_gt, octave_matrix, octave_scalar, gt); - INSTALL_BINOP (op_ne, octave_matrix, octave_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_matrix, octave_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_matrix, octave_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_matrix, octave_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_matrix, octave_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_matrix, octave_scalar, el_or); + INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_scalar, el_or); - INSTALL_CATOP (octave_matrix, octave_scalar, m_s); + INSTALL_CATOP_TI (ti, octave_matrix, octave_scalar, m_s); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_scalar, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_scalar, sgl_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_scalar, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_scalar, sgl_assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_scalar, clx_sgl_assign); - INSTALL_ASSIGNOP (op_add_eq, octave_matrix, octave_scalar, assign_add); - INSTALL_ASSIGNOP (op_sub_eq, octave_matrix, octave_scalar, assign_sub); - INSTALL_ASSIGNOP (op_mul_eq, octave_matrix, octave_scalar, assign_mul); - INSTALL_ASSIGNOP (op_div_eq, octave_matrix, octave_scalar, assign_div); + INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_matrix, octave_scalar, assign_add); + INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_matrix, octave_scalar, assign_sub); + INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_matrix, octave_scalar, assign_mul); + INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_matrix, octave_scalar, assign_div); }
--- a/libinterp/operators/op-m-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-m-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -144,38 +144,38 @@ } void -install_m_scm_ops (void) +install_m_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_matrix, octave_sparse_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_matrix, octave_sparse_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_matrix, octave_sparse_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_matrix, octave_sparse_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_matrix, octave_sparse_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_matrix, octave_sparse_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_matrix, octave_sparse_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_matrix, octave_sparse_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_matrix, octave_sparse_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_matrix, octave_sparse_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_matrix, octave_sparse_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_matrix, octave_sparse_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_sparse_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_sparse_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_sparse_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_sparse_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_sparse_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_sparse_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_sparse_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_sparse_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_sparse_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_sparse_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_sparse_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_sparse_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_sparse_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_sparse_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_sparse_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_sparse_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_sparse_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_sparse_complex_matrix, el_or); - INSTALL_CATOP (octave_matrix, octave_sparse_complex_matrix, m_scm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_sparse_complex_matrix, m_scm); - INSTALL_ASSIGNCONV (octave_matrix, octave_sparse_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_sparse_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_matrix, octave_sparse_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_matrix, octave_sparse_complex_matrix, sparse_complex_matrix_conv); }
--- a/libinterp/operators/op-m-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-m-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -138,34 +138,34 @@ DEFNDASSIGNOP_FN (assign, matrix, sparse_matrix, array, assign) void -install_m_sm_ops (void) +install_m_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_matrix, octave_sparse_matrix, add); - INSTALL_BINOP (op_sub, octave_matrix, octave_sparse_matrix, sub); - INSTALL_BINOP (op_mul, octave_matrix, octave_sparse_matrix, mul); - INSTALL_BINOP (op_div, octave_matrix, octave_sparse_matrix, div); - INSTALL_BINOP (op_pow, octave_matrix, octave_sparse_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_matrix, octave_sparse_matrix, ldiv); - INSTALL_BINOP (op_mul_trans, octave_matrix, octave_sparse_matrix, mul_trans); - INSTALL_BINOP (op_mul_herm, octave_matrix, octave_sparse_matrix, mul_trans); - INSTALL_BINOP (op_lt, octave_matrix, octave_sparse_matrix, lt); - INSTALL_BINOP (op_le, octave_matrix, octave_sparse_matrix, le); - INSTALL_BINOP (op_eq, octave_matrix, octave_sparse_matrix, eq); - INSTALL_BINOP (op_ge, octave_matrix, octave_sparse_matrix, ge); - INSTALL_BINOP (op_gt, octave_matrix, octave_sparse_matrix, gt); - INSTALL_BINOP (op_ne, octave_matrix, octave_sparse_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_matrix, octave_sparse_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_matrix, octave_sparse_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_matrix, octave_sparse_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_sparse_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_matrix, octave_sparse_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_matrix, octave_sparse_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_sparse_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_sparse_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_sparse_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_sparse_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_sparse_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_sparse_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_mul_trans, octave_matrix, octave_sparse_matrix, mul_trans); + INSTALL_BINOP_TI (ti, op_mul_herm, octave_matrix, octave_sparse_matrix, mul_trans); + INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_sparse_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_sparse_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_sparse_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_sparse_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_sparse_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_sparse_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_sparse_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_sparse_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_sparse_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_sparse_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_sparse_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_sparse_matrix, el_or); - INSTALL_CATOP (octave_matrix, octave_sparse_matrix, m_sm); + INSTALL_CATOP_TI (ti, octave_matrix, octave_sparse_matrix, m_sm); - INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_sparse_matrix, assign) - INSTALL_ASSIGNCONV (octave_matrix, octave_sparse_matrix, octave_matrix) + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_sparse_matrix, assign) + INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_sparse_matrix, octave_matrix) - INSTALL_WIDENOP (octave_matrix, octave_sparse_matrix, + INSTALL_WIDENOP_TI (ti, octave_matrix, octave_sparse_matrix, sparse_matrix_conv); }
--- a/libinterp/operators/op-pm-pm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-pm-pm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -74,16 +74,16 @@ } void -install_pm_pm_ops (void) +install_pm_pm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_transpose, octave_perm_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_perm_matrix, transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_perm_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_perm_matrix, transpose); - INSTALL_BINOP (op_mul, octave_perm_matrix, octave_perm_matrix, mul); - INSTALL_BINOP (op_div, octave_perm_matrix, octave_perm_matrix, div); - INSTALL_BINOP (op_ldiv, octave_perm_matrix, octave_perm_matrix, ldiv); - INSTALL_BINOP (op_pow, octave_perm_matrix, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_mul, octave_perm_matrix, octave_perm_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_perm_matrix, octave_perm_matrix, div); + INSTALL_BINOP_TI (ti, op_ldiv, octave_perm_matrix, octave_perm_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_pow, octave_perm_matrix, octave_scalar, pow); - INSTALL_ASSIGNCONV (octave_perm_matrix, octave_matrix, octave_matrix); - INSTALL_WIDENOP (octave_perm_matrix, octave_matrix, perm_matrix_to_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_perm_matrix, octave_matrix, octave_matrix); + INSTALL_WIDENOP_TI (ti, octave_perm_matrix, octave_matrix, perm_matrix_to_matrix); }
--- a/libinterp/operators/op-pm-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-pm-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -92,14 +92,14 @@ } void -install_pm_scm_ops (void) +install_pm_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_mul, octave_perm_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_perm_matrix, octave_sparse_complex_matrix, mul_pm_scm); - INSTALL_BINOP (op_ldiv, octave_perm_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_perm_matrix, octave_sparse_complex_matrix, ldiv_pm_scm); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, octave_perm_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_perm_matrix, mul_scm_pm); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, octave_perm_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_perm_matrix, div_scm_pm); }
--- a/libinterp/operators/op-pm-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-pm-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -88,14 +88,14 @@ } void -install_pm_sm_ops (void) +install_pm_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_mul, octave_perm_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_perm_matrix, octave_sparse_matrix, mul_pm_sm); - INSTALL_BINOP (op_ldiv, octave_perm_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_perm_matrix, octave_sparse_matrix, ldiv_pm_sm); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_perm_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_perm_matrix, mul_sm_pm); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_perm_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_perm_matrix, div_sm_pm); }
--- a/libinterp/operators/op-pm-template.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-pm-template.cc Fri Jan 05 18:44:53 2018 -0500 @@ -80,17 +80,17 @@ #define INST_NAME CONCAT3(install_, SHORT_NAME, _ops) void -INST_NAME (void) +INST_NAME (octave::type_info& ti) { - INSTALL_BINOP (op_mul, OCTAVE_LMATRIX, OCTAVE_RMATRIX, mul); + INSTALL_BINOP_TI (ti, op_mul, OCTAVE_LMATRIX, OCTAVE_RMATRIX, mul); #if defined (LEFT) - INSTALL_BINOP (op_ldiv, OCTAVE_LMATRIX, OCTAVE_RMATRIX, ldiv); + INSTALL_BINOP_TI (ti, op_ldiv, OCTAVE_LMATRIX, OCTAVE_RMATRIX, ldiv); #else - INSTALL_BINOP (op_div, OCTAVE_LMATRIX, OCTAVE_RMATRIX, div); + INSTALL_BINOP_TI (ti, op_div, OCTAVE_LMATRIX, OCTAVE_RMATRIX, div); #endif #if defined (DEFINENULLASSIGNCONV) - INSTALL_ASSIGNCONV (OCTAVE_LMATRIX, octave_null_matrix, OCTAVE_LDMATRIX); - INSTALL_ASSIGNCONV (OCTAVE_LMATRIX, octave_null_str, OCTAVE_LDMATRIX); - INSTALL_ASSIGNCONV (OCTAVE_LMATRIX, octave_null_sq_str, OCTAVE_LDMATRIX); + INSTALL_ASSIGNCONV_TI (ti, OCTAVE_LMATRIX, octave_null_matrix, OCTAVE_LDMATRIX); + INSTALL_ASSIGNCONV_TI (ti, OCTAVE_LMATRIX, octave_null_str, OCTAVE_LDMATRIX); + INSTALL_ASSIGNCONV_TI (ti, OCTAVE_LMATRIX, octave_null_sq_str, OCTAVE_LDMATRIX); #endif }
--- a/libinterp/operators/op-range.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-range.cc Fri Jan 05 18:44:53 2018 -0500 @@ -94,49 +94,49 @@ } void -install_range_ops (void) +install_range_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_range, not); - INSTALL_UNOP (op_uplus, octave_range, uplus); - INSTALL_UNOP (op_uminus, octave_range, uminus); - INSTALL_UNOP (op_transpose, octave_range, transpose); - INSTALL_UNOP (op_hermitian, octave_range, transpose); + INSTALL_UNOP_TI (ti, op_not, octave_range, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_range, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_range, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_range, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_range, transpose); - INSTALL_BINOP (op_add, octave_range, octave_scalar, addrs); - INSTALL_BINOP (op_add, octave_scalar, octave_range, addsr); - INSTALL_BINOP (op_sub, octave_range, octave_scalar, subrs); - INSTALL_BINOP (op_sub, octave_scalar, octave_range, subsr); - INSTALL_BINOP (op_mul, octave_range, octave_scalar, mulrs); - INSTALL_BINOP (op_mul, octave_scalar, octave_range, mulsr); + INSTALL_BINOP_TI (ti, op_add, octave_range, octave_scalar, addrs); + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_range, addsr); + INSTALL_BINOP_TI (ti, op_sub, octave_range, octave_scalar, subrs); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_range, subsr); + INSTALL_BINOP_TI (ti, op_mul, octave_range, octave_scalar, mulrs); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_range, mulsr); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_range, el_powsr); - INSTALL_BINOP (op_el_pow, octave_complex, octave_range, el_powcsr); + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_range, el_powsr); + INSTALL_BINOP_TI (ti, op_el_pow, octave_complex, octave_range, el_powcsr); - INSTALL_CATOP (octave_range, octave_range, r_r); - INSTALL_CATOP (octave_range, octave_scalar, r_s); - INSTALL_CATOP (octave_range, octave_matrix, r_m); - INSTALL_CATOP (octave_range, octave_complex, r_cs); - INSTALL_CATOP (octave_range, octave_complex_matrix, r_cm); - INSTALL_CATOP (octave_range, octave_bool, r_b); - INSTALL_CATOP (octave_range, octave_bool_matrix, r_bm); - INSTALL_CATOP (octave_range, octave_char_matrix, r_chm); - INSTALL_CATOP (octave_scalar, octave_range, s_r); - INSTALL_CATOP (octave_matrix, octave_range, m_r); - INSTALL_CATOP (octave_complex, octave_range, cs_r); - INSTALL_CATOP (octave_complex_matrix, octave_range, cm_r); - INSTALL_CATOP (octave_bool, octave_range, b_r); - INSTALL_CATOP (octave_bool_matrix, octave_range, bm_r); - INSTALL_CATOP (octave_char_matrix, octave_range, chm_r); + INSTALL_CATOP_TI (ti, octave_range, octave_range, r_r); + INSTALL_CATOP_TI (ti, octave_range, octave_scalar, r_s); + INSTALL_CATOP_TI (ti, octave_range, octave_matrix, r_m); + INSTALL_CATOP_TI (ti, octave_range, octave_complex, r_cs); + INSTALL_CATOP_TI (ti, octave_range, octave_complex_matrix, r_cm); + INSTALL_CATOP_TI (ti, octave_range, octave_bool, r_b); + INSTALL_CATOP_TI (ti, octave_range, octave_bool_matrix, r_bm); + INSTALL_CATOP_TI (ti, octave_range, octave_char_matrix, r_chm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_range, s_r); + INSTALL_CATOP_TI (ti, octave_matrix, octave_range, m_r); + INSTALL_CATOP_TI (ti, octave_complex, octave_range, cs_r); + INSTALL_CATOP_TI (ti, octave_complex_matrix, octave_range, cm_r); + INSTALL_CATOP_TI (ti, octave_bool, octave_range, b_r); + INSTALL_CATOP_TI (ti, octave_bool_matrix, octave_range, bm_r); + INSTALL_CATOP_TI (ti, octave_char_matrix, octave_range, chm_r); // FIXME: this would be unneccessary if // octave_base_value::numeric_assign always tried converting lhs // before rhs. - INSTALL_ASSIGNCONV (octave_range, octave_null_matrix, octave_matrix); - INSTALL_ASSIGNCONV (octave_range, octave_null_str, octave_matrix); - INSTALL_ASSIGNCONV (octave_range, octave_null_sq_str, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_range, octave_null_matrix, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_range, octave_null_str, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_range, octave_null_sq_str, octave_matrix); // However, this should probably be here just in case we need it. - INSTALL_WIDENOP (octave_range, octave_matrix, range_to_matrix); + INSTALL_WIDENOP_TI (ti, octave_range, octave_matrix, range_to_matrix); }
--- a/libinterp/operators/op-s-cm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-s-cm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -118,33 +118,33 @@ } void -install_s_cm_ops (void) +install_s_cm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_scalar, octave_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_scalar, octave_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_scalar, octave_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_scalar, octave_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_scalar, octave_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_scalar, octave_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_scalar, octave_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_scalar, octave_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_scalar, octave_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_scalar, octave_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_scalar, octave_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_scalar, octave_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_scalar, octave_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_scalar, octave_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_scalar, octave_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_scalar, octave_complex_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_complex_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_complex_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_complex_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_complex_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_complex_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_complex_matrix, el_or); - INSTALL_CATOP (octave_scalar, octave_complex_matrix, s_cm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_complex_matrix, s_cm); - INSTALL_ASSIGNCONV (octave_scalar, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_complex_matrix, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_complex_matrix, octave_float_complex_matrix); - INSTALL_WIDENOP (octave_scalar, octave_complex_matrix, complex_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_scalar, octave_complex_matrix, complex_matrix_conv); }
--- a/libinterp/operators/op-s-cs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-s-cs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -127,30 +127,30 @@ DEFNDCATOP_FN (s_cs, scalar, complex, array, complex_array, concat) void -install_s_cs_ops (void) +install_s_cs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_scalar, octave_complex, add); - INSTALL_BINOP (op_sub, octave_scalar, octave_complex, sub); - INSTALL_BINOP (op_mul, octave_scalar, octave_complex, mul); - INSTALL_BINOP (op_div, octave_scalar, octave_complex, div); - INSTALL_BINOP (op_pow, octave_scalar, octave_complex, pow); - INSTALL_BINOP (op_ldiv, octave_scalar, octave_complex, ldiv); - INSTALL_BINOP (op_lt, octave_scalar, octave_complex, lt); - INSTALL_BINOP (op_le, octave_scalar, octave_complex, le); - INSTALL_BINOP (op_eq, octave_scalar, octave_complex, eq); - INSTALL_BINOP (op_ge, octave_scalar, octave_complex, ge); - INSTALL_BINOP (op_gt, octave_scalar, octave_complex, gt); - INSTALL_BINOP (op_ne, octave_scalar, octave_complex, ne); - INSTALL_BINOP (op_el_mul, octave_scalar, octave_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_scalar, octave_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_scalar, octave_complex, el_and); - INSTALL_BINOP (op_el_or, octave_scalar, octave_complex, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_complex, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_complex, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_complex, el_or); - INSTALL_CATOP (octave_scalar, octave_complex, s_cs); + INSTALL_CATOP_TI (ti, octave_scalar, octave_complex, s_cs); - INSTALL_ASSIGNCONV (octave_scalar, octave_complex, octave_complex_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_complex, octave_complex_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_complex, octave_float_complex_matrix); }
--- a/libinterp/operators/op-s-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-s-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -109,31 +109,31 @@ } void -install_s_m_ops (void) +install_s_m_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_scalar, octave_matrix, add); - INSTALL_BINOP (op_sub, octave_scalar, octave_matrix, sub); - INSTALL_BINOP (op_mul, octave_scalar, octave_matrix, mul); - INSTALL_BINOP (op_div, octave_scalar, octave_matrix, div); - INSTALL_BINOP (op_pow, octave_scalar, octave_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_scalar, octave_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_scalar, octave_matrix, lt); - INSTALL_BINOP (op_le, octave_scalar, octave_matrix, le); - INSTALL_BINOP (op_eq, octave_scalar, octave_matrix, eq); - INSTALL_BINOP (op_ge, octave_scalar, octave_matrix, ge); - INSTALL_BINOP (op_gt, octave_scalar, octave_matrix, gt); - INSTALL_BINOP (op_ne, octave_scalar, octave_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_scalar, octave_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_scalar, octave_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_scalar, octave_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_scalar, octave_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_matrix, el_or); - INSTALL_CATOP (octave_scalar, octave_matrix, s_m); + INSTALL_CATOP_TI (ti, octave_scalar, octave_matrix, s_m); - INSTALL_ASSIGNCONV (octave_scalar, octave_matrix, octave_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_matrix, octave_float_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_matrix, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_matrix, octave_float_matrix); - INSTALL_WIDENOP (octave_scalar, octave_matrix, matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_scalar, octave_matrix, matrix_conv); }
--- a/libinterp/operators/op-s-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-s-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -136,42 +136,42 @@ DEFNDCATOP_FN (s_s, scalar, scalar, array, array, concat) void -install_s_s_ops (void) +install_s_s_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_scalar, not); - INSTALL_UNOP (op_uplus, octave_scalar, uplus); - INSTALL_UNOP (op_uminus, octave_scalar, uminus); - INSTALL_UNOP (op_transpose, octave_scalar, transpose); - INSTALL_UNOP (op_hermitian, octave_scalar, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_scalar, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_scalar, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_scalar, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_scalar, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_scalar, hermitian); - INSTALL_NCUNOP (op_incr, octave_scalar, incr); - INSTALL_NCUNOP (op_decr, octave_scalar, decr); + INSTALL_NCUNOP_TI (ti, op_incr, octave_scalar, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_scalar, decr); - INSTALL_BINOP (op_add, octave_scalar, octave_scalar, add); - INSTALL_BINOP (op_sub, octave_scalar, octave_scalar, sub); - INSTALL_BINOP (op_mul, octave_scalar, octave_scalar, mul); - INSTALL_BINOP (op_div, octave_scalar, octave_scalar, div); - INSTALL_BINOP (op_pow, octave_scalar, octave_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_scalar, octave_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_scalar, octave_scalar, lt); - INSTALL_BINOP (op_le, octave_scalar, octave_scalar, le); - INSTALL_BINOP (op_eq, octave_scalar, octave_scalar, eq); - INSTALL_BINOP (op_ge, octave_scalar, octave_scalar, ge); - INSTALL_BINOP (op_gt, octave_scalar, octave_scalar, gt); - INSTALL_BINOP (op_ne, octave_scalar, octave_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_scalar, octave_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_scalar, octave_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_scalar, octave_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_scalar, octave_scalar, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_scalar, el_or); - INSTALL_CATOP (octave_scalar, octave_scalar, s_s); + INSTALL_CATOP_TI (ti, octave_scalar, octave_scalar, s_s); - INSTALL_ASSIGNCONV (octave_scalar, octave_scalar, octave_matrix); - INSTALL_ASSIGNCONV (octave_float_scalar, octave_scalar, octave_float_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_scalar, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_scalar, octave_float_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_null_matrix, octave_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_null_str, octave_matrix); - INSTALL_ASSIGNCONV (octave_scalar, octave_null_sq_str, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_null_matrix, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_null_str, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_null_sq_str, octave_matrix); }
--- a/libinterp/operators/op-s-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-s-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -148,38 +148,38 @@ } void -install_s_scm_ops (void) +install_s_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_scalar, octave_sparse_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_scalar, octave_sparse_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_scalar, octave_sparse_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_scalar, octave_sparse_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_scalar, octave_sparse_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_scalar, octave_sparse_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_scalar, octave_sparse_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_scalar, octave_sparse_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_scalar, octave_sparse_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_scalar, octave_sparse_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_scalar, octave_sparse_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_scalar, octave_sparse_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_scalar, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_sparse_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_sparse_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_sparse_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_sparse_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_sparse_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_sparse_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_sparse_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_sparse_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_sparse_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_sparse_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_sparse_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_sparse_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_sparse_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_scalar, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_sparse_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_sparse_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_sparse_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_scalar, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_sparse_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_scalar, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_sparse_complex_matrix, el_or); - INSTALL_CATOP (octave_scalar, octave_sparse_complex_matrix, s_scm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_sparse_complex_matrix, s_scm); - INSTALL_ASSIGNCONV (octave_scalar, octave_sparse_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_sparse_complex_matrix, octave_complex_matrix); - INSTALL_WIDENOP (octave_scalar, octave_sparse_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_scalar, octave_sparse_complex_matrix, sparse_complex_matrix_conv); }
--- a/libinterp/operators/op-s-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-s-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -137,30 +137,30 @@ } void -install_s_sm_ops (void) +install_s_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_scalar, octave_sparse_matrix, add); - INSTALL_BINOP (op_sub, octave_scalar, octave_sparse_matrix, sub); - INSTALL_BINOP (op_mul, octave_scalar, octave_sparse_matrix, mul); - INSTALL_BINOP (op_div, octave_scalar, octave_sparse_matrix, div); - INSTALL_BINOP (op_pow, octave_scalar, octave_sparse_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_scalar, octave_sparse_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_scalar, octave_sparse_matrix, lt); - INSTALL_BINOP (op_le, octave_scalar, octave_sparse_matrix, le); - INSTALL_BINOP (op_eq, octave_scalar, octave_sparse_matrix, eq); - INSTALL_BINOP (op_ge, octave_scalar, octave_sparse_matrix, ge); - INSTALL_BINOP (op_gt, octave_scalar, octave_sparse_matrix, gt); - INSTALL_BINOP (op_ne, octave_scalar, octave_sparse_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_scalar, octave_sparse_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_scalar, octave_sparse_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_scalar, octave_sparse_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_sparse_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_scalar, octave_sparse_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_scalar, octave_sparse_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_sparse_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_sparse_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_sparse_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_sparse_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_sparse_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_sparse_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_sparse_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_sparse_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_sparse_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_sparse_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_sparse_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_sparse_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_sparse_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_sparse_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_sparse_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_sparse_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_sparse_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_sparse_matrix, el_or); - INSTALL_CATOP (octave_scalar, octave_sparse_matrix, s_sm); + INSTALL_CATOP_TI (ti, octave_scalar, octave_sparse_matrix, s_sm); - INSTALL_ASSIGNCONV (octave_scalar, octave_sparse_matrix, octave_matrix); + INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_sparse_matrix, octave_matrix); - INSTALL_WIDENOP (octave_scalar, octave_sparse_matrix, sparse_matrix_conv); + INSTALL_WIDENOP_TI (ti, octave_scalar, octave_sparse_matrix, sparse_matrix_conv); }
--- a/libinterp/operators/op-sbm-b.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sbm-b.cc Fri Jan 05 18:44:53 2018 -0500 @@ -107,38 +107,38 @@ } void -install_sbm_b_ops (void) +install_sbm_b_ops (octave::type_info& ti) { - INSTALL_BINOP (op_eq, octave_sparse_bool_matrix, octave_bool, eq); - INSTALL_BINOP (op_ne, octave_sparse_bool_matrix, octave_bool, ne); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_bool_matrix, octave_bool, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_bool_matrix, octave_bool, ne); - INSTALL_BINOP (op_el_and, octave_sparse_bool_matrix, octave_bool, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_bool_matrix, octave_bool, el_or); + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_bool_matrix, octave_bool, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_bool_matrix, octave_bool, el_or); - INSTALL_CATOP (octave_sparse_bool_matrix, octave_bool, sbm_b); - INSTALL_CATOP (octave_sparse_bool_matrix, octave_scalar, sbm_s); - INSTALL_CATOP (octave_sparse_matrix, octave_bool, sm_b); + INSTALL_CATOP_TI (ti, octave_sparse_bool_matrix, octave_bool, sbm_b); + INSTALL_CATOP_TI (ti, octave_sparse_bool_matrix, octave_scalar, sbm_s); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_bool, sm_b); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_bool, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_bool, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int8_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int8_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int16_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int16_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int32_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int32_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int64_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int64_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint8_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint8_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint16_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint16_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint32_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint32_scalar, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint64_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint64_scalar, conv_and_assign); }
--- a/libinterp/operators/op-sbm-bm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sbm-bm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -113,58 +113,58 @@ } void -install_sbm_bm_ops (void) +install_sbm_bm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_eq, octave_sparse_bool_matrix, octave_bool_matrix, eq); - INSTALL_BINOP (op_ne, octave_sparse_bool_matrix, octave_bool_matrix, ne); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_bool_matrix, octave_bool_matrix, eq); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_bool_matrix, octave_bool_matrix, ne); - INSTALL_BINOP (op_el_and, octave_sparse_bool_matrix, octave_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_bool_matrix, octave_bool_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_bool_matrix, octave_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_bool_matrix, octave_bool_matrix, el_or); - INSTALL_CATOP (octave_sparse_bool_matrix, octave_bool_matrix, sbm_bm); - INSTALL_CATOP (octave_sparse_matrix, octave_bool_matrix, sm_bm); - INSTALL_CATOP (octave_sparse_bool_matrix, octave_matrix, sbm_m); + INSTALL_CATOP_TI (ti, octave_sparse_bool_matrix, octave_bool_matrix, sbm_bm); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_bool_matrix, sm_bm); + INSTALL_CATOP_TI (ti, octave_sparse_bool_matrix, octave_matrix, sbm_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_bool_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_char_matrix_str, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_char_matrix_sq_str, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_range, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_range, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_sparse_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_sparse_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int8_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int8_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int16_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int16_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int32_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int32_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_int64_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_int64_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint8_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint8_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint16_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint16_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint32_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint32_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_uint64_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_uint64_matrix, conv_and_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_null_sq_str, null_assign); }
--- a/libinterp/operators/op-sbm-sbm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sbm-sbm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -79,29 +79,29 @@ assign) void -install_sbm_sbm_ops (void) +install_sbm_sbm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_sparse_bool_matrix, not); - INSTALL_UNOP (op_uplus, octave_sparse_bool_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_sparse_bool_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_sparse_bool_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_sparse_bool_matrix, transpose); + INSTALL_UNOP_TI (ti, op_not, octave_sparse_bool_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_sparse_bool_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_sparse_bool_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_sparse_bool_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_sparse_bool_matrix, transpose); - INSTALL_BINOP (op_eq, octave_sparse_bool_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_bool_matrix, octave_sparse_bool_matrix, eq); - INSTALL_BINOP (op_ne, octave_sparse_bool_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_bool_matrix, octave_sparse_bool_matrix, ne); - INSTALL_BINOP (op_el_and, octave_sparse_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_bool_matrix, octave_sparse_bool_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_bool_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_bool_matrix, octave_sparse_bool_matrix, el_or); - INSTALL_CATOP (octave_sparse_bool_matrix, octave_sparse_bool_matrix, + INSTALL_CATOP_TI (ti, octave_sparse_bool_matrix, octave_sparse_bool_matrix, sbm_sbm); - INSTALL_CATOP (octave_sparse_bool_matrix, octave_sparse_matrix, sbm_sm); - INSTALL_CATOP (octave_sparse_matrix, octave_sparse_bool_matrix, sm_sbm); + INSTALL_CATOP_TI (ti, octave_sparse_bool_matrix, octave_sparse_matrix, sbm_sm); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_sparse_bool_matrix, sm_sbm); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_bool_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_bool_matrix, octave_sparse_bool_matrix, assign); }
--- a/libinterp/operators/op-scm-cm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-scm-cm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -157,52 +157,52 @@ } void -install_scm_cm_ops (void) +install_scm_cm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_complex_matrix, octave_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_complex_matrix, octave_complex_matrix, ldiv); - INSTALL_BINOP (op_trans_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_trans_mul, octave_sparse_complex_matrix, octave_complex_matrix, trans_mul); - INSTALL_BINOP (op_herm_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_herm_mul, octave_sparse_complex_matrix, octave_complex_matrix, herm_mul); - INSTALL_BINOP (op_lt, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_complex_matrix, octave_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_le, octave_sparse_complex_matrix, octave_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_complex_matrix, octave_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_complex_matrix, octave_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_complex_matrix, octave_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_complex_matrix, octave_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_complex_matrix, octave_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_complex_matrix, octave_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_complex_matrix, octave_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_complex_matrix, octave_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_complex_matrix, octave_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_complex_matrix, octave_complex_matrix, el_or); - INSTALL_CATOP (octave_sparse_complex_matrix, + INSTALL_CATOP_TI (ti, octave_sparse_complex_matrix, octave_complex_matrix, scm_cm); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_complex_matrix, assign); }
--- a/libinterp/operators/op-scm-cs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-scm-cs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -159,36 +159,36 @@ } void -install_scm_cs_ops (void) +install_scm_cs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, octave_complex, add); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, octave_complex, sub); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, octave_complex, mul); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, octave_complex, div); - INSTALL_BINOP (op_pow, octave_sparse_complex_matrix, octave_complex, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_complex_matrix, octave_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_complex_matrix, octave_complex, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_complex_matrix, octave_complex, lt); - INSTALL_BINOP (op_le, octave_sparse_complex_matrix, octave_complex, le); - INSTALL_BINOP (op_eq, octave_sparse_complex_matrix, octave_complex, eq); - INSTALL_BINOP (op_ge, octave_sparse_complex_matrix, octave_complex, ge); - INSTALL_BINOP (op_gt, octave_sparse_complex_matrix, octave_complex, gt); - INSTALL_BINOP (op_ne, octave_sparse_complex_matrix, octave_complex, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_complex_matrix, octave_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_complex_matrix, octave_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_complex_matrix, octave_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_complex_matrix, octave_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_complex_matrix, octave_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_complex_matrix, octave_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_complex_matrix, octave_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_complex_matrix, octave_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_complex_matrix, octave_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_complex_matrix, octave_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_complex_matrix, octave_complex, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_complex_matrix, octave_complex, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_complex_matrix, octave_complex, el_or); - INSTALL_CATOP (octave_sparse_complex_matrix, octave_complex, scm_cs); + INSTALL_CATOP_TI (ti, octave_sparse_complex_matrix, octave_complex, scm_cs); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, octave_complex, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_complex, assign); }
--- a/libinterp/operators/op-scm-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-scm-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -149,35 +149,35 @@ } void -install_scm_m_ops (void) +install_scm_m_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, octave_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, octave_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, octave_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, octave_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_complex_matrix, octave_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_complex_matrix, octave_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_complex_matrix, octave_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_complex_matrix, octave_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_complex_matrix, octave_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_complex_matrix, octave_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_complex_matrix, octave_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_complex_matrix, octave_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_complex_matrix, octave_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_complex_matrix, octave_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_complex_matrix, octave_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_complex_matrix, octave_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_complex_matrix, octave_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_complex_matrix, octave_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_complex_matrix, octave_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_complex_matrix, octave_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_complex_matrix, octave_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_complex_matrix, octave_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_complex_matrix, octave_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_complex_matrix, octave_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_complex_matrix, octave_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_complex_matrix, octave_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_complex_matrix, octave_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_complex_matrix, octave_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_complex_matrix, octave_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_complex_matrix, octave_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_complex_matrix, octave_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_complex_matrix, octave_matrix, el_or); - INSTALL_CATOP (octave_sparse_complex_matrix, octave_matrix, scm_m); + INSTALL_CATOP_TI (ti, octave_sparse_complex_matrix, octave_matrix, scm_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, octave_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_matrix, assign); }
--- a/libinterp/operators/op-scm-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-scm-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -166,35 +166,35 @@ } void -install_scm_s_ops (void) +install_scm_s_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, octave_scalar, add); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, octave_scalar, sub); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, octave_scalar, mul); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, octave_scalar, div); - INSTALL_BINOP (op_pow, octave_sparse_complex_matrix, octave_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_complex_matrix, octave_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_complex_matrix, octave_scalar, lt); - INSTALL_BINOP (op_le, octave_sparse_complex_matrix, octave_scalar, le); - INSTALL_BINOP (op_eq, octave_sparse_complex_matrix, octave_scalar, eq); - INSTALL_BINOP (op_ge, octave_sparse_complex_matrix, octave_scalar, ge); - INSTALL_BINOP (op_gt, octave_sparse_complex_matrix, octave_scalar, gt); - INSTALL_BINOP (op_ne, octave_sparse_complex_matrix, octave_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_complex_matrix, octave_scalar, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_complex_matrix, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_complex_matrix, octave_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_complex_matrix, octave_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_complex_matrix, octave_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_complex_matrix, octave_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_complex_matrix, octave_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_complex_matrix, octave_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_complex_matrix, octave_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_complex_matrix, octave_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_complex_matrix, octave_scalar, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_complex_matrix, octave_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_complex_matrix, octave_scalar, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_complex_matrix, octave_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_complex_matrix, octave_scalar, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_complex_matrix, octave_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_complex_matrix, octave_scalar, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_complex_matrix, octave_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_complex_matrix, octave_scalar, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_complex_matrix, octave_scalar, el_or); - INSTALL_CATOP (octave_sparse_complex_matrix, octave_scalar, scm_s); + INSTALL_CATOP_TI (ti, octave_sparse_complex_matrix, octave_scalar, scm_s); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_scalar, assign); }
--- a/libinterp/operators/op-scm-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-scm-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -188,66 +188,66 @@ DEFNULLASSIGNOP_FN (null_assign, sparse_complex_matrix, delete_elements) void -install_scm_scm_ops (void) +install_scm_scm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_sparse_complex_matrix, not); - INSTALL_UNOP (op_uplus, octave_sparse_complex_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_sparse_complex_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_sparse_complex_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_sparse_complex_matrix, hermitian); + INSTALL_UNOP_TI (ti, op_not, octave_sparse_complex_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_sparse_complex_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_sparse_complex_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_sparse_complex_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_sparse_complex_matrix, hermitian); #if 0 - INSTALL_NCUNOP (op_incr, octave_sparse_complex_matrix, incr); - INSTALL_NCUNOP (op_decr, octave_sparse_complex_matrix, decr); + INSTALL_NCUNOP_TI (ti, op_incr, octave_sparse_complex_matrix, incr); + INSTALL_NCUNOP_TI (ti, op_decr, octave_sparse_complex_matrix, decr); #endif - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_sparse_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_sparse_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_sparse_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_sparse_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_complex_matrix, octave_sparse_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_complex_matrix, octave_sparse_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_complex_matrix, octave_sparse_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_le, octave_sparse_complex_matrix, octave_sparse_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_complex_matrix, octave_sparse_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_complex_matrix, octave_sparse_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_complex_matrix, octave_sparse_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_complex_matrix, octave_sparse_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_complex_matrix, octave_sparse_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_complex_matrix, octave_sparse_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_complex_matrix, octave_sparse_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_complex_matrix, octave_sparse_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_complex_matrix, octave_sparse_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_complex_matrix, octave_sparse_complex_matrix, el_or); - INSTALL_CATOP (octave_sparse_complex_matrix, + INSTALL_CATOP_TI (ti, octave_sparse_complex_matrix, octave_sparse_complex_matrix, scm_scm); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_sparse_complex_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_null_sq_str, null_assign); }
--- a/libinterp/operators/op-scm-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-scm-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -135,47 +135,47 @@ DEFASSIGNOP_FN (assign, sparse_complex_matrix, sparse_matrix, assign) void -install_scm_sm_ops (void) +install_scm_sm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_complex_matrix, octave_sparse_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_complex_matrix, octave_sparse_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_complex_matrix, octave_sparse_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_complex_matrix, octave_sparse_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_complex_matrix, octave_sparse_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_complex_matrix, octave_sparse_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_complex_matrix, octave_sparse_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_le, octave_sparse_complex_matrix, octave_sparse_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_complex_matrix, octave_sparse_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_complex_matrix, octave_sparse_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_complex_matrix, octave_sparse_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_complex_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_complex_matrix, octave_sparse_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_complex_matrix, octave_sparse_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_complex_matrix, octave_sparse_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_complex_matrix, octave_sparse_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_complex_matrix, octave_sparse_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_complex_matrix, octave_sparse_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_complex_matrix, octave_sparse_matrix, el_or); - INSTALL_CATOP (octave_sparse_complex_matrix, octave_sparse_matrix, scm_sm); + INSTALL_CATOP_TI (ti, octave_sparse_complex_matrix, octave_sparse_matrix, scm_sm); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_complex_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_complex_matrix, octave_sparse_matrix, assign); }
--- a/libinterp/operators/op-sm-cm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sm-cm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -147,38 +147,38 @@ } void -install_sm_cm_ops (void) +install_sm_cm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_matrix, octave_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_complex_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_complex_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_complex_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_complex_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_matrix, octave_complex_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_matrix, octave_complex_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_matrix, octave_complex_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_matrix, octave_complex_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_matrix, octave_complex_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_matrix, octave_complex_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_matrix, octave_complex_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_matrix, octave_complex_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_matrix, octave_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_matrix, octave_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_matrix, octave_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_matrix, octave_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_matrix, octave_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_matrix, octave_complex_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_matrix, octave_complex_matrix, el_or); - INSTALL_CATOP (octave_sparse_matrix, octave_complex_matrix, sm_cm); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_complex_matrix, sm_cm); - INSTALL_ASSIGNCONV (octave_sparse_matrix, octave_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_sparse_matrix, octave_complex_matrix, octave_sparse_complex_matrix); - INSTALL_WIDENOP (octave_sparse_matrix, octave_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_sparse_matrix, octave_complex_matrix, sparse_complex_matrix_conv); }
--- a/libinterp/operators/op-sm-cs.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sm-cs.cc Fri Jan 05 18:44:53 2018 -0500 @@ -142,30 +142,30 @@ } void -install_sm_cs_ops (void) +install_sm_cs_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_complex, add); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_complex, sub); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_complex, mul); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_complex, div); - INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_complex, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_complex, ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_complex, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_complex, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_complex, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_complex, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_matrix, octave_complex, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_matrix, octave_complex, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_complex, lt); - INSTALL_BINOP (op_le, octave_sparse_matrix, octave_complex, le); - INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_complex, eq); - INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_complex, ge); - INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_complex, gt); - INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_complex, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_matrix, octave_complex, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_matrix, octave_complex, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_matrix, octave_complex, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, octave_complex, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_matrix, octave_complex, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_matrix, octave_complex, el_or); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_matrix, octave_complex, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_matrix, octave_complex, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_matrix, octave_complex, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_matrix, octave_complex, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_matrix, octave_complex, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_matrix, octave_complex, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_matrix, octave_complex, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_matrix, octave_complex, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_matrix, octave_complex, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_matrix, octave_complex, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_matrix, octave_complex, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_matrix, octave_complex, el_or); - INSTALL_CATOP (octave_sparse_matrix, octave_complex, sm_cs); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_complex, sm_cs); - INSTALL_ASSIGNCONV (octave_sparse_matrix, octave_complex, + INSTALL_ASSIGNCONV_TI (ti, octave_sparse_matrix, octave_complex, octave_sparse_complex_matrix); }
--- a/libinterp/operators/op-sm-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sm-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -141,30 +141,30 @@ } void -install_sm_m_ops (void) +install_sm_m_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_matrix, ldiv); - INSTALL_BINOP (op_trans_mul, octave_sparse_matrix, octave_matrix, trans_mul); - INSTALL_BINOP (op_herm_mul, octave_sparse_matrix, octave_matrix, trans_mul); - INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_matrix, octave_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_matrix, octave_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_matrix, octave_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_matrix, octave_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, octave_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_matrix, octave_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_matrix, octave_matrix, el_or); + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_matrix, octave_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_matrix, octave_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_trans_mul, octave_sparse_matrix, octave_matrix, trans_mul); + INSTALL_BINOP_TI (ti, op_herm_mul, octave_sparse_matrix, octave_matrix, trans_mul); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_matrix, octave_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_matrix, octave_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_matrix, octave_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_matrix, octave_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_matrix, octave_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_matrix, octave_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_matrix, octave_matrix, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_matrix, octave_matrix, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_matrix, octave_matrix, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_matrix, octave_matrix, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_matrix, octave_matrix, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_matrix, octave_matrix, el_or); - INSTALL_CATOP (octave_sparse_matrix, octave_matrix, sm_m); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_matrix, sm_m); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_matrix, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_matrix, octave_matrix, assign); }
--- a/libinterp/operators/op-sm-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sm-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -154,29 +154,29 @@ } void -install_sm_s_ops (void) +install_sm_s_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_scalar, add); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_scalar, sub); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_scalar, mul); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_scalar, div); - INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_scalar, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_scalar, ldiv); + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_scalar, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_scalar, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_scalar, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_scalar, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_matrix, octave_scalar, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_matrix, octave_scalar, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_scalar, lt); - INSTALL_BINOP (op_le, octave_sparse_matrix, octave_scalar, le); - INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_scalar, eq); - INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_scalar, ge); - INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_scalar, gt); - INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_scalar, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_matrix, octave_scalar, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_matrix, octave_scalar, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_matrix, octave_scalar, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, octave_scalar, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_matrix, octave_scalar, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_matrix, octave_scalar, el_or); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_matrix, octave_scalar, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_matrix, octave_scalar, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_matrix, octave_scalar, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_matrix, octave_scalar, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_matrix, octave_scalar, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_matrix, octave_scalar, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_matrix, octave_scalar, el_mul); + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_matrix, octave_scalar, el_div); + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_matrix, octave_scalar, el_pow); + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_matrix, octave_scalar, el_ldiv); + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_matrix, octave_scalar, el_and); + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_matrix, octave_scalar, el_or); - INSTALL_CATOP (octave_sparse_matrix, octave_scalar, sm_s); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_scalar, sm_s); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_scalar, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_matrix, octave_scalar, assign); }
--- a/libinterp/operators/op-sm-scm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sm-scm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -141,50 +141,50 @@ } void -install_sm_scm_ops (void) +install_sm_scm_ops (octave::type_info& ti) { - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_sparse_complex_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_sparse_complex_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_sparse_complex_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_sparse_complex_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_matrix, octave_sparse_complex_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_matrix, octave_sparse_complex_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_matrix, octave_sparse_complex_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_le, octave_sparse_matrix, octave_sparse_complex_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_matrix, octave_sparse_complex_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_matrix, octave_sparse_complex_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_matrix, octave_sparse_complex_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_matrix, octave_sparse_complex_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_matrix, octave_sparse_complex_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_matrix, octave_sparse_complex_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_matrix, octave_sparse_complex_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_matrix, octave_sparse_complex_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_matrix, octave_sparse_complex_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_matrix, octave_sparse_complex_matrix, el_or); - INSTALL_CATOP (octave_sparse_matrix, octave_sparse_complex_matrix, sm_scm); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_sparse_complex_matrix, sm_scm); - INSTALL_ASSIGNCONV (octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_ASSIGNCONV_TI (ti, octave_sparse_matrix, octave_sparse_complex_matrix, octave_sparse_complex_matrix); - INSTALL_WIDENOP (octave_sparse_matrix, octave_sparse_complex_matrix, + INSTALL_WIDENOP_TI (ti, octave_sparse_matrix, octave_sparse_complex_matrix, sparse_complex_matrix_conv); }
--- a/libinterp/operators/op-sm-sm.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-sm-sm.cc Fri Jan 05 18:44:53 2018 -0500 @@ -156,48 +156,48 @@ DEFNULLASSIGNOP_FN (null_assign, sparse_matrix, delete_elements) void -install_sm_sm_ops (void) +install_sm_sm_ops (octave::type_info& ti) { - INSTALL_UNOP (op_not, octave_sparse_matrix, not); - INSTALL_UNOP (op_uplus, octave_sparse_matrix, uplus); - INSTALL_UNOP (op_uminus, octave_sparse_matrix, uminus); - INSTALL_UNOP (op_transpose, octave_sparse_matrix, transpose); - INSTALL_UNOP (op_hermitian, octave_sparse_matrix, transpose); + INSTALL_UNOP_TI (ti, op_not, octave_sparse_matrix, not); + INSTALL_UNOP_TI (ti, op_uplus, octave_sparse_matrix, uplus); + INSTALL_UNOP_TI (ti, op_uminus, octave_sparse_matrix, uminus); + INSTALL_UNOP_TI (ti, op_transpose, octave_sparse_matrix, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_sparse_matrix, transpose); - INSTALL_BINOP (op_add, octave_sparse_matrix, octave_sparse_matrix, add); - INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_sparse_matrix, sub); - INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_sparse_matrix, mul); - INSTALL_BINOP (op_div, octave_sparse_matrix, octave_sparse_matrix, div); - INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_sparse_matrix, pow); - INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_sparse_matrix, ldiv); - INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_sparse_matrix, lt); - INSTALL_BINOP (op_le, octave_sparse_matrix, octave_sparse_matrix, le); - INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_sparse_matrix, eq); - INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_sparse_matrix, ge); - INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_sparse_matrix, gt); - INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_sparse_matrix, ne); - INSTALL_BINOP (op_el_mul, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_add, octave_sparse_matrix, octave_sparse_matrix, add); + INSTALL_BINOP_TI (ti, op_sub, octave_sparse_matrix, octave_sparse_matrix, sub); + INSTALL_BINOP_TI (ti, op_mul, octave_sparse_matrix, octave_sparse_matrix, mul); + INSTALL_BINOP_TI (ti, op_div, octave_sparse_matrix, octave_sparse_matrix, div); + INSTALL_BINOP_TI (ti, op_pow, octave_sparse_matrix, octave_sparse_matrix, pow); + INSTALL_BINOP_TI (ti, op_ldiv, octave_sparse_matrix, octave_sparse_matrix, ldiv); + INSTALL_BINOP_TI (ti, op_lt, octave_sparse_matrix, octave_sparse_matrix, lt); + INSTALL_BINOP_TI (ti, op_le, octave_sparse_matrix, octave_sparse_matrix, le); + INSTALL_BINOP_TI (ti, op_eq, octave_sparse_matrix, octave_sparse_matrix, eq); + INSTALL_BINOP_TI (ti, op_ge, octave_sparse_matrix, octave_sparse_matrix, ge); + INSTALL_BINOP_TI (ti, op_gt, octave_sparse_matrix, octave_sparse_matrix, gt); + INSTALL_BINOP_TI (ti, op_ne, octave_sparse_matrix, octave_sparse_matrix, ne); + INSTALL_BINOP_TI (ti, op_el_mul, octave_sparse_matrix, octave_sparse_matrix, el_mul); - INSTALL_BINOP (op_el_div, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_div, octave_sparse_matrix, octave_sparse_matrix, el_div); - INSTALL_BINOP (op_el_pow, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_pow, octave_sparse_matrix, octave_sparse_matrix, el_pow); - INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_ldiv, octave_sparse_matrix, octave_sparse_matrix, el_ldiv); - INSTALL_BINOP (op_el_and, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_and, octave_sparse_matrix, octave_sparse_matrix, el_and); - INSTALL_BINOP (op_el_or, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_BINOP_TI (ti, op_el_or, octave_sparse_matrix, octave_sparse_matrix, el_or); - INSTALL_CATOP (octave_sparse_matrix, octave_sparse_matrix, sm_sm); + INSTALL_CATOP_TI (ti, octave_sparse_matrix, octave_sparse_matrix, sm_sm); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_sparse_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_matrix, octave_sparse_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_matrix, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_matrix, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_sparse_matrix, octave_null_sq_str, null_assign); }
--- a/libinterp/operators/op-str-m.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-str-m.cc Fri Jan 05 18:44:53 2018 -0500 @@ -51,15 +51,15 @@ DEFNDCHARCATOP_FN (m_str, matrix, char_matrix_str, concat) void -install_str_m_ops (void) +install_str_m_ops (octave::type_info& ti) { - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, octave_matrix, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, octave_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_matrix, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_matrix, assign); - INSTALL_CATOP (octave_char_matrix_str, octave_matrix, str_m); - INSTALL_CATOP (octave_char_matrix_sq_str, octave_matrix, str_m); + INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_matrix, str_m); + INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_matrix, str_m); - INSTALL_CATOP (octave_matrix, octave_char_matrix_str, m_str); - INSTALL_CATOP (octave_matrix, octave_char_matrix_sq_str, m_str); + INSTALL_CATOP_TI (ti, octave_matrix, octave_char_matrix_str, m_str); + INSTALL_CATOP_TI (ti, octave_matrix, octave_char_matrix_sq_str, m_str); }
--- a/libinterp/operators/op-str-s.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-str-s.cc Fri Jan 05 18:44:53 2018 -0500 @@ -51,15 +51,15 @@ DEFNDCHARCATOP_FN (s_str, scalar, char_matrix_str, concat) void -install_str_s_ops (void) +install_str_s_ops (octave::type_info& ti) { - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, octave_scalar, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, octave_scalar, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_scalar, assign); + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_scalar, assign); - INSTALL_CATOP (octave_char_matrix_str, octave_scalar, str_s); - INSTALL_CATOP (octave_char_matrix_sq_str, octave_scalar, str_s); + INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_scalar, str_s); + INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_scalar, str_s); - INSTALL_CATOP (octave_scalar, octave_char_matrix_str, s_str); - INSTALL_CATOP (octave_scalar, octave_char_matrix_sq_str, s_str); + INSTALL_CATOP_TI (ti, octave_scalar, octave_char_matrix_str, s_str); + INSTALL_CATOP_TI (ti, octave_scalar, octave_char_matrix_sq_str, s_str); }
--- a/libinterp/operators/op-str-str.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-str-str.cc Fri Jan 05 18:44:53 2018 -0500 @@ -110,77 +110,77 @@ DEFNDCHARCATOP_FN (str_str, char_matrix_str, char_matrix_str, concat) void -install_str_str_ops (void) +install_str_str_ops (octave::type_info& ti) { - INSTALL_UNOP (op_transpose, octave_char_matrix_str, transpose); - INSTALL_UNOP (op_transpose, octave_char_matrix_sq_str, transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_char_matrix_str, transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_char_matrix_sq_str, transpose); - INSTALL_UNOP (op_hermitian, octave_char_matrix_str, transpose); - INSTALL_UNOP (op_hermitian, octave_char_matrix_sq_str, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_char_matrix_str, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_char_matrix_sq_str, transpose); - INSTALL_BINOP (op_lt, octave_char_matrix_str, octave_char_matrix_str, lt); - INSTALL_BINOP (op_lt, octave_char_matrix_str, octave_char_matrix_sq_str, lt); - INSTALL_BINOP (op_lt, octave_char_matrix_sq_str, octave_char_matrix_str, lt); - INSTALL_BINOP (op_lt, octave_char_matrix_sq_str, octave_char_matrix_sq_str, + INSTALL_BINOP_TI (ti, op_lt, octave_char_matrix_str, octave_char_matrix_str, lt); + INSTALL_BINOP_TI (ti, op_lt, octave_char_matrix_str, octave_char_matrix_sq_str, lt); + INSTALL_BINOP_TI (ti, op_lt, octave_char_matrix_sq_str, octave_char_matrix_str, lt); + INSTALL_BINOP_TI (ti, op_lt, octave_char_matrix_sq_str, octave_char_matrix_sq_str, lt); - INSTALL_BINOP (op_le, octave_char_matrix_str, octave_char_matrix_str, le); - INSTALL_BINOP (op_le, octave_char_matrix_str, octave_char_matrix_sq_str, le); - INSTALL_BINOP (op_le, octave_char_matrix_sq_str, octave_char_matrix_str, le); - INSTALL_BINOP (op_le, octave_char_matrix_sq_str, octave_char_matrix_sq_str, + INSTALL_BINOP_TI (ti, op_le, octave_char_matrix_str, octave_char_matrix_str, le); + INSTALL_BINOP_TI (ti, op_le, octave_char_matrix_str, octave_char_matrix_sq_str, le); + INSTALL_BINOP_TI (ti, op_le, octave_char_matrix_sq_str, octave_char_matrix_str, le); + INSTALL_BINOP_TI (ti, op_le, octave_char_matrix_sq_str, octave_char_matrix_sq_str, le); - INSTALL_BINOP (op_eq, octave_char_matrix_str, octave_char_matrix_str, eq); - INSTALL_BINOP (op_eq, octave_char_matrix_str, octave_char_matrix_sq_str, eq); - INSTALL_BINOP (op_eq, octave_char_matrix_sq_str, octave_char_matrix_str, eq); - INSTALL_BINOP (op_eq, octave_char_matrix_sq_str, octave_char_matrix_sq_str, + INSTALL_BINOP_TI (ti, op_eq, octave_char_matrix_str, octave_char_matrix_str, eq); + INSTALL_BINOP_TI (ti, op_eq, octave_char_matrix_str, octave_char_matrix_sq_str, eq); + INSTALL_BINOP_TI (ti, op_eq, octave_char_matrix_sq_str, octave_char_matrix_str, eq); + INSTALL_BINOP_TI (ti, op_eq, octave_char_matrix_sq_str, octave_char_matrix_sq_str, eq); - INSTALL_BINOP (op_ge, octave_char_matrix_str, octave_char_matrix_str, ge); - INSTALL_BINOP (op_ge, octave_char_matrix_str, octave_char_matrix_sq_str, ge); - INSTALL_BINOP (op_ge, octave_char_matrix_sq_str, octave_char_matrix_str, ge); - INSTALL_BINOP (op_ge, octave_char_matrix_sq_str, octave_char_matrix_sq_str, + INSTALL_BINOP_TI (ti, op_ge, octave_char_matrix_str, octave_char_matrix_str, ge); + INSTALL_BINOP_TI (ti, op_ge, octave_char_matrix_str, octave_char_matrix_sq_str, ge); + INSTALL_BINOP_TI (ti, op_ge, octave_char_matrix_sq_str, octave_char_matrix_str, ge); + INSTALL_BINOP_TI (ti, op_ge, octave_char_matrix_sq_str, octave_char_matrix_sq_str, ge); - INSTALL_BINOP (op_gt, octave_char_matrix_str, octave_char_matrix_str, gt); - INSTALL_BINOP (op_gt, octave_char_matrix_str, octave_char_matrix_sq_str, gt); - INSTALL_BINOP (op_gt, octave_char_matrix_sq_str, octave_char_matrix_str, gt); - INSTALL_BINOP (op_gt, octave_char_matrix_sq_str, octave_char_matrix_sq_str, + INSTALL_BINOP_TI (ti, op_gt, octave_char_matrix_str, octave_char_matrix_str, gt); + INSTALL_BINOP_TI (ti, op_gt, octave_char_matrix_str, octave_char_matrix_sq_str, gt); + INSTALL_BINOP_TI (ti, op_gt, octave_char_matrix_sq_str, octave_char_matrix_str, gt); + INSTALL_BINOP_TI (ti, op_gt, octave_char_matrix_sq_str, octave_char_matrix_sq_str, gt); - INSTALL_BINOP (op_ne, octave_char_matrix_str, octave_char_matrix_str, ne); - INSTALL_BINOP (op_ne, octave_char_matrix_str, octave_char_matrix_sq_str, ne); - INSTALL_BINOP (op_ne, octave_char_matrix_sq_str, octave_char_matrix_str, ne); - INSTALL_BINOP (op_ne, octave_char_matrix_sq_str, octave_char_matrix_sq_str, + INSTALL_BINOP_TI (ti, op_ne, octave_char_matrix_str, octave_char_matrix_str, ne); + INSTALL_BINOP_TI (ti, op_ne, octave_char_matrix_str, octave_char_matrix_sq_str, ne); + INSTALL_BINOP_TI (ti, op_ne, octave_char_matrix_sq_str, octave_char_matrix_str, ne); + INSTALL_BINOP_TI (ti, op_ne, octave_char_matrix_sq_str, octave_char_matrix_sq_str, ne); - INSTALL_CATOP (octave_char_matrix_str, octave_char_matrix_str, str_str); - INSTALL_CATOP (octave_char_matrix_str, octave_char_matrix_sq_str, str_str); - INSTALL_CATOP (octave_char_matrix_sq_str, octave_char_matrix_str, str_str); - INSTALL_CATOP (octave_char_matrix_sq_str, octave_char_matrix_sq_str, str_str); + INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_char_matrix_str, str_str); + INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_char_matrix_sq_str, str_str); + INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_char_matrix_str, str_str); + INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_char_matrix_sq_str, str_str); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, octave_char_matrix_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_char_matrix_str, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_char_matrix_sq_str, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_char_matrix_str, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_char_matrix_sq_str, assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_str, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_str, octave_null_sq_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, octave_null_matrix, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_null_matrix, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, octave_null_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_null_str, null_assign); - INSTALL_ASSIGNOP (op_asn_eq, octave_char_matrix_sq_str, octave_null_sq_str, + INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_char_matrix_sq_str, octave_null_sq_str, null_assign); }
--- a/libinterp/operators/op-struct.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-struct.cc Fri Jan 05 18:44:53 2018 -0500 @@ -89,19 +89,19 @@ } void -install_struct_ops (void) +install_struct_ops (octave::type_info& ti) { - INSTALL_UNOP (op_transpose, octave_struct, transpose); - INSTALL_UNOP (op_hermitian, octave_struct, transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_struct, transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_struct, transpose); - INSTALL_UNOP (op_transpose, octave_scalar_struct, scalar_transpose); - INSTALL_UNOP (op_hermitian, octave_scalar_struct, scalar_transpose); + INSTALL_UNOP_TI (ti, op_transpose, octave_scalar_struct, scalar_transpose); + INSTALL_UNOP_TI (ti, op_hermitian, octave_scalar_struct, scalar_transpose); - INSTALL_CATOP (octave_struct, octave_struct, s_s_concat); - INSTALL_CATOP (octave_struct, octave_scalar_struct, s_ss_concat) - INSTALL_CATOP (octave_scalar_struct, octave_struct, ss_s_concat) - INSTALL_CATOP (octave_scalar_struct, octave_scalar_struct, ss_ss_concat) + INSTALL_CATOP_TI (ti, octave_struct, octave_struct, s_s_concat); + INSTALL_CATOP_TI (ti, octave_struct, octave_scalar_struct, s_ss_concat) + INSTALL_CATOP_TI (ti, octave_scalar_struct, octave_struct, ss_s_concat) + INSTALL_CATOP_TI (ti, octave_scalar_struct, octave_scalar_struct, ss_ss_concat) - INSTALL_CATOP (octave_struct, octave_matrix, struct_matrix); - INSTALL_CATOP (octave_matrix, octave_struct, matrix_struct); + INSTALL_CATOP_TI (ti, octave_struct, octave_matrix, struct_matrix); + INSTALL_CATOP_TI (ti, octave_matrix, octave_struct, matrix_struct); }
--- a/libinterp/operators/op-ui16-ui16.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-ui16-ui16.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (uint16, uint64) void -install_ui16_ui16_ops (void) +install_ui16_ui16_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (uint16);
--- a/libinterp/operators/op-ui32-ui32.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-ui32-ui32.cc Fri Jan 05 18:44:53 2018 -0500 @@ -119,7 +119,7 @@ OCTAVE_MIXED_INT_CMP_OPS (uint32, int64) OCTAVE_MIXED_INT_CMP_OPS (uint32, uint64) void -install_ui32_ui32_ops (void) +install_ui32_ui32_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (uint32);
--- a/libinterp/operators/op-ui64-ui64.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-ui64-ui64.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (uint64, int64) void -install_ui64_ui64_ops (void) +install_ui64_ui64_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (uint64);
--- a/libinterp/operators/op-ui8-ui8.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/op-ui8-ui8.cc Fri Jan 05 18:44:53 2018 -0500 @@ -120,7 +120,7 @@ OCTAVE_MIXED_INT_CMP_OPS (uint8, uint64) void -install_ui8_ui8_ops (void) +install_ui8_ui8_ops (octave::type_info& ti) { OCTAVE_INSTALL_INT_OPS (uint8)
--- a/libinterp/operators/ops.h Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/operators/ops.h Fri Jan 05 18:44:53 2018 -0500 @@ -28,6 +28,11 @@ #include "Array-util.h" +namespace octave +{ + class type_info; +} + // Concatenation macros that enforce argument prescan #define CONCAT2X(x, y) x ## y #define CONCAT2(x, y) CONCAT2X (x, y) @@ -35,7 +40,43 @@ #define CONCAT3X(x, y, z) x ## y ## z #define CONCAT3(x, y, z) CONCAT3X (x, y, z) -extern void install_ops (void); +extern void install_ops (octave::type_info&); + +#define INSTALL_UNOP_TI(ti, op, t, f) \ + ti.install_unary_op \ + (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f)); + +#define INSTALL_NCUNOP_TI(ti, op, t, f) \ + ti.install_non_const_unary_op \ + (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f)); + +#define INSTALL_BINOP_TI(ti, op, t1, t2, f) \ + ti.install_binary_op \ + (octave_value::op, t1::static_type_id (), t2::static_type_id (), \ + CONCAT2 (oct_binop_, f)); + +#define INSTALL_CATOP_TI(ti, t1, t2, f) \ + ti.install_cat_op \ + (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_catop_, f)); + +#define INSTALL_ASSIGNOP_TI(ti, op, t1, t2, f) \ + ti.install_assign_op \ + (octave_value::op, t1::static_type_id (), t2::static_type_id (), \ + CONCAT2 (oct_assignop_, f)); + +#define INSTALL_ASSIGNANYOP_TI(ti, op, t1, f) \ + ti.install_assignany_op \ + (octave_value::op, t1::static_type_id (), CONCAT2 (oct_assignop_, f)); + +#define INSTALL_ASSIGNCONV_TI(ti, t1, t2, tr) \ + ti.install_pref_assign_conv \ + (t1::static_type_id (), t2::static_type_id (), tr::static_type_id ()); + +#define INSTALL_WIDENOP_TI(ti, t1, t2, f) \ + ti.install_widening_op \ + (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f)); + +// The following INSTALL_* macros are obsolete. #define INSTALL_UNOP(op, t, f) \ octave_value_typeinfo::register_unary_op \
--- a/libinterp/parse-tree/pt-eval.cc Sat Jan 06 14:57:23 2018 -0500 +++ b/libinterp/parse-tree/pt-eval.cc Fri Jan 05 18:44:53 2018 -0500 @@ -1660,7 +1660,7 @@ // // We might also start with a empty octave_value using // - // ctmp = octave_value_typeinfo::lookup_type + // ctmp = octave::type_info::lookup_type // (tmp.begin() -> begin() -> type_name()); // // and then directly resize. However, for some types there