Mercurial > octave
view libinterp/operators/ops.h @ 31867:a9c8b1f8fb32
use macro to simplify octave_base_value casts in operator functions
* ops.h (OCTAVE_DYNAMIC_CAST): Rename from DYNORSTAT_CAST.
(OCTAVE_CAST_BASE_VALUE): New macro.
* 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-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-mi.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, ops.h:
Replace lines like "T& v = DYNORSTAT_CAST<T&> (a)" with
"OCTAVE_CAST_BASE_VALUE (T&, v, a)".
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Tue, 28 Feb 2023 15:45:03 -0500 |
| parents | 3722c5b1a8c8 |
| children | 2e484f9f1f18 |
line wrap: on
line source
//////////////////////////////////////////////////////////////////////// // // Copyright (C) 1996-2023 The Octave Project Developers // // See the file COPYRIGHT.md in the top-level directory of this // distribution or <https://octave.org/copyright/>. // // This file is part of Octave. // // Octave is free software: you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // Octave is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with Octave; see the file COPYING. If not, see // <https://www.gnu.org/licenses/>. // //////////////////////////////////////////////////////////////////////// #if ! defined (octave_ops_h) #define octave_ops_h 1 #include "octave-config.h" #include "Array-util.h" #include "error.h" OCTAVE_BEGIN_NAMESPACE(octave) class type_info; OCTAVE_END_NAMESPACE(octave) // NOTE: If OCTAVE_ENABLE_INTERNAL_CHECKS is defined, then // OCTAVE_DYNAMIC_CAST is only safe if you can ensure that the cast will // succeed. Using static_cast disables the RTTI checks used by // dynamic_cast that ensure an unsuccesful cast will either throw an // error for reference types or or return nullptr for pointer types. #if defined (OCTAVE_ENABLE_INTERNAL_CHECKS) # define OCTAVE_DYNAMIC_CAST dynamic_cast #else # define OCTAVE_DYNAMIC_CAST static_cast #endif #define OCTAVE_CAST_BASE_VALUE(T, T_VAL, BASE_VAL) \ T T_VAL = OCTAVE_DYNAMIC_CAST<T> (BASE_VAL) // Concatenation macros that enforce argument prescan #define CONCAT2X(x, y) x ## y #define CONCAT2(x, y) CONCAT2X (x, y) #define CONCAT3X(x, y, z) x ## y ## z #define CONCAT3(x, y, z) CONCAT3X (x, y, z) #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)); #define DEFASSIGNOP(name, t1, t2) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ const octave_value_list& idx, \ const octave_base_value& a2) #define DEFASSIGNOP_FN(name, t1, t2, f) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ const octave_value_list& idx, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ v1.f (idx, v2.CONCAT2 (t1, _value) ()); \ return octave_value (); \ } #define DEFNULLASSIGNOP_FN(name, t, f) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a, \ const octave_value_list& idx, \ const octave_base_value&) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t)&, v, a); \ \ v.f (idx); \ return octave_value (); \ } #define DEFNDASSIGNOP_FN(name, t1, t2, e, f) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ const octave_value_list& idx, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ v1.f (idx, v2.CONCAT2 (e, _value) ()); \ return octave_value (); \ } // FIXME: the following currently don't handle index. #define DEFNDASSIGNOP_OP(name, t1, t2, f, op) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ const octave_value_list& idx, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ error_unless (idx.empty ()); \ v1.matrix_ref () op v2.CONCAT2 (f, _value) (); \ \ return octave_value (); \ } #define DEFNDASSIGNOP_FNOP(name, t1, t2, f, fnop) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ const octave_value_list& idx, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ error_unless (idx.empty ()); \ fnop (v1.matrix_ref (), v2.CONCAT2 (f, _value) ()); \ \ return octave_value (); \ } #define DEFASSIGNANYOP_FN(name, t1, f) \ static octave_value \ CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ const octave_value_list& idx, \ const octave_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \ \ v1.f (idx, a2); \ return octave_value (); \ } #define CONVDECL(name) \ static octave_base_value * \ CONCAT2 (oct_conv_, name) (const octave_base_value& a) #define DEFCONV(name, a_dummy, b_dummy) \ CONVDECL (name) #define DEFUNOPX(name, t) \ static octave_value \ CONCAT2 (oct_unop_, name) (const octave_base_value&) #define DEFUNOP(name, t) \ static octave_value \ CONCAT2 (oct_unop_, name) (const octave_base_value& a) #define DEFUNOP_OP(name, t, op) \ static octave_value \ CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \ return octave_value (op v.CONCAT2 (t, _value) ()); \ } #define DEFNDUNOP_OP(name, t, e, op) \ static octave_value \ CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \ return octave_value (op v.CONCAT2 (e, _value) ()); \ } // FIXME: in some cases, the constructor isn't necessary. #define DEFUNOP_FN(name, t, f) \ static octave_value \ CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \ return octave_value (f (v.CONCAT2 (t, _value) ())); \ } #define DEFNDUNOP_FN(name, t, e, f) \ static octave_value \ CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \ return octave_value (f (v.CONCAT2 (e, _value) ())); \ } #define DEFNCUNOP_METHOD(name, t, method) \ static void \ CONCAT2 (oct_unop_, name) (octave_base_value& a) \ { \ OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t)&, v, a); \ v.method (); \ } #define DEFBINOPX(name, t1, t2) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value&, \ const octave_base_value&) #define DEFBINOP(name, t1, t2) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) #define DEFBINOP_OP(name, t1, t2, op) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value \ (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \ } #define DEFCMPLXCMPOP_OP(name, t1, t2, op) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ warn_complex_cmp (); \ \ return octave_value \ (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \ } #define DEFSCALARBOOLOP_OP(name, t1, t2, op) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ if (octave::math::isnan (v1.CONCAT2 (t1, _value) ()) || octave::math::isnan (v2.CONCAT2 (t2, _value) ())) \ octave::err_nan_to_logical_conversion (); \ \ return octave_value \ (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \ } #define DEFNDBINOP_OP(name, t1, t2, e1, e2, op) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value \ (v1.CONCAT2 (e1, _value) () op v2.CONCAT2 (e2, _value) ()); \ } // FIXME: in some cases, the constructor isn't necessary. #define DEFBINOP_FN(name, t1, t2, f) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (f (v1.CONCAT2 (t1, _value) (), v2.CONCAT2 (t2, _value) ())); \ } #define DEFNDBINOP_FN(name, t1, t2, e1, e2, f) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \ } #define DEFNDCMPLXCMPOP_FN(name, t1, t2, e1, e2, f) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \ } #define DEFCATOPX(name, t1, t2) \ static octave_value \ CONCAT2 (oct_catop_, name) (const octave_base_value&, \ const octave_base_value&, \ const Array<octave_idx_type>& ra_idx) #define DEFCATOP(name, t1, t2) \ static octave_value \ CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \ const octave_base_value& a2, \ const Array<octave_idx_type>& ra_idx) // FIXME: in some cases, the constructor isn't necessary. #define DEFCATOP_FN(name, t1, t2, f) \ static octave_value \ CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \ const octave_base_value& a2, \ const Array<octave_idx_type>& ra_idx) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (v1.CONCAT2 (t1, _value) () . f (v2.CONCAT2 (t2, _value) (), ra_idx)); \ } #define DEFNDCATOP_FN(name, t1, t2, e1, e2, f) \ static octave_value \ CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \ const octave_base_value& a2, \ const Array<octave_idx_type>& ra_idx) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (v1.CONCAT2 (e1, _value) () . f (v2.CONCAT2 (e2, _value) (), ra_idx)); \ } #define DEFNDCHARCATOP_FN(name, t1, t2, f) \ static octave_value \ CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \ const octave_base_value& a2, \ const Array<octave_idx_type>& ra_idx) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \ ((a1.is_sq_string () || a2.is_sq_string ()) \ ? '\'' : '"')); \ } // For compatibility, the second arg is always converted to the type // of the first. Hmm. #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \ static octave_value \ CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \ const octave_base_value& a2, \ const Array<octave_idx_type>& ra_idx) \ { \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \ OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \ \ return octave_value (tc1 (v1.CONCAT2 (e1, _value) ()) . f (tc2 (v2.CONCAT2 (e2, _value) ()), ra_idx)); \ } #endif