# HG changeset patch
# User John W. Eaton <jwe@octave.org>
# Date 1461791820 14400
# Node ID 0822917dfcf52b43cc1f53d744d4e5ab841ab894
# Parent  1eabc3e24a532f5d5e03e4a46c8eefe92a483512
* ops.h, op-int.h: Style fixes.

diff -r 1eabc3e24a53 -r 0822917dfcf5 libinterp/operators/op-int.h
--- a/libinterp/operators/op-int.h	Wed Apr 27 17:02:06 2016 -0400
+++ b/libinterp/operators/op-int.h	Wed Apr 27 17:17:00 2016 -0400
@@ -30,7 +30,8 @@
 
 #define DEFINTBINOP_OP(name, t1, t2, op, t3) \
   static octave_value \
-  CONCAT2(oct_binop_, name) (const octave_base_value& a1, const octave_base_value& a2) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
     const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
     const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
@@ -41,7 +42,8 @@
 
 #define DEFINTNDBINOP_OP(name, t1, t2, e1, e2, op, t3) \
   static octave_value \
-  CONCAT2(oct_binop_, name) (const octave_base_value& a1, const octave_base_value& a2) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
     const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
     const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
@@ -52,7 +54,8 @@
 
 #define DEFINTBINOP_FN(name, t1, t2, f, t3, op) \
   static octave_value \
-  CONCAT2(oct_binop_, name) (const octave_base_value& a1, const octave_base_value& a2) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
     const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
     const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
@@ -60,9 +63,10 @@
     return retval; \
   }
 
-#define DEFINTNDBINOP_FN(name, t1, t2, e1, e2, f, t3, op)       \
+#define DEFINTNDBINOP_FN(name, t1, t2, e1, e2, f, t3, op) \
   static octave_value \
-  CONCAT2(oct_binop_, name) (const octave_base_value& a1, const octave_base_value& a2) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
     const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
     const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
@@ -183,7 +187,7 @@
   DEFNCUNOP_METHOD (s_decr, TYPE ## _scalar, decrement)
 
 // scalar by scalar ops.
-#define OCTAVE_SS_INT_ARITH_OPS(PFX, T1, T2, T3)        \
+#define OCTAVE_SS_INT_ARITH_OPS(PFX, T1, T2, T3) \
  \
   DEFINTBINOP_OP (PFX ## _add, T1 ## scalar, T2 ## scalar, +, T3) \
   DEFINTBINOP_OP (PFX ## _sub, T1 ## scalar, T2 ## scalar, -, T3) \
@@ -215,7 +219,7 @@
     return retval; \
   } \
  \
-  DEFINTBINOP_OP (PFX ## _el_mul, T1 ## scalar, T2 ## scalar, *, T3)    \
+  DEFINTBINOP_OP (PFX ## _el_mul, T1 ## scalar, T2 ## scalar, *, T3) \
  \
   DEFBINOP (PFX ## _el_div, T1 ## scalar, T2 ## scalar) \
   { \
@@ -531,7 +535,7 @@
   { \
     const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \
     const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \
-    \
+ \
     octave_value retval = v2.TS ## scalar_value () / v1.TM ## array_value (); \
     return retval; \
   }
@@ -566,7 +570,7 @@
   for (int i = 0; i < a.numel (); i++) \
     { \
       OCTAVE_QUIT; \
-      result (i) = pow (a(i), b);               \
+      result (i) = pow (a(i), b); \
     } \
   return octave_value (result); \
 } \
@@ -577,7 +581,7 @@
   for (int i = 0; i < a.numel (); i++) \
     { \
       OCTAVE_QUIT; \
-      result (i) = pow (a(i), b);               \
+      result (i) = pow (a(i), b); \
     } \
   return octave_value (result); \
 } \
@@ -588,7 +592,7 @@
   for (int i = 0; i < a.numel (); i++) \
     { \
       OCTAVE_QUIT; \
-      result (i) = pow (a(i), b);               \
+      result (i) = pow (a(i), b); \
     } \
   return octave_value (result); \
 } \
@@ -599,7 +603,7 @@
   for (int i = 0; i < a.numel (); i++) \
     { \
       OCTAVE_QUIT; \
-      result (i) = powf (a(i), b);              \
+      result (i) = powf (a(i), b); \
     } \
   return octave_value (result); \
 } \
@@ -610,7 +614,7 @@
   for (int i = 0; i < a.numel (); i++) \
     { \
       OCTAVE_QUIT; \
-      result (i) = powf (a(i), b);              \
+      result (i) = powf (a(i), b); \
     } \
   return octave_value (result); \
 }
@@ -665,7 +669,7 @@
   DEFNCUNOP_METHOD (m_changesign, TYPE ## _matrix, changesign)
 
 // matrix by matrix ops.
-#define OCTAVE_MM_INT_ARITH_OPS(PFX, T1, T2, T3)        \
+#define OCTAVE_MM_INT_ARITH_OPS(PFX, T1, T2, T3) \
  \
   DEFINTNDBINOP_OP (PFX ## _add, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, +, T3) \
   DEFINTNDBINOP_OP (PFX ## _sub, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, -, T3) \
@@ -690,7 +694,7 @@
   { \
     const octave_ ## T1 ## matrix& v1 = dynamic_cast<const octave_ ## T1 ## matrix&> (a1); \
     const octave_ ## T2 ## matrix& v2 = dynamic_cast<const octave_ ## T2 ## matrix&> (a2); \
-    \
+ \
     octave_value retval = octave_value (quotient (v2.T2 ## array_value (), v1.T1 ## array_value ())); \
     return retval; \
   }
@@ -729,7 +733,7 @@
     if (a_dims != b_dims) \
       { \
         if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
-          err_nonconformant ("operator .^", a_dims, b_dims);  \
+          err_nonconformant ("operator .^", a_dims, b_dims); \
  \
         return bsxfun_pow (a, b); \
       } \
@@ -750,7 +754,7 @@
     if (a_dims != b_dims) \
       { \
         if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
-          err_nonconformant ("operator .^", a_dims, b_dims);  \
+          err_nonconformant ("operator .^", a_dims, b_dims); \
  \
         return bsxfun_pow (a, b); \
       } \
@@ -928,10 +932,10 @@
 #define OCTAVE_INSTALL_SS_INT_OPS(TYPE) \
   OCTAVE_INSTALL_S_INT_UNOPS (TYPE) \
   OCTAVE_INSTALL_SS_INT_ARITH_OPS (ss, TYPE ## _, TYPE ## _) \
-  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssx, TYPE ## _, )         \
-  OCTAVE_INSTALL_SS_INT_ARITH_OPS (sxs,  , TYPE ## _)        \
-  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssfx, TYPE ## _, float_)          \
-  OCTAVE_INSTALL_SS_INT_ARITH_OPS (sfxs,  float_, TYPE ## _)         \
+  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssx, TYPE ## _, ) \
+  OCTAVE_INSTALL_SS_INT_ARITH_OPS (sxs,  , TYPE ## _) \
+  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssfx, TYPE ## _, float_) \
+  OCTAVE_INSTALL_SS_INT_ARITH_OPS (sfxs,  float_, TYPE ## _) \
   OCTAVE_INSTALL_SS_INT_CMP_OPS (ss, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_SS_INT_CMP_OPS (sx, TYPE ## _, ) \
   OCTAVE_INSTALL_SS_INT_CMP_OPS (xs, , TYPE ## _) \
@@ -976,10 +980,10 @@
 
 #define OCTAVE_INSTALL_SM_INT_OPS(TYPE) \
   OCTAVE_INSTALL_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _) \
-  OCTAVE_INSTALL_SM_INT_ARITH_OPS (smx, TYPE ## _, )         \
-  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sxm, , TYPE ## _)         \
-  OCTAVE_INSTALL_SM_INT_ARITH_OPS (smfx, TYPE ## _, float_)          \
-  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sfxm, float_, TYPE ## _)          \
+  OCTAVE_INSTALL_SM_INT_ARITH_OPS (smx, TYPE ## _, ) \
+  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sxm, , TYPE ## _) \
+  OCTAVE_INSTALL_SM_INT_ARITH_OPS (smfx, TYPE ## _, float_) \
+  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sfxm, float_, TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_CMP_OPS (xm, , TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_CMP_OPS (smx, TYPE ## _, ) \
@@ -1038,9 +1042,9 @@
 #define OCTAVE_INSTALL_MS_INT_OPS(TYPE) \
   OCTAVE_INSTALL_MS_INT_ARITH_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_ARITH_OPS (msx, TYPE ## _, ) \
-  OCTAVE_INSTALL_MS_INT_ARITH_OPS (mxs, , TYPE ## _)       \
+  OCTAVE_INSTALL_MS_INT_ARITH_OPS (mxs, , TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_ARITH_OPS (msfx, TYPE ## _, float_) \
-  OCTAVE_INSTALL_MS_INT_ARITH_OPS (mfxs, float_, TYPE ## _)        \
+  OCTAVE_INSTALL_MS_INT_ARITH_OPS (mfxs, float_, TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_CMP_OPS (mx, TYPE ## _, ) \
   OCTAVE_INSTALL_MS_INT_CMP_OPS (mxs, , TYPE ## _) \
@@ -1069,7 +1073,7 @@
   INSTALL_NCUNOP (op_decr, octave_ ## TYPE ## _matrix, m_decr); \
   INSTALL_NCUNOP (op_uminus, octave_ ## TYPE ## _matrix, m_changesign);
 
-#define OCTAVE_INSTALL_MM_INT_ARITH_OPS(PFX, T1, T2)                    \
+#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); */ \
@@ -1110,9 +1114,9 @@
   OCTAVE_INSTALL_M_INT_UNOPS (TYPE) \
   OCTAVE_INSTALL_MM_INT_ARITH_OPS (mm, TYPE ##_, TYPE ## _) \
   OCTAVE_INSTALL_MM_INT_ARITH_OPS (mmx, TYPE ##_, ) \
-  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mxm, , TYPE ##_)        \
+  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mxm, , TYPE ##_) \
   OCTAVE_INSTALL_MM_INT_ARITH_OPS (mmfx, TYPE ##_, float_) \
-  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mfxm, float_, TYPE ##_)         \
+  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mfxm, float_, TYPE ##_) \
   OCTAVE_INSTALL_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \
   OCTAVE_INSTALL_MM_INT_CMP_OPS (mxm, , TYPE ## _) \
diff -r 1eabc3e24a53 -r 0822917dfcf5 libinterp/operators/ops.h
--- a/libinterp/operators/ops.h	Wed Apr 27 17:02:06 2016 -0400
+++ b/libinterp/operators/ops.h	Wed Apr 27 17:17:00 2016 -0400
@@ -29,39 +29,39 @@
 #include "Array-util.h"
 
 // Concatenation macros that enforce argument prescan
-#define CONCAT2X(x,y) x ## y
-#define CONCAT2(x,y) CONCAT2X(x,y)
+#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 CONCAT3X(x, y, z) x ## y ## z
+#define CONCAT3(x, y, z) CONCAT3X (x, y, z)
 
 extern void install_ops (void);
 
 #define INSTALL_UNOP(op, t, f) \
   octave_value_typeinfo::register_unary_op \
-    (octave_value::op, t::static_type_id (), CONCAT2(oct_unop_, f));
+    (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f));
 
 #define INSTALL_NCUNOP(op, t, f) \
   octave_value_typeinfo::register_non_const_unary_op \
-    (octave_value::op, t::static_type_id (), CONCAT2(oct_unop_, f));
+    (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f));
 
 #define INSTALL_BINOP(op, t1, t2, f) \
   octave_value_typeinfo::register_binary_op \
     (octave_value::op, t1::static_type_id (), t2::static_type_id (), \
-     CONCAT2(oct_binop_, f));
+     CONCAT2 (oct_binop_, f));
 
 #define INSTALL_CATOP(t1, t2, f) \
   octave_value_typeinfo::register_cat_op \
-    (t1::static_type_id (), t2::static_type_id (), CONCAT2(oct_catop_, f));
+    (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_catop_, f));
 
 #define INSTALL_ASSIGNOP(op, t1, t2, f) \
   octave_value_typeinfo::register_assign_op \
     (octave_value::op, t1::static_type_id (), t2::static_type_id (), \
-     CONCAT2(oct_assignop_, f));
+     CONCAT2 (oct_assignop_, f));
 
 #define INSTALL_ASSIGNANYOP(op, t1, f) \
   octave_value_typeinfo::register_assignany_op \
-    (octave_value::op, t1::static_type_id (), CONCAT2(oct_assignop_, f));
+    (octave_value::op, t1::static_type_id (), CONCAT2 (oct_assignop_, f));
 
 #define INSTALL_ASSIGNCONV(t1, t2, tr) \
   octave_value_typeinfo::register_pref_assign_conv \
@@ -69,38 +69,38 @@
 
 #define INSTALL_CONVOP(t1, t2, f) \
   octave_value_typeinfo::register_type_conv_op \
-    (t1::static_type_id (), t2::static_type_id (), CONCAT2(oct_conv_, f));
+    (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f));
 
 #define INSTALL_WIDENOP(t1, t2, f) \
   octave_value_typeinfo::register_widening_op \
-    (t1::static_type_id (), t2::static_type_id (), CONCAT2(oct_conv_, f));
+    (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)
+  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) \
+  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
+                                 const octave_value_list& idx, \
+                                 const octave_base_value& a2) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
  \
-    v1.f (idx, v2.CONCAT2(t1, _value) ()); \
+    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 (oct_assignop_, name) (octave_base_value& a, \
+                                 const octave_value_list& idx, \
+                                 const octave_base_value&) \
   { \
-    CONCAT2(octave_, t)& v = dynamic_cast<CONCAT2(octave_, t)&> (a); \
+    CONCAT2 (octave_, t)& v = dynamic_cast<CONCAT2 (octave_, t)&> (a); \
  \
     v.f (idx); \
     return octave_value (); \
@@ -108,55 +108,55 @@
 
 #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) \
+  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
+                                 const octave_value_list& idx, \
+                                 const octave_base_value& a2) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
  \
-    v1.f (idx, v2.CONCAT2(e, _value) ()); \
+    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) \
+  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
+                                 const octave_value_list& idx, \
+                                 const octave_base_value& a2) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
  \
     assert (idx.empty ()); \
-    v1.matrix_ref () op v2.CONCAT2(f, _value) (); \
+    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) \
+  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
+                                 const octave_value_list& idx, \
+                                 const octave_base_value& a2) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
  \
     assert (idx.empty ()); \
-    fnop (v1.matrix_ref (), v2.CONCAT2(f, _value) ()); \
+    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) \
+  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
+                                 const octave_value_list& idx, \
+                                 const octave_value& a2) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
  \
     v1.f (idx, a2); \
     return octave_value (); \
@@ -164,11 +164,11 @@
 
 #define CONVDECL(name) \
   static octave_base_value * \
-  CONCAT2(oct_conv_, name) (const octave_base_value& a)
+  CONCAT2 (oct_conv_, name) (const octave_base_value& a)
 
 #define CONVDECLX(name) \
   static octave_base_value * \
-  CONCAT2(oct_conv_, name) (const octave_base_value&)
+  CONCAT2 (oct_conv_, name) (const octave_base_value&)
 
 #define DEFCONV(name, a_dummy, b_dummy) \
   CONVDECL (name)
@@ -176,37 +176,37 @@
 #define DEFCONVFNX(name, tfrom, ovtto, tto, e) \
   CONVDECL (name) \
   { \
-    const CONCAT2(octave_, tfrom)& v = dynamic_cast<const CONCAT2(octave_, tfrom)&> (a); \
+    const CONCAT2 (octave_, tfrom)& v = dynamic_cast<const CONCAT2 (octave_, tfrom)&> (a); \
  \
-    return new CONCAT2(octave_, ovtto) (CONCAT2(tto, NDArray) (v.CONCAT2(e, array_value) ())); \
+    return new CONCAT2 (octave_, ovtto) (CONCAT2 (tto, NDArray) (v.CONCAT2 (e, array_value) ())); \
   }
 
 #define DEFCONVFNX2(name, tfrom, ovtto, e) \
   CONVDECL (name) \
   { \
-    const CONCAT2(octave_, tfrom)& v = dynamic_cast<const CONCAT2(octave_, tfrom)&> (a); \
+    const CONCAT2 (octave_, tfrom)& v = dynamic_cast<const CONCAT2 (octave_, tfrom)&> (a); \
  \
-    return new CONCAT2(octave_, ovtto) (v.CONCAT2(e, array_value) ()); \
+    return new CONCAT2 (octave_, ovtto) (v.CONCAT2 (e, array_value) ()); \
   }
 
 #define DEFDBLCONVFN(name, ovtfrom, e) \
   CONVDECL (name) \
   { \
-    const CONCAT2(octave_, ovtfrom)& v = dynamic_cast<const CONCAT2(octave_, ovtfrom)&> (a); \
+    const CONCAT2 (octave_, ovtfrom)& v = dynamic_cast<const CONCAT2 (octave_, ovtfrom)&> (a); \
  \
-    return new octave_matrix (NDArray (v.CONCAT2(e, _value) ())); \
+    return new octave_matrix (NDArray (v.CONCAT2 (e, _value) ())); \
   }
 
 #define DEFFLTCONVFN(name, ovtfrom, e) \
   CONVDECL (name) \
   { \
-    const CONCAT2(octave_, ovtfrom)& v = dynamic_cast<const CONCAT2(octave_, ovtfrom)&> (a); \
+    const CONCAT2 (octave_, ovtfrom)& v = dynamic_cast<const CONCAT2 (octave_, ovtfrom)&> (a); \
  \
-    return new octave_float_matrix (FloatNDArray (v.CONCAT2(e, _value) ())); \
+    return new octave_float_matrix (FloatNDArray (v.CONCAT2 (e, _value) ())); \
   }
 
 #define DEFSTRINTCONVFN(name, tto) \
-  DEFCONVFNX(name, char_matrix_str, CONCAT2(tto, _matrix), tto, char_)
+  DEFCONVFNX(name, char_matrix_str, CONCAT2 (tto, _matrix), tto, char_)
 
 #define DEFSTRDBLCONVFN(name, tfrom) \
   DEFCONVFNX(name, tfrom, matrix, , char_)
@@ -215,181 +215,204 @@
   DEFCONVFNX(name, tfrom, float_matrix, Float, char_)
 
 #define DEFCONVFN(name, tfrom, tto) \
-  DEFCONVFNX2 (name, tfrom, CONCAT2(tto, _matrix), CONCAT2(tto, _))
+  DEFCONVFNX2 (name, tfrom, CONCAT2 (tto, _matrix), CONCAT2 (tto, _))
 
 #define DEFCONVFN2(name, tfrom, sm, tto) \
-  DEFCONVFNX2 (name, CONCAT3(tfrom, _, sm), CONCAT2(tto, _matrix), CONCAT2(tto, _))
+  DEFCONVFNX2 (name, CONCAT3 (tfrom, _, sm), CONCAT2 (tto, _matrix), CONCAT2 (tto, _))
 
 #define DEFUNOPX(name, t) \
   static octave_value \
-  CONCAT2(oct_unop_, name) (const octave_base_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)
+  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) \
+  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
   { \
-    const CONCAT2(octave_, t)& v = dynamic_cast<const CONCAT2(octave_, t)&> (a); \
-    return octave_value (op v.CONCAT2(t, _value) ()); \
+    const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (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) \
+  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
   { \
-    const CONCAT2(octave_, t)& v = dynamic_cast<const CONCAT2(octave_, t)&> (a); \
-    return octave_value (op v.CONCAT2(e, _value) ()); \
+    const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (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) \
+  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
   { \
-    const CONCAT2(octave_, t)& v = dynamic_cast<const CONCAT2(octave_, t)&> (a); \
-    return octave_value (f (v.CONCAT2(t, _value) ())); \
+    const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (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) \
+  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
   { \
-    const CONCAT2(octave_, t)& v = dynamic_cast<const CONCAT2(octave_, t)&> (a); \
-    return octave_value (f (v.CONCAT2(e, _value) ())); \
+    const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (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 (oct_unop_, name) (octave_base_value& a) \
   { \
-    CONCAT2(octave_, t)& v = dynamic_cast<CONCAT2(octave_, t)&> (a); \
+    CONCAT2 (octave_, t)& v = dynamic_cast<CONCAT2 (octave_, t)&> (a); \
     v.method (); \
   }
 
 #define DEFBINOPX(name, t1, t2) \
   static octave_value \
-  CONCAT2(oct_binop_, name) (const octave_base_value&, const octave_base_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)
+  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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
+ \
     return octave_value \
-      (v1.CONCAT2(t1, _value) () op v2.CONCAT2(t2, _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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
+ \
     warn_complex_cmp (); \
+ \
     return octave_value \
-      (v1.CONCAT2(t1, _value) () op v2.CONCAT2(t2, _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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    if (xisnan (v1.CONCAT2(t1, _value) ()) || xisnan (v2.CONCAT2(t2, _value) ())) \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
+ \
+    if (xisnan (v1.CONCAT2 (t1, _value) ()) || xisnan (v2.CONCAT2 (t2, _value) ())) \
       err_nan_to_logical_conversion (); \
  \
     return octave_value \
-      (v1.CONCAT2(t1, _value) () op v2.CONCAT2(t2, _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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
+ \
     return octave_value \
-      (v1.CONCAT2(e1, _value) () op v2.CONCAT2(e2, _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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    return octave_value (f (v1.CONCAT2(t1, _value) (), v2.CONCAT2(t2, _value) ())); \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    return octave_value (f (v1.CONCAT2(e1, _value) (), v2.CONCAT2(e2, _value) ())); \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (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) \
+  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
+                              const octave_base_value& a2) \
   { \
-    const CONCAT2(octave_, t1)& v1 = dynamic_cast<const CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    return octave_value (f (v1.CONCAT2(e1, _value) (), v2.CONCAT2(e2, _value) ())); \
+    const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (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) (octave_base_value&, const octave_base_value&, \
-                             const Array<octave_idx_type>& ra_idx)
+  CONCAT2 (oct_catop_, name) (octave_base_value&, const octave_base_value&, \
+                              const Array<octave_idx_type>& ra_idx)
 
-#define DEFCATOP(name, t1, t2)  \
+#define DEFCATOP(name, t1, t2) \
   static octave_value \
-  CONCAT2(oct_catop_, name) (octave_base_value& a1, const octave_base_value& a2, \
-                             const Array<octave_idx_type>& ra_idx)
+  CONCAT2 (oct_catop_, name) (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) (octave_base_value& a1, const octave_base_value& a2, \
-                             const Array<octave_idx_type>& ra_idx) \
+  CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
+                              const octave_base_value& a2, \
+                              const Array<octave_idx_type>& ra_idx) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    return octave_value (v1.CONCAT2(t1, _value) () . f (v2.CONCAT2(t2, _value) (), ra_idx)); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (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) (octave_base_value& a1, const octave_base_value& a2, \
-                             const Array<octave_idx_type>& ra_idx) \
+  CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
+                              const octave_base_value& a2, \
+                              const Array<octave_idx_type>& ra_idx) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    return octave_value (v1.CONCAT2(e1, _value) () . f (v2.CONCAT2(e2, _value) (), ra_idx)); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (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) (octave_base_value& a1, const octave_base_value& a2, \
-                             const Array<octave_idx_type>& ra_idx) \
+  CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
+                              const octave_base_value& a2, \
+                              const Array<octave_idx_type>& ra_idx) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
  \
     return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \
                          ((a1.is_sq_string () || a2.is_sq_string ()) \
@@ -401,12 +424,14 @@
 
 #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \
   static octave_value \
-  CONCAT2(oct_catop_, name) (octave_base_value& a1, const octave_base_value& a2, \
-                             const Array<octave_idx_type>& ra_idx) \
+  CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
+                              const octave_base_value& a2, \
+                              const Array<octave_idx_type>& ra_idx) \
   { \
-    CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \
-    const CONCAT2(octave_, t2)& v2 = dynamic_cast<const CONCAT2(octave_, t2)&> (a2); \
-    return octave_value (tc1 (v1.CONCAT2(e1, _value) ()) . f (tc2 (v2.CONCAT2(e2, _value) ()), ra_idx)); \
+    CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
+    const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
+ \
+    return octave_value (tc1 (v1.CONCAT2 (e1, _value) ()) . f (tc2 (v2.CONCAT2 (e2, _value) ()), ra_idx)); \
   }
 
 #endif