--- a/libinterp/octave-value/ov-typeinfo.cc	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/octave-value/ov-typeinfo.cc	Thu Dec 01 18:02:15 2022 -0800
@@ -40,853 +40,854 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  extern void install_ops (type_info& ti);
+extern void install_ops (type_info& ti);
 
-  // FIXME: we should also store all class names and provide a
-  // way to list them (calling class with nargin == 0?).
+// FIXME: we should also store all class names and provide a
+// way to list them (calling class with nargin == 0?).
 
-  static NDArray as_nd_array (const Array<int>& x)
-  {
-    NDArray retval (x.dims ());
+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);
+  for (int i = 0; i < x.numel (); i++)
+    retval.xelem(i) = x(i);
+
+  return retval;
+}
 
-    return retval;
-  }
+static boolNDArray as_bool_nd_array (const Array<void *>& x)
+{
+  boolNDArray retval (x.dims ());
 
-  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);
 
-    for (octave_idx_type i = 0; i < x.numel (); i++)
-      retval.xelem (i) = x(i);
-
-    return retval;
-  }
+  return retval;
+}
 
-  type_info::type_info (int init_tab_sz)
-    : m_num_types (0), m_types (dim_vector (init_tab_sz, 1), ""),
-      m_vals (dim_vector (init_tab_sz, 1)),
-      m_unary_class_ops (dim_vector (octave_value::num_unary_ops, 1), nullptr),
-      m_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr),
-      m_non_const_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr),
-      m_binary_class_ops (dim_vector (octave_value::num_binary_ops, 1), nullptr),
-      m_binary_ops (dim_vector (octave_value::num_binary_ops, init_tab_sz, init_tab_sz), nullptr),
-      m_compound_binary_class_ops (dim_vector (octave_value::num_compound_binary_ops, 1), nullptr),
-      m_compound_binary_ops (dim_vector (octave_value::num_compound_binary_ops, init_tab_sz, init_tab_sz), nullptr),
-      m_cat_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr),
-      m_assign_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz, init_tab_sz), nullptr),
-      m_assignany_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz), nullptr),
-      m_pref_assign_conv (dim_vector (init_tab_sz, init_tab_sz), -1),
-      m_widening_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr)
-  {
-    install_types (*this);
+type_info::type_info (int init_tab_sz)
+  : m_num_types (0), m_types (dim_vector (init_tab_sz, 1), ""),
+    m_vals (dim_vector (init_tab_sz, 1)),
+    m_unary_class_ops (dim_vector (octave_value::num_unary_ops, 1), nullptr),
+    m_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr),
+    m_non_const_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr),
+    m_binary_class_ops (dim_vector (octave_value::num_binary_ops, 1), nullptr),
+    m_binary_ops (dim_vector (octave_value::num_binary_ops, init_tab_sz, init_tab_sz), nullptr),
+    m_compound_binary_class_ops (dim_vector (octave_value::num_compound_binary_ops, 1), nullptr),
+    m_compound_binary_ops (dim_vector (octave_value::num_compound_binary_ops, init_tab_sz, init_tab_sz),
+                           nullptr),
+    m_cat_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr),
+    m_assign_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz, init_tab_sz), nullptr),
+    m_assignany_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz), nullptr),
+    m_pref_assign_conv (dim_vector (init_tab_sz, init_tab_sz), -1),
+    m_widening_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr)
+{
+  install_types (*this);
 
-    install_ops (*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;
+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 < m_num_types; i++)
-      {
-        if (t_name == m_types (i))
-          {
-            if (abort_on_duplicate)
-              {
-                std::cerr << "duplicate type " << t_name << std::endl;
-                abort ();
-              }
+  for (i = 0; i < m_num_types; i++)
+    {
+      if (t_name == m_types (i))
+        {
+          if (abort_on_duplicate)
+            {
+              std::cerr << "duplicate type " << t_name << std::endl;
+              abort ();
+            }
 
-            warning ("duplicate type %s\n", t_name.c_str ());
+          warning ("duplicate type %s\n", t_name.c_str ());
 
-            return i;
-          }
-      }
+          return i;
+        }
+    }
 
-    int len = m_types.numel ();
+  int len = m_types.numel ();
 
-    if (i == len)
-      {
-        len *= 2;
+  if (i == len)
+    {
+      len *= 2;
 
-        m_types.resize (dim_vector (len, 1), "");
+      m_types.resize (dim_vector (len, 1), "");
 
-        m_vals.resize (dim_vector (len, 1), nullptr);
+      m_vals.resize (dim_vector (len, 1), nullptr);
 
-        m_unary_ops.resize
-          (dim_vector (octave_value::num_unary_ops, len), nullptr);
+      m_unary_ops.resize
+      (dim_vector (octave_value::num_unary_ops, len), nullptr);
 
-        m_non_const_unary_ops.resize
-          (dim_vector (octave_value::num_unary_ops, len), nullptr);
+      m_non_const_unary_ops.resize
+      (dim_vector (octave_value::num_unary_ops, len), nullptr);
 
-        m_binary_ops.resize
-          (dim_vector (octave_value::num_binary_ops, len, len), nullptr);
+      m_binary_ops.resize
+      (dim_vector (octave_value::num_binary_ops, len, len), nullptr);
 
-        m_compound_binary_ops.resize
-          (dim_vector (octave_value::num_compound_binary_ops, len, len),
-           nullptr);
+      m_compound_binary_ops.resize
+      (dim_vector (octave_value::num_compound_binary_ops, len, len),
+       nullptr);
 
-        m_cat_ops.resize (dim_vector (len, len), nullptr);
+      m_cat_ops.resize (dim_vector (len, len), nullptr);
 
-        m_assign_ops.resize
-          (dim_vector (octave_value::num_assign_ops, len, len), nullptr);
+      m_assign_ops.resize
+      (dim_vector (octave_value::num_assign_ops, len, len), nullptr);
 
-        m_assignany_ops.resize
-          (dim_vector (octave_value::num_assign_ops, len), nullptr);
+      m_assignany_ops.resize
+      (dim_vector (octave_value::num_assign_ops, len), nullptr);
 
-        m_pref_assign_conv.resize (dim_vector (len, len), -1);
+      m_pref_assign_conv.resize (dim_vector (len, len), -1);
 
-        m_widening_ops.resize (dim_vector (len, len), nullptr);
-      }
+      m_widening_ops.resize (dim_vector (len, len), nullptr);
+    }
 
-    m_types (i) = t_name;
+  m_types (i) = t_name;
 
-    // Yes, this object is intentionally not deleted in the destructor
-    // so that we avoid a crash on exit for user-defined data types.
-    // See bug #53156.  If that problem is properly fixed, then this
-    // could be stored as an object instead of a pointer to an object
-    // allocated with new.
+  // Yes, this object is intentionally not deleted in the destructor
+  // so that we avoid a crash on exit for user-defined data types.
+  // See bug #53156.  If that problem is properly fixed, then this
+  // could be stored as an object instead of a pointer to an object
+  // allocated with new.
 
-    m_vals(i) = new octave_value (val);
+  m_vals(i) = new octave_value (val);
 
-    m_num_types++;
+  m_num_types++;
 
-    return i;
-  }
+  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);
+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 ();
-          }
+      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 ());
-      }
+      warning ("duplicate unary operator '%s' for class dispatch",
+               op_name.c_str ());
+    }
 
-    m_unary_class_ops.checkelem (static_cast<int> (op))
-      = reinterpret_cast<void *> (f);
+  m_unary_class_ops.checkelem (static_cast<int> (op))
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t);
+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 = m_types(t);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "duplicate unary operator '" << op_name
-                      << "' for type '" << type_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("duplicate unary operator '%s' for type '%s'",
+               op_name.c_str (), type_name.c_str ());
+    }
 
-    m_unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f);
+  m_unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t);
+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 = m_types(t);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "duplicate unary operator '" << op_name
-                      << "' for type '" << type_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("duplicate unary operator '%s' for type '%s'",
+               op_name.c_str (), type_name.c_str ());
+    }
 
-    m_non_const_unary_ops.checkelem (static_cast<int> (op), t)
-      = reinterpret_cast<void *> (f);
+  m_non_const_unary_ops.checkelem (static_cast<int> (op), t)
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  return false;
+}
 
-  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);
+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)
-          {
+      if (abort_on_duplicate)
+        {
 
-            std::cerr << "duplicate binary operator '" << op_name
-                      << "' for class dispatch" << std::endl;
-            abort ();
-          }
+          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 ());
-      }
+      warning ("duplicate binary operator '%s' for class dispatch",
+               op_name.c_str ());
+    }
 
-    m_binary_class_ops.checkelem (static_cast<int> (op))
-      = reinterpret_cast<void *> (f);
+  m_binary_class_ops.checkelem (static_cast<int> (op))
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t1);
-        std::string t2_name = m_types(t2);
+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 = m_types(t1);
+      std::string t2_name = m_types(t2);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "duplicate binary operator '" << op_name
-                      << "' for types '" << t1_name << "' and '"
-                      << t2_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("duplicate binary operator '%s' for types '%s' and '%s'",
+               op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
+    }
 
-    m_binary_ops.checkelem (static_cast<int> (op), t1, t2)
-      = reinterpret_cast<void *> (f);
+  m_binary_ops.checkelem (static_cast<int> (op), t1, t2)
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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);
+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 ();
-          }
+      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 ());
-      }
+      warning ("duplicate compound binary operator '%s' for class dispatch",
+               op_name.c_str ());
+    }
 
-    m_compound_binary_class_ops.checkelem (static_cast<int> (op))
-      = reinterpret_cast<void *> (f);
+  m_compound_binary_class_ops.checkelem (static_cast<int> (op))
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t1);
-        std::string t2_name = m_types(t2);
+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 = m_types(t1);
+      std::string t2_name = m_types(t2);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "duplicate compound binary operator '"
-                      << op_name << "' for types '" << t1_name
-                      << "' and '" << t2_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("duplicate compound binary operator '%s' for types '%s' and '%s'",
+               op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
+    }
 
-    m_compound_binary_ops.checkelem (static_cast<int> (op), t1, t2)
-      = reinterpret_cast<void *> (f);
+  m_compound_binary_ops.checkelem (static_cast<int> (op), t1, t2)
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t1);
-        std::string t2_name = m_types(t2);
+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 = m_types(t1);
+      std::string t2_name = m_types(t2);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "duplicate concatenation operator for types '"
-                      << t1_name << "' and '" << t2_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("duplicate concatenation operator for types '%s' and '%s'",
+               t1_name.c_str (), t1_name.c_str ());
+    }
 
-    m_cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f);
+  m_cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t_lhs);
-        std::string t_rhs_name = m_types(t_rhs);
+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 = m_types(t_lhs);
+      std::string t_rhs_name = m_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 ();
-          }
+      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 ());
-      }
+      warning ("duplicate assignment operator '%s' for types '%s' and '%s'",
+               op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ());
+    }
 
-    m_assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs)
-      = reinterpret_cast<void *> (f);
+  m_assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs)
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t_lhs);
+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 = m_types(t_lhs);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "duplicate assignment operator '" << op_name
-                      << "' for types '" << t_lhs_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("duplicate assignment operator '%s' for types '%s'",
+               op_name.c_str (), t_lhs_name.c_str ());
+    }
 
-    m_assignany_ops.checkelem (static_cast<int> (op), t_lhs)
-      = reinterpret_cast<void *> (f);
+  m_assignany_ops.checkelem (static_cast<int> (op), t_lhs)
+    = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  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 = m_types(t_lhs);
-        std::string t_rhs_name = m_types(t_rhs);
+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 = m_types(t_lhs);
+      std::string t_rhs_name = m_types(t_rhs);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "overriding assignment conversion for types '"
-                      << t_lhs_name << "' and '" << t_rhs_name << "'"
-                      << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("overriding assignment conversion for types '%s' and '%s'",
+               t_lhs_name.c_str (), t_rhs_name.c_str ());
+    }
 
-    m_pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result;
+  m_pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result;
 
-    return false;
-  }
+  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 = m_types(t);
-        std::string t_result_name = m_types(t_result);
+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 = m_types(t);
+      std::string t_result_name = m_types(t_result);
 
-        if (abort_on_duplicate)
-          {
-            std::cerr << "overriding widening op for '" << t_name
-                      << "' to '" << t_result_name << "'" << std::endl;
-            abort ();
-          }
+      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 ());
-      }
+      warning ("overriding widening op for '%s' to '%s'",
+               t_name.c_str (), t_result_name.c_str ());
+    }
 
-    m_widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
+  m_widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
 
-    return false;
-  }
+  return false;
+}
 
-  octave_value type_info::lookup_type (const std::string& nm)
-  {
-    octave_value retval;
+octave_value type_info::lookup_type (const std::string& nm)
+{
+  octave_value retval;
 
-    for (int i = 0; i < m_num_types; i++)
-      {
-        if (nm == m_types(i))
-          {
-            retval = *m_vals(i);
-            retval.make_unique ();
-            break;
-          }
-      }
+  for (int i = 0; i < m_num_types; i++)
+    {
+      if (nm == m_types(i))
+        {
+          retval = *m_vals(i);
+          retval.make_unique ();
+          break;
+        }
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  type_info::unary_class_op_fcn
-  type_info::lookup_unary_class_op (octave_value::unary_op op)
-  {
-    void *f = m_unary_class_ops.checkelem (static_cast<int> (op));
-    return reinterpret_cast<type_info::unary_class_op_fcn> (f);
-  }
+type_info::unary_class_op_fcn
+type_info::lookup_unary_class_op (octave_value::unary_op op)
+{
+  void *f = m_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 = m_unary_ops.checkelem (static_cast<int> (op), t);
-    return reinterpret_cast<type_info::unary_op_fcn> (f);
-  }
+type_info::unary_op_fcn
+type_info::lookup_unary_op (octave_value::unary_op op, int t)
+{
+  void *f = m_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 = m_non_const_unary_ops.checkelem (static_cast<int> (op), t);
-    return reinterpret_cast<type_info::non_const_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 = m_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 = m_binary_class_ops.checkelem (static_cast<int> (op));
-    return reinterpret_cast<type_info::binary_class_op_fcn> (f);
-  }
+type_info::binary_class_op_fcn
+type_info::lookup_binary_class_op (octave_value::binary_op op)
+{
+  void *f = m_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 = m_binary_ops.checkelem (static_cast<int> (op), t1, t2);
-    return reinterpret_cast<type_info::binary_op_fcn> (f);
-  }
+type_info::binary_op_fcn
+type_info::lookup_binary_op (octave_value::binary_op op, int t1, int t2)
+{
+  void *f = m_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 = m_compound_binary_class_ops.checkelem (static_cast<int> (op));
-    return reinterpret_cast<type_info::binary_class_op_fcn> (f);
-  }
+type_info::binary_class_op_fcn
+type_info::lookup_binary_class_op (octave_value::compound_binary_op op)
+{
+  void *f = m_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 = m_compound_binary_ops.checkelem (static_cast<int> (op), t1, t2);
-    return reinterpret_cast<type_info::binary_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 = m_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 = m_cat_ops.checkelem (t1, t2);
-    return reinterpret_cast<type_info::cat_op_fcn> (f);
-  }
+type_info::cat_op_fcn
+type_info::lookup_cat_op (int t1, int t2)
+{
+  void *f = m_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 = m_assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs);
-    return reinterpret_cast<type_info::assign_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 = m_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 = m_assignany_ops.checkelem (static_cast<int> (op), t_lhs);
-    return reinterpret_cast<type_info::assignany_op_fcn> (f);
-  }
+type_info::assignany_op_fcn
+type_info::lookup_assignany_op (octave_value::assign_op op, int t_lhs)
+{
+  void *f = m_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 m_pref_assign_conv.checkelem (t_lhs, t_rhs);
-  }
+int
+type_info::lookup_pref_assign_conv (int t_lhs, int t_rhs)
+{
+  return m_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 = m_widening_ops.checkelem (t, t_result);
-    return reinterpret_cast<octave_base_value::type_conv_fcn> (f);
-  }
+octave_base_value::type_conv_fcn
+type_info::lookup_widening_op (int t, int t_result)
+{
+  void *f = m_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 (m_num_types);
+string_vector
+type_info::installed_type_names (void) const
+{
+  string_vector retval (m_num_types);
 
-    for (int i = 0; i < m_num_types; i++)
-      retval(i) = m_types(i);
+  for (int i = 0; i < m_num_types; i++)
+    retval(i) = m_types(i);
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::unary_ops_map (void) const
-  {
-    octave_scalar_map retval;
+octave_scalar_map
+type_info::unary_ops_map (void) const
+{
+  octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (m_non_const_unary_ops.columns ()),
-                        m_num_types);
+  int len = std::min (static_cast<int> (m_non_const_unary_ops.columns ()),
+                      m_num_types);
 
-    dim_vector tab_dims (1, len);
+  dim_vector tab_dims (1, len);
 
-    for (int j = 0; j < octave_value::num_unary_ops; j++)
-      {
-        boolNDArray tab (tab_dims);
+  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) = (m_unary_ops(j,i) != nullptr);
+      for (int i = 0; i < len; i++)
+        tab.xelem (i) = (m_unary_ops(j, i) != nullptr);
 
-        octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j);
+      octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j);
 
-        retval.setfield (octave_value::unary_op_as_string (op_id), tab);
-      }
+      retval.setfield (octave_value::unary_op_as_string (op_id), tab);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::non_const_unary_ops_map (void) const
-  {
-    octave_scalar_map retval;
+octave_scalar_map
+type_info::non_const_unary_ops_map (void) const
+{
+  octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (m_non_const_unary_ops.columns ()),
-                        m_num_types);
+  int len = std::min (static_cast<int> (m_non_const_unary_ops.columns ()),
+                      m_num_types);
 
-    dim_vector tab_dims (1, len);
+  dim_vector tab_dims (1, len);
 
-    for (int j = 0; j < octave_value::num_unary_ops; j++)
-      {
-        boolNDArray tab (tab_dims);
+  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) = (m_non_const_unary_ops(j,i) != nullptr);
+      for (int i = 0; i < len; i++)
+        tab.xelem (i) = (m_non_const_unary_ops(j, i) != nullptr);
 
-        octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j);
+      octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j);
 
-        retval.setfield (octave_value::unary_op_as_string (op_id), tab);
-      }
+      retval.setfield (octave_value::unary_op_as_string (op_id), tab);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::binary_ops_map (void) const
-  {
-    octave_scalar_map retval;
+octave_scalar_map
+type_info::binary_ops_map (void) const
+{
+  octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (m_binary_ops.columns ()),
-                        m_num_types);
+  int len = std::min (static_cast<int> (m_binary_ops.columns ()),
+                      m_num_types);
 
-    dim_vector tab_dims (len, len);
+  dim_vector tab_dims (len, len);
 
-    for (int k = 0; k < octave_value::num_binary_ops; k++)
-      {
-        boolNDArray tab (tab_dims);
+  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) = (m_binary_ops(k,j,i) != nullptr);
+      for (int j = 0; j < len; j++)
+        for (int i = 0; i < len; i++)
+          tab.xelem (j, i) = (m_binary_ops(k, j, i) != nullptr);
 
-        octave_value::binary_op op_id = static_cast<octave_value::binary_op> (k);
+      octave_value::binary_op op_id = static_cast<octave_value::binary_op> (k);
 
-        retval.setfield (octave_value::binary_op_as_string (op_id), tab);
-      }
+      retval.setfield (octave_value::binary_op_as_string (op_id), tab);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::compound_binary_ops_map (void) const
-  {
-    octave_scalar_map retval;
+octave_scalar_map
+type_info::compound_binary_ops_map (void) const
+{
+  octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (m_compound_binary_ops.columns ()),
-                        m_num_types);
+  int len = std::min (static_cast<int> (m_compound_binary_ops.columns ()),
+                      m_num_types);
 
-    dim_vector tab_dims (len, len);
+  dim_vector tab_dims (len, len);
 
-    for (int k = 0; k < octave_value::num_compound_binary_ops; k++)
-      {
-        boolNDArray tab (tab_dims);
+  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) = (m_compound_binary_ops(k,j,i) != nullptr);
+      for (int j = 0; j < len; j++)
+        for (int i = 0; i < len; i++)
+          tab.xelem (j, i) = (m_compound_binary_ops(k, j, i) != nullptr);
 
-        octave_value::compound_binary_op op_id
-          = static_cast<octave_value::compound_binary_op> (k);
+      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);
-      }
+      retval.setfield (octave_value::binary_op_fcn_name (op_id), tab);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::assign_ops_map (void) const
-  {
-    octave_scalar_map retval;
+octave_scalar_map
+type_info::assign_ops_map (void) const
+{
+  octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (m_assign_ops.columns ()),
-                        m_num_types);
+  int len = std::min (static_cast<int> (m_assign_ops.columns ()),
+                      m_num_types);
 
-    dim_vector tab_dims (len, len);
+  dim_vector tab_dims (len, len);
 
-    for (int k = 0; k < octave_value::num_assign_ops; k++)
-      {
-        boolNDArray tab (tab_dims);
+  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) = (m_assign_ops(k,j,i) != nullptr);
+      for (int j = 0; j < len; j++)
+        for (int i = 0; i < len; i++)
+          tab.xelem (j, i) = (m_assign_ops(k, j, i) != nullptr);
 
-        octave_value::assign_op op_id = static_cast<octave_value::assign_op> (k);
+      octave_value::assign_op op_id = static_cast<octave_value::assign_op> (k);
 
-        retval.setfield (octave_value::assign_op_as_string (op_id), tab);
-      }
+      retval.setfield (octave_value::assign_op_as_string (op_id), tab);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::assignany_ops_map (void) const
-  {
-    octave_scalar_map retval;
+octave_scalar_map
+type_info::assignany_ops_map (void) const
+{
+  octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (m_assignany_ops.columns ()),
-                        m_num_types);
+  int len = std::min (static_cast<int> (m_assignany_ops.columns ()),
+                      m_num_types);
 
-    dim_vector tab_dims (1, len);
+  dim_vector tab_dims (1, len);
 
-    for (int j = 0; j < octave_value::num_assign_ops; j++)
-      {
-        boolNDArray tab (tab_dims);
+  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) = (m_assignany_ops(j,i) != nullptr);
+      for (int i = 0; i < len; i++)
+        tab.xelem (i) = (m_assignany_ops(j, i) != nullptr);
 
-        octave_value::assign_op op_id = static_cast<octave_value::assign_op> (j);
+      octave_value::assign_op op_id = static_cast<octave_value::assign_op> (j);
 
-        retval.setfield (octave_value::assign_op_as_string (op_id), tab);
-      }
+      retval.setfield (octave_value::assign_op_as_string (op_id), tab);
+    }
 
-    return retval;
-  }
+  return retval;
+}
 
-  octave_scalar_map
-  type_info::installed_type_info (void) const
-  {
-    octave_scalar_map 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 (m_cat_ops));
-    retval.setfield ("assign_ops", assign_ops_map ());
-    retval.setfield ("assignany_ops", assignany_ops_map ());
-    retval.setfield ("pref_assign_conv", as_nd_array (m_pref_assign_conv));
-    retval.setfield ("widening_ops", as_bool_nd_array (m_widening_ops));
+  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 (m_cat_ops));
+  retval.setfield ("assign_ops", assign_ops_map ());
+  retval.setfield ("assignany_ops", assignany_ops_map ());
+  retval.setfield ("pref_assign_conv", as_nd_array (m_pref_assign_conv));
+  retval.setfield ("widening_ops", as_bool_nd_array (m_widening_ops));
 
-    return retval;
-  }
+  return retval;
+}
 
 OCTAVE_END_NAMESPACE(octave)
 
 OCTAVE_BEGIN_NAMESPACE(octave_value_typeinfo)
 
-  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__ ();
+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__ ();
 
-    return type_info.register_type (t_name, c_name, val);
-  }
+  return type_info.register_type (t_name, c_name, val);
+}
 
-  octave_value lookup_type (const std::string& nm)
-  {
-    octave::type_info& type_info = octave::__get_type_info__ ();
+octave_value lookup_type (const std::string& nm)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_type (nm);
-  }
+  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__ ();
+unary_class_op_fcn lookup_unary_class_op (octave_value::unary_op op)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_unary_class_op (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__ ();
+unary_op_fcn lookup_unary_op (octave_value::unary_op op, int t)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_unary_op (op, t);
-  }
+  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__ ();
+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__ ();
 
-    return type_info.lookup_non_const_unary_op (op, t);
-  }
+  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__ ();
+binary_class_op_fcn
+lookup_binary_class_op (octave_value::binary_op op)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_binary_class_op (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__ ();
+binary_op_fcn
+lookup_binary_op (octave_value::binary_op op, int t1, int t2)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_binary_op (op, t1, t2);
-  }
+  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__ ();
+binary_class_op_fcn
+lookup_binary_class_op (octave_value::compound_binary_op op)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_binary_class_op (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__ ();
+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__ ();
 
-    return type_info.lookup_binary_op (op, t1, t2);
-  }
+  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__ ();
+cat_op_fcn lookup_cat_op (int t1, int t2)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_cat_op (t1, t2);
-  }
+  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__ ();
+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__ ();
 
-    return type_info.lookup_assign_op (op, t_lhs, t_rhs);
-  }
+  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__ ();
+assignany_op_fcn
+lookup_assignany_op (octave_value::assign_op op, int t_lhs)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_assignany_op (op, t_lhs);
-  }
+  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__ ();
+int lookup_pref_assign_conv (int t_lhs, int t_rhs)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_pref_assign_conv (t_lhs, t_rhs);
-  }
+  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__ ();
+octave_base_value::type_conv_fcn
+lookup_widening_op (int t, int t_result)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.lookup_widening_op (t, t_result);
-  }
+  return type_info.lookup_widening_op (t, t_result);
+}
 
-  string_vector installed_type_names (void)
-  {
-    octave::type_info& type_info = octave::__get_type_info__ ();
+string_vector installed_type_names (void)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return 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__ ();
+octave_scalar_map installed_type_info (void)
+{
+  octave::type_info& type_info = octave::__get_type_info__ ();
 
-    return type_info.installed_type_info ();
-  }
+  return type_info.installed_type_info ();
+}
 
 OCTAVE_END_NAMESPACE(octave_value_typeinfo)