diff 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 diff
--- a/libinterp/operators/ops.h	Tue Feb 28 11:43:18 2023 -0500
+++ b/libinterp/operators/ops.h	Tue Feb 28 15:45:03 2023 -0500
@@ -37,15 +37,21 @@
 
 OCTAVE_END_NAMESPACE(octave)
 
-// Use the static_cast rather than dynamic_cast when
-// internal checks are not enabled to speed up execution,
-// avoiding RTTI calls.
-#ifdef OCTAVE_ENABLE_INTERNAL_CHECKS
-#  define DYNORSTAT_CAST dynamic_cast
+// 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 DYNORSTAT_CAST static_cast
+#  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)
@@ -99,23 +105,23 @@
                                  const octave_value_list& idx,          \
                                  const octave_base_value& a2)           \
   {                                                                     \
-    CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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&)              \
-  {                                                                     \
-    CONCAT2 (octave_, t)& v = DYNORSTAT_CAST<CONCAT2 (octave_, t)&> (a);  \
-                                                                        \
-    v.f (idx);                                                          \
-    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)                            \
@@ -124,8 +130,8 @@
                                  const octave_value_list& idx,          \
                                  const octave_base_value& a2)           \
   {                                                                     \
-    CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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 ();                                             \
@@ -138,8 +144,8 @@
                                  const octave_value_list& idx,          \
                                  const octave_base_value& a2)           \
   {                                                                     \
-    CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ();                      \
@@ -153,8 +159,8 @@
                                  const octave_value_list& idx,          \
                                  const octave_base_value& a2)           \
   {                                                                     \
-    CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ());                 \
@@ -162,16 +168,16 @@
     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)                \
-  {                                                                     \
-    CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<CONCAT2 (octave_, t1)&> (a1); \
-                                                                        \
-    v1.f (idx, a2);                                                     \
-    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)                                          \
@@ -189,46 +195,46 @@
   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)                \
-  {                                                                     \
-    const CONCAT2 (octave_, t)& v = DYNORSTAT_CAST<const CONCAT2 (octave_, t)&> (a); \
-    return octave_value (op v.CONCAT2 (t, _value) ());                  \
+#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)                \
-  {                                                                     \
-    const CONCAT2 (octave_, t)& v = DYNORSTAT_CAST<const CONCAT2 (octave_, t)&> (a); \
-    return octave_value (op v.CONCAT2 (e, _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)                \
-  {                                                                     \
-    const CONCAT2 (octave_, t)& v = DYNORSTAT_CAST<const CONCAT2 (octave_, t)&> (a); \
-    return octave_value (f (v.CONCAT2 (t, _value) ()));                 \
+#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)                \
-  {                                                                     \
-    const CONCAT2 (octave_, t)& v = DYNORSTAT_CAST<const CONCAT2 (octave_, t)&> (a); \
-    return octave_value (f (v.CONCAT2 (e, _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)                      \
-  {                                                                     \
-    CONCAT2 (octave_, t)& v = DYNORSTAT_CAST<CONCAT2 (octave_, t)&> (a);  \
-    v.method ();                                                        \
+#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)                         \
@@ -246,8 +252,8 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ());       \
@@ -258,8 +264,8 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (a2); \
+    OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1);      \
+    OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2);      \
                                                                         \
     warn_complex_cmp ();                                                \
                                                                         \
@@ -272,11 +278,11 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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 ();                                 \
+      octave::err_nan_to_logical_conversion ();                         \
                                                                         \
     return octave_value                                                 \
       (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ());       \
@@ -287,8 +293,8 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ());       \
@@ -301,8 +307,8 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ())); \
   }
@@ -312,8 +318,8 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ())); \
   }
@@ -323,8 +329,8 @@
   CONCAT2 (oct_binop_, name) (const octave_base_value& a1,              \
                               const octave_base_value& a2)              \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) ())); \
   }
@@ -349,8 +355,8 @@
                               const octave_base_value& a2,              \
                               const Array<octave_idx_type>& ra_idx)     \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) () . f (v2.CONCAT2 (t2, _value) (), ra_idx)); \
   }
@@ -361,8 +367,8 @@
                               const octave_base_value& a2,              \
                               const Array<octave_idx_type>& ra_idx)     \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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) () . f (v2.CONCAT2 (e2, _value) (), ra_idx)); \
   }
@@ -373,8 +379,8 @@
                               const octave_base_value& a2,              \
                               const Array<octave_idx_type>& ra_idx)     \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (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.char_array_value () . f (v2.char_array_value (), ra_idx), \
                          ((a1.is_sq_string () || a2.is_sq_string ())    \
@@ -390,8 +396,8 @@
                               const octave_base_value& a2,              \
                               const Array<octave_idx_type>& ra_idx)     \
   {                                                                     \
-    const CONCAT2 (octave_, t1)& v1 = DYNORSTAT_CAST<const CONCAT2 (octave_, t1)&> (a1); \
-    const CONCAT2 (octave_, t2)& v2 = DYNORSTAT_CAST<const CONCAT2 (octave_, t2)&> (a2); \
+    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)); \
   }