--- a/libinterp/octave-value/ov-typeinfo.cc	Mon Aug 30 10:52:39 2021 -0700
+++ b/libinterp/octave-value/ov-typeinfo.cc	Mon Aug 30 14:02:47 2021 -0400
@@ -66,20 +66,20 @@
   }
 
   type_info::type_info (int init_tab_sz)
-    : num_types (0), types (dim_vector (init_tab_sz, 1), ""),
-      vals (dim_vector (init_tab_sz, 1)),
-      unary_class_ops (dim_vector (octave_value::num_unary_ops, 1), nullptr),
-      unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr),
-      non_const_unary_ops (dim_vector (octave_value::num_unary_ops, init_tab_sz), nullptr),
-      binary_class_ops (dim_vector (octave_value::num_binary_ops, 1), nullptr),
-      binary_ops (dim_vector (octave_value::num_binary_ops, init_tab_sz, init_tab_sz), nullptr),
-      compound_binary_class_ops (dim_vector (octave_value::num_compound_binary_ops, 1), nullptr),
-      compound_binary_ops (dim_vector (octave_value::num_compound_binary_ops, init_tab_sz, init_tab_sz), nullptr),
-      cat_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr),
-      assign_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz, init_tab_sz), nullptr),
-      assignany_ops (dim_vector (octave_value::num_assign_ops, init_tab_sz), nullptr),
-      pref_assign_conv (dim_vector (init_tab_sz, init_tab_sz), -1),
-      widening_ops (dim_vector (init_tab_sz, init_tab_sz), nullptr)
+    : 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);
 
@@ -93,9 +93,9 @@
   {
     int i = 0;
 
-    for (i = 0; i < num_types; i++)
+    for (i = 0; i < m_num_types; i++)
       {
-        if (t_name == types (i))
+        if (t_name == m_types (i))
           {
             if (abort_on_duplicate)
               {
@@ -109,43 +109,43 @@
           }
       }
 
-    int len = types.numel ();
+    int len = m_types.numel ();
 
     if (i == len)
       {
         len *= 2;
 
-        types.resize (dim_vector (len, 1), "");
+        m_types.resize (dim_vector (len, 1), "");
 
-        vals.resize (dim_vector (len, 1), nullptr);
+        m_vals.resize (dim_vector (len, 1), nullptr);
 
-        unary_ops.resize
+        m_unary_ops.resize
           (dim_vector (octave_value::num_unary_ops, len), nullptr);
 
-        non_const_unary_ops.resize
+        m_non_const_unary_ops.resize
           (dim_vector (octave_value::num_unary_ops, len), nullptr);
 
-        binary_ops.resize
+        m_binary_ops.resize
           (dim_vector (octave_value::num_binary_ops, len, len), nullptr);
 
-        compound_binary_ops.resize
+        m_compound_binary_ops.resize
           (dim_vector (octave_value::num_compound_binary_ops, len, len),
            nullptr);
 
-        cat_ops.resize (dim_vector (len, len), nullptr);
+        m_cat_ops.resize (dim_vector (len, len), nullptr);
 
-        assign_ops.resize
+        m_assign_ops.resize
           (dim_vector (octave_value::num_assign_ops, len, len), nullptr);
 
-        assignany_ops.resize
+        m_assignany_ops.resize
           (dim_vector (octave_value::num_assign_ops, len), nullptr);
 
-        pref_assign_conv.resize (dim_vector (len, len), -1);
+        m_pref_assign_conv.resize (dim_vector (len, len), -1);
 
-        widening_ops.resize (dim_vector (len, len), nullptr);
+        m_widening_ops.resize (dim_vector (len, len), nullptr);
       }
 
-    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.
@@ -153,9 +153,9 @@
     // could be stored as an object instead of a pointer to an object
     // allocated with new.
 
-    vals(i) = new octave_value (val);
+    m_vals(i) = new octave_value (val);
 
-    num_types++;
+    m_num_types++;
 
     return i;
   }
@@ -179,7 +179,7 @@
                  op_name.c_str ());
       }
 
-    unary_class_ops.checkelem (static_cast<int> (op))
+    m_unary_class_ops.checkelem (static_cast<int> (op))
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -191,7 +191,7 @@
     if (lookup_unary_op (op, t))
       {
         std::string op_name = octave_value::unary_op_as_string (op);
-        std::string type_name = types(t);
+        std::string type_name = m_types(t);
 
         if (abort_on_duplicate)
           {
@@ -204,7 +204,7 @@
                  op_name.c_str (), type_name.c_str ());
       }
 
-    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;
   }
@@ -217,7 +217,7 @@
     if (lookup_non_const_unary_op (op, t))
       {
         std::string op_name = octave_value::unary_op_as_string (op);
-        std::string type_name = types(t);
+        std::string type_name = m_types(t);
 
         if (abort_on_duplicate)
           {
@@ -230,7 +230,7 @@
                  op_name.c_str (), type_name.c_str ());
       }
 
-    non_const_unary_ops.checkelem (static_cast<int> (op), t)
+    m_non_const_unary_ops.checkelem (static_cast<int> (op), t)
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -257,7 +257,7 @@
                  op_name.c_str ());
       }
 
-    binary_class_ops.checkelem (static_cast<int> (op))
+    m_binary_class_ops.checkelem (static_cast<int> (op))
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -271,8 +271,8 @@
     if (lookup_binary_op (op, t1, t2))
       {
         std::string op_name = octave_value::binary_op_as_string (op);
-        std::string t1_name = types(t1);
-        std::string t2_name = types(t2);
+        std::string t1_name = m_types(t1);
+        std::string t2_name = m_types(t2);
 
         if (abort_on_duplicate)
           {
@@ -286,7 +286,7 @@
                  op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
       }
 
-    binary_ops.checkelem (static_cast<int> (op), t1, t2)
+    m_binary_ops.checkelem (static_cast<int> (op), t1, t2)
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -312,7 +312,7 @@
                  op_name.c_str ());
       }
 
-    compound_binary_class_ops.checkelem (static_cast<int> (op))
+    m_compound_binary_class_ops.checkelem (static_cast<int> (op))
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -326,8 +326,8 @@
     if (lookup_binary_op (op, t1, t2))
       {
         std::string op_name = octave_value::binary_op_fcn_name (op);
-        std::string t1_name = types(t1);
-        std::string t2_name = types(t2);
+        std::string t1_name = m_types(t1);
+        std::string t2_name = m_types(t2);
 
         if (abort_on_duplicate)
           {
@@ -341,7 +341,7 @@
                  op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
       }
 
-    compound_binary_ops.checkelem (static_cast<int> (op), t1, t2)
+    m_compound_binary_ops.checkelem (static_cast<int> (op), t1, t2)
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -352,8 +352,8 @@
   {
     if (lookup_cat_op (t1, t2))
       {
-        std::string t1_name = types(t1);
-        std::string t2_name = types(t2);
+        std::string t1_name = m_types(t1);
+        std::string t2_name = m_types(t2);
 
         if (abort_on_duplicate)
           {
@@ -366,7 +366,7 @@
                  t1_name.c_str (), t1_name.c_str ());
       }
 
-    cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f);
+    m_cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f);
 
     return false;
   }
@@ -379,8 +379,8 @@
     if (lookup_assign_op (op, t_lhs, t_rhs))
       {
         std::string op_name = octave_value::assign_op_as_string (op);
-        std::string t_lhs_name = types(t_lhs);
-        std::string t_rhs_name = types(t_rhs);
+        std::string t_lhs_name = m_types(t_lhs);
+        std::string t_rhs_name = m_types(t_rhs);
 
         if (abort_on_duplicate)
           {
@@ -394,7 +394,7 @@
                  op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ());
       }
 
-    assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs)
+    m_assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs)
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -407,7 +407,7 @@
     if (lookup_assignany_op (op, t_lhs))
       {
         std::string op_name = octave_value::assign_op_as_string (op);
-        std::string t_lhs_name = types(t_lhs);
+        std::string t_lhs_name = m_types(t_lhs);
 
         if (abort_on_duplicate)
           {
@@ -420,7 +420,7 @@
                  op_name.c_str (), t_lhs_name.c_str ());
       }
 
-    assignany_ops.checkelem (static_cast<int> (op), t_lhs)
+    m_assignany_ops.checkelem (static_cast<int> (op), t_lhs)
       = reinterpret_cast<void *> (f);
 
     return false;
@@ -432,8 +432,8 @@
   {
     if (lookup_pref_assign_conv (t_lhs, t_rhs) >= 0)
       {
-        std::string t_lhs_name = types(t_lhs);
-        std::string t_rhs_name = types(t_rhs);
+        std::string t_lhs_name = m_types(t_lhs);
+        std::string t_rhs_name = m_types(t_rhs);
 
         if (abort_on_duplicate)
           {
@@ -447,7 +447,7 @@
                  t_lhs_name.c_str (), t_rhs_name.c_str ());
       }
 
-    pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result;
+    m_pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result;
 
     return false;
   }
@@ -458,8 +458,8 @@
   {
     if (lookup_widening_op (t, t_result))
       {
-        std::string t_name = types(t);
-        std::string t_result_name = types(t_result);
+        std::string t_name = m_types(t);
+        std::string t_result_name = m_types(t_result);
 
         if (abort_on_duplicate)
           {
@@ -472,7 +472,7 @@
                  t_name.c_str (), t_result_name.c_str ());
       }
 
-    widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
+    m_widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
 
     return false;
   }
@@ -481,11 +481,11 @@
   {
     octave_value retval;
 
-    for (int i = 0; i < num_types; i++)
+    for (int i = 0; i < m_num_types; i++)
       {
-        if (nm == types(i))
+        if (nm == m_types(i))
           {
-            retval = *vals(i);
+            retval = *m_vals(i);
             retval.make_unique ();
             break;
           }
@@ -497,42 +497,42 @@
   type_info::unary_class_op_fcn
   type_info::lookup_unary_class_op (octave_value::unary_op op)
   {
-    void *f = unary_class_ops.checkelem (static_cast<int> (op));
+    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 = unary_ops.checkelem (static_cast<int> (op), 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 = non_const_unary_ops.checkelem (static_cast<int> (op), 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 = binary_class_ops.checkelem (static_cast<int> (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 = binary_ops.checkelem (static_cast<int> (op), t1, 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 = compound_binary_class_ops.checkelem (static_cast<int> (op));
+    void *f = m_compound_binary_class_ops.checkelem (static_cast<int> (op));
     return reinterpret_cast<type_info::binary_class_op_fcn> (f);
   }
 
@@ -540,14 +540,14 @@
   type_info::lookup_binary_op (octave_value::compound_binary_op op,
                                int t1, int t2)
   {
-    void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2);
+    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 = cat_ops.checkelem (t1, t2);
+    void *f = m_cat_ops.checkelem (t1, t2);
     return reinterpret_cast<type_info::cat_op_fcn> (f);
   }
 
@@ -555,37 +555,37 @@
   type_info::lookup_assign_op (octave_value::assign_op op,
                                int t_lhs, int t_rhs)
   {
-    void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs);
+    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 = assignany_ops.checkelem (static_cast<int> (op), 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 pref_assign_conv.checkelem (t_lhs, 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 = widening_ops.checkelem (t, 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 (num_types);
+    string_vector retval (m_num_types);
 
-    for (int i = 0; i < num_types; i++)
-      retval(i) = types(i);
+    for (int i = 0; i < m_num_types; i++)
+      retval(i) = m_types(i);
 
     return retval;
   }
@@ -595,8 +595,8 @@
   {
     octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (non_const_unary_ops.columns ()),
-                        num_types);
+    int len = std::min (static_cast<int> (m_non_const_unary_ops.columns ()),
+                        m_num_types);
 
     dim_vector tab_dims (1, len);
 
@@ -605,7 +605,7 @@
         boolNDArray tab (tab_dims);
 
         for (int i = 0; i < len; i++)
-          tab.xelem (i) = (unary_ops(j,i) != nullptr);
+          tab.xelem (i) = (m_unary_ops(j,i) != nullptr);
 
         octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j);
 
@@ -620,8 +620,8 @@
   {
     octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (non_const_unary_ops.columns ()),
-                        num_types);
+    int len = std::min (static_cast<int> (m_non_const_unary_ops.columns ()),
+                        m_num_types);
 
     dim_vector tab_dims (1, len);
 
@@ -630,7 +630,7 @@
         boolNDArray tab (tab_dims);
 
         for (int i = 0; i < len; i++)
-          tab.xelem (i) = (non_const_unary_ops(j,i) != nullptr);
+          tab.xelem (i) = (m_non_const_unary_ops(j,i) != nullptr);
 
         octave_value::unary_op op_id = static_cast<octave_value::unary_op> (j);
 
@@ -645,7 +645,7 @@
   {
     octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (binary_ops.columns ()), num_types);
+    int len = std::min (static_cast<int> (m_binary_ops.columns ()), m_num_types);
 
     dim_vector tab_dims (len, len);
 
@@ -655,7 +655,7 @@
 
         for (int j = 0; j < len; j++)
           for (int i = 0; i < len; i++)
-            tab.xelem (j,i) = (binary_ops(k,j,i) != nullptr);
+            tab.xelem (j,i) = (m_binary_ops(k,j,i) != nullptr);
 
         octave_value::binary_op op_id = static_cast<octave_value::binary_op> (k);
 
@@ -670,8 +670,8 @@
   {
     octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (compound_binary_ops.columns ()),
-                        num_types);
+    int len = std::min (static_cast<int> (m_compound_binary_ops.columns ()),
+                        m_num_types);
 
     dim_vector tab_dims (len, len);
 
@@ -681,7 +681,7 @@
 
         for (int j = 0; j < len; j++)
           for (int i = 0; i < len; i++)
-            tab.xelem (j,i) = (compound_binary_ops(k,j,i) != nullptr);
+            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);
@@ -697,7 +697,7 @@
   {
     octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (assign_ops.columns ()), num_types);
+    int len = std::min (static_cast<int> (m_assign_ops.columns ()), m_num_types);
 
     dim_vector tab_dims (len, len);
 
@@ -707,7 +707,7 @@
 
         for (int j = 0; j < len; j++)
           for (int i = 0; i < len; i++)
-            tab.xelem (j,i) = (assign_ops(k,j,i) != nullptr);
+            tab.xelem (j,i) = (m_assign_ops(k,j,i) != nullptr);
 
         octave_value::assign_op op_id = static_cast<octave_value::assign_op> (k);
 
@@ -722,7 +722,7 @@
   {
     octave_scalar_map retval;
 
-    int len = std::min (static_cast<int> (assignany_ops.columns ()), num_types);
+    int len = std::min (static_cast<int> (m_assignany_ops.columns ()), m_num_types);
 
     dim_vector tab_dims (1, len);
 
@@ -731,7 +731,7 @@
         boolNDArray tab (tab_dims);
 
         for (int i = 0; i < len; i++)
-          tab.xelem (i) = (assignany_ops(j,i) != nullptr);
+          tab.xelem (i) = (m_assignany_ops(j,i) != nullptr);
 
         octave_value::assign_op op_id = static_cast<octave_value::assign_op> (j);
 
@@ -751,11 +751,11 @@
     retval.setfield ("non_const_unary_ops", non_const_unary_ops_map ());
     retval.setfield ("binary_ops", binary_ops_map ());
     retval.setfield ("compound_binary_ops", compound_binary_ops_map ());
-    retval.setfield ("cat_ops", as_bool_nd_array (cat_ops));
+    retval.setfield ("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 (pref_assign_conv));
-    retval.setfield ("widening_ops", as_bool_nd_array (widening_ops));
+    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;
   }