# HG changeset patch
# User John W. Eaton <jwe@octave.org>
# Date 1630344827 14400
# Node ID 0e0cc2760540b289c15944957f518e2e5fedd06a
# Parent  93f576a35b23b4d9d8c4f75d4834a2324f88912c
maint: use "m_" prefix for member variables in some classdef classes.

* cdef-class.h, cdef-class.cc, cdef-method.h, cdef-method.cc,
cdef-object.h, cdef-object.cc, cdef-package.h, cdef-package.cc:
Use "m_" prefix for class member variables.

diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-class.cc
--- a/libinterp/octave-value/cdef-class.cc	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-class.cc	Mon Aug 30 13:33:47 2021 -0400
@@ -81,19 +81,19 @@
   }
 
   cdef_class::cdef_class_rep::cdef_class_rep (const std::list<cdef_class>& superclasses)
-    : cdef_meta_object_rep (), member_count (0), handle_class (false),
-      meta (false)
+    : cdef_meta_object_rep (), m_member_count (0), m_handle_class (false),
+      m_meta (false)
   {
     put ("SuperClasses", to_ov (superclasses));
-    implicit_ctor_list = superclasses;
+    m_implicit_ctor_list = superclasses;
   }
 
   cdef_method
   cdef_class::cdef_class_rep::find_method (const std::string& nm, bool local)
   {
-    auto it = method_map.find (nm);
+    auto it = m_method_map.find (nm);
 
-    if (it == method_map.end ())
+    if (it == m_method_map.end ())
       {
         // FIXME: look into class directory
       }
@@ -231,9 +231,9 @@
   void
   cdef_class::cdef_class_rep::install_method (const cdef_method& meth)
   {
-    method_map[meth.get_name ()] = meth;
+    m_method_map[meth.get_name ()] = meth;
 
-    member_count++;
+    m_member_count++;
 
     if (meth.is_constructor ())
       {
@@ -270,7 +270,7 @@
                               << cdef_cls.get_name () << std::endl;
 #endif
 
-                    implicit_ctor_list.remove (cdef_cls);
+                    m_implicit_ctor_list.remove (cdef_cls);
                   }
               }
           }
@@ -320,7 +320,7 @@
 
     method_const_iterator it;
 
-    for (it = method_map.begin (); it != method_map.end (); ++it)
+    for (it = m_method_map.begin (); it != m_method_map.end (); ++it)
       {
         if (include_ctor || ! it->second.is_constructor ())
           {
@@ -357,9 +357,9 @@
   cdef_property
   cdef_class::cdef_class_rep::find_property (const std::string& nm)
   {
-    auto it = property_map.find (nm);
+    auto it = m_property_map.find (nm);
 
-    if (it != property_map.end ())
+    if (it != m_property_map.end ())
       {
         cdef_property& prop = it->second;
 
@@ -387,9 +387,9 @@
   void
   cdef_class::cdef_class_rep::install_property (const cdef_property& prop)
   {
-    property_map[prop.get_name ()] = prop;
+    m_property_map[prop.get_name ()] = prop;
 
-    member_count++;
+    m_member_count++;
   }
 
   Cell
@@ -426,7 +426,7 @@
   {
     property_const_iterator it;
 
-    for (it = property_map.begin (); it != property_map.end (); ++it)
+    for (it = m_property_map.begin (); it != m_property_map.end (); ++it)
       {
         std::string nm = it->second.get_name ();
 
@@ -466,7 +466,7 @@
   {
     load_all_methods ();
 
-    for (const auto& cls_fnmap : method_map)
+    for (const auto& cls_fnmap : m_method_map)
       {
         if (! cls_fnmap.second.is_constructor ())
           {
@@ -485,7 +485,7 @@
           }
       }
 
-    for (const auto& pname_prop : property_map)
+    for (const auto& pname_prop : m_property_map)
       {
         std::string nm = pname_prop.second.get_name ();
 
@@ -650,7 +650,7 @@
     for (auto& cls : super_classes)
       cls.initialize_object (obj);
 
-    for (const auto& pname_prop : property_map)
+    for (const auto& pname_prop : m_property_map)
       {
         if (! pname_prop.second.get ("Dependent").bool_value ())
           {
@@ -673,7 +673,7 @@
   {
     octave_value_list empty_args;
 
-    for (const auto& cls : implicit_ctor_list)
+    for (const auto& cls : m_implicit_ctor_list)
       {
         cdef_class supcls = lookup_class (cls);
 
@@ -706,9 +706,9 @@
   octave_value
   cdef_class::cdef_class_rep::get_method (const std::string& name) const
   {
-    auto p = method_map.find (name);
+    auto p = m_method_map.find (name);
 
-    if (p == method_map.end ())
+    if (p == m_method_map.end ())
       return octave_value ();
 
     return p->second.get_function ();
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-class.h
--- a/libinterp/octave-value/cdef-class.h	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-class.h	Mon Aug 30 13:33:47 2021 -0400
@@ -57,8 +57,8 @@
     {
     public:
       cdef_class_rep (void)
-        : cdef_meta_object_rep (), member_count (0), handle_class (false),
-          meta (false)
+        : cdef_meta_object_rep (), m_member_count (0), m_handle_class (false),
+          m_meta (false)
       { }
 
       OCTINTERP_API cdef_class_rep (const std::list<cdef_class>& superclasses);
@@ -103,9 +103,9 @@
 
       OCTINTERP_API string_vector get_names (void);
 
-      void set_directory (const std::string& dir) { directory = dir; }
+      void set_directory (const std::string& dir) { m_directory = dir; }
 
-      std::string get_directory (void) const { return directory; }
+      std::string get_directory (void) const { return m_directory; }
 
       OCTINTERP_API void delete_object (const cdef_object& obj);
 
@@ -132,30 +132,30 @@
       OCTINTERP_API void
       run_constructor (cdef_object& obj, const octave_value_list& args);
 
-      void mark_as_handle_class (void) { handle_class = true; }
+      void mark_as_handle_class (void) { m_handle_class = true; }
 
-      bool is_handle_class (void) const { return handle_class; }
+      bool is_handle_class (void) const { return m_handle_class; }
 
-      octave_idx_type static_count (void) const { return member_count; }
+      octave_idx_type static_count (void) const { return m_member_count; }
 
       void destroy (void)
       {
-        if (member_count)
+        if (m_member_count)
           {
             m_count++;
             cdef_class lock (this);
 
-            member_count = 0;
-            method_map.clear ();
-            property_map.clear ();
+            m_member_count = 0;
+            m_method_map.clear ();
+            m_property_map.clear ();
           }
         else
           delete this;
       }
 
-      void mark_as_meta_class (void) { meta = true; }
+      void mark_as_meta_class (void) { m_meta = true; }
 
-      bool is_meta_class (void) const { return meta; }
+      bool is_meta_class (void) const { return m_meta; }
 
       void doc_string (const std::string& txt) { m_doc_string = txt; }
 
@@ -184,36 +184,36 @@
       // The @-directory were this class is loaded from.
       // (not used yet)
 
-      std::string directory;
+      std::string m_directory;
 
       std::string m_doc_string;
 
       // The methods defined by this class.
 
-      std::map<std::string,cdef_method> method_map;
+      std::map<std::string,cdef_method> m_method_map;
 
       // The properties defined by this class.
 
-      std::map<std::string,cdef_property> property_map;
+      std::map<std::string,cdef_property> m_property_map;
 
       // The number of members in this class (methods, properties...)
 
-      octave_idx_type member_count;
+      octave_idx_type m_member_count;
 
       // TRUE if this class is a handle class.  A class is a handle
       // class when the abstract "handle" class is one of its superclasses.
 
-      bool handle_class;
+      bool m_handle_class;
 
       // The list of super-class constructors that are called implicitly by the
       // the classdef engine when creating an object.  These constructors are not
       // called explicitly by the class constructor.
 
-      std::list<cdef_class> implicit_ctor_list;
+      std::list<cdef_class> m_implicit_ctor_list;
 
       // TRUE if this class is a built-in meta class.
 
-      bool meta;
+      bool m_meta;
 
       // Utility iterator typedefs.
 
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-method.cc
--- a/libinterp/octave-value/cdef-method.cc	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-method.cc	Mon Aug 30 13:33:47 2021 -0400
@@ -72,13 +72,13 @@
   {
     if (is_external ())
       {
-        if (is_dummy_method (function))
+        if (is_dummy_method (m_function))
           {
             load_path& lp
               = __get_load_path__ ("cdef_method::cdef_method_rep::check_method");
 
             std::string name = get_name ();
-            std::string cls_name = dispatch_type;
+            std::string cls_name = m_dispatch_type;
             std::string pack_name;
 
             std::size_t pos = cls_name.rfind ('.');
@@ -97,13 +97,13 @@
               {
                 octave_value ov_fcn
                   = load_fcn_from_file (file_name, dir_name,
-                                        dispatch_type, pack_name);
+                                        m_dispatch_type, pack_name);
 
                 if (ov_fcn.is_defined ())
                   {
-                    function = ov_fcn;
+                    m_function = ov_fcn;
 
-                    make_function_of_class (dispatch_type, function);
+                    make_function_of_class (m_dispatch_type, m_function);
                   }
               }
           }
@@ -112,9 +112,9 @@
             // FIXME: check out-of-date status
           }
 
-        if (is_dummy_method (function))
+        if (is_dummy_method (m_function))
           error ("no definition found for method '%s' of class '%s'",
-                 get_name ().c_str (), dispatch_type.c_str ());
+                 get_name ().c_str (), m_dispatch_type.c_str ());
       }
   }
 
@@ -134,8 +134,8 @@
 
     check_method ();
 
-    if (function.is_defined ())
-      retval = feval (function, args, nargout);
+    if (m_function.is_defined ())
+      retval = feval (m_function, args, nargout);
 
     return retval;
   }
@@ -157,7 +157,7 @@
 
     check_method ();
 
-    if (function.is_defined ())
+    if (m_function.is_defined ())
       {
         octave_value_list new_args;
 
@@ -167,7 +167,7 @@
         for (int i = 0; i < args.length (); i++)
           new_args(i+1) = args(i);
 
-        retval = feval (function, new_args, nargout);
+        retval = feval (m_function, new_args, nargout);
       }
 
     return retval;
@@ -176,8 +176,8 @@
   bool
   cdef_method::cdef_method_rep::is_constructor (void) const
   {
-    if (function.is_function())
-      return function.function_value ()->is_classdef_constructor ();
+    if (m_function.is_function())
+      return m_function.function_value ()->is_classdef_constructor ();
 
     return false;
   }
@@ -185,8 +185,8 @@
   bool
   cdef_method::cdef_method_rep::is_defined_in_class (const std::string &cname) const
   {
-    return (function.is_function ()
-            ? function.function_value ()->dispatch_class () == cname
+    return (m_function.is_function ()
+            ? m_function.function_value ()->dispatch_class () == cname
             : false);
   }
 
@@ -195,7 +195,7 @@
   {
     check_method ();
 
-    octave_function *fcn = function.function_value ();
+    octave_function *fcn = m_function.function_value ();
 
     return fcn ? fcn->doc_string () : "";
   }
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-method.h
--- a/libinterp/octave-value/cdef-method.h	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-method.h	Mon Aug 30 13:33:47 2021 -0400
@@ -52,7 +52,7 @@
     public:
 
       cdef_method_rep (void)
-        : cdef_meta_object_rep (), function (), dispatch_type ()
+        : cdef_meta_object_rep (), m_function (), m_dispatch_type ()
       { }
 
       cdef_method_rep& operator = (const cdef_method_rep& m) = delete;
@@ -69,19 +69,19 @@
 
       bool is_static (void) const { return get("Static").bool_value (); }
 
-      octave_value get_function (void) const { return function; }
+      octave_value get_function (void) const { return m_function; }
 
-      void set_function (const octave_value& fcn) { function = fcn; }
+      void set_function (const octave_value& fcn) { m_function = fcn; }
 
       OCTINTERP_API std::string get_doc_string (void);
 
       OCTINTERP_API bool check_access (void) const;
 
-      bool is_external (void) const { return ! dispatch_type.empty (); }
+      bool is_external (void) const { return ! m_dispatch_type.empty (); }
 
       void mark_as_external (const std::string& dtype)
       {
-        dispatch_type = dtype;
+        m_dispatch_type = dtype;
       }
 
       OCTINTERP_API octave_value_list
@@ -109,8 +109,8 @@
     private:
 
       cdef_method_rep (const cdef_method_rep& m)
-        : cdef_meta_object_rep (m), function (m.function),
-          dispatch_type (m.dispatch_type)
+        : cdef_meta_object_rep (m), m_function (m.m_function),
+          m_dispatch_type (m.m_dispatch_type)
       { }
 
       OCTINTERP_API void check_method (void);
@@ -121,12 +121,12 @@
         return cdef_method (this);
       }
 
-      octave_value function;
+      octave_value m_function;
 
       // When non-empty, the method is externally defined and this member
       // is used to cache the dispatch type to look for the method.
 
-      std::string dispatch_type;
+      std::string m_dispatch_type;
     };
 
   public:
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-object.cc
--- a/libinterp/octave-value/cdef-object.cc	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-object.cc	Mon Aug 30 13:33:47 2021 -0400
@@ -182,23 +182,23 @@
   cdef_class
   cdef_object::get_class (void) const
   {
-    return rep->get_class ();
+    return m_rep->get_class ();
   }
 
   cdef_class
   cdef_object_base::get_class (void) const
   {
-    return cdef_class (klass);
+    return cdef_class (m_klass);
   }
 
   void
   cdef_object_base::set_class (const cdef_class& cls)
   {
-    if ((klass.ok () && cls.ok () && cls != get_class ())
-        || (klass.ok () && ! cls.ok ())
-        || (! klass.ok () && cls.ok ()))
+    if ((m_klass.ok () && cls.ok () && cls != get_class ())
+        || (m_klass.ok () && ! cls.ok ())
+        || (! m_klass.ok () && cls.ok ()))
       {
-        klass = cls;
+        m_klass = cls;
       }
   }
 
@@ -254,7 +254,7 @@
               is_scalar = is_scalar && iv(i).is_scalar ();
             }
 
-          Array<cdef_object> ires = array.index (iv, auto_add);
+          Array<cdef_object> ires = m_array.index (iv, auto_add);
 
           // If resizing is enabled (auto_add = true), it's possible
           // indexing was out-of-bound and the result array contains
@@ -281,7 +281,7 @@
           {
             Cell c (dims ());
 
-            octave_idx_type n = array.numel ();
+            octave_idx_type n = m_array.numel ();
 
             // dummy variables
             std::size_t dummy_skip;
@@ -289,7 +289,7 @@
 
             for (octave_idx_type i = 0; i < n; i++)
               {
-                octave_value_list r = array(i).subsref (type, idx, 1, dummy_skip,
+                octave_value_list r = m_array(i).subsref (type, idx, 1, dummy_skip,
                                                         dummy_cls);
 
                 if (r.length () > 0)
@@ -359,11 +359,11 @@
             else
               rhs_mat = rhs_obj.array_value ();
 
-            octave_idx_type n = array.numel ();
+            octave_idx_type n = m_array.numel ();
 
-            array.assign (iv, rhs_mat, cdef_object ());
+            m_array.assign (iv, rhs_mat, cdef_object ());
 
-            if (array.numel () > n)
+            if (m_array.numel () > n)
               fill_empty_values ();
 
             m_count++;
@@ -377,7 +377,7 @@
             // array.index doesn't create a new blank entry (bug #46660).
             const octave_idx_type one = static_cast<octave_idx_type> (1);
             const octave_value_list& ival = ivl.length () >= 2
-                                            ? ivl : ((array.dims ()(0) == 1)
+                                            ? ivl : ((m_array.dims ()(0) == 1)
                                                      ? ovl (one, ivl(0))
                                                      : ovl (ivl(0), one));
 
@@ -406,7 +406,7 @@
                          "array.");
               }
 
-            Array<cdef_object> a = array.index (iv, true);
+            Array<cdef_object> a = m_array.index (iv, true);
 
             if (a.numel () != 1)
               error ("subsasgn: invalid indexing for object array assignment");
@@ -451,11 +451,11 @@
                 Array<cdef_object> rhs_a (dim_vector (1, 1),
                                           robj);
 
-                octave_idx_type n = array.numel ();
+                octave_idx_type n = m_array.numel ();
 
-                array.assign (iv, rhs_a);
+                m_array.assign (iv, rhs_a);
 
-                if (array.numel () > n)
+                if (m_array.numel () > n)
                   fill_empty_values ();
               }
 
@@ -502,8 +502,8 @@
   void
   cdef_object_scalar::break_closure_cycles (const std::shared_ptr<stack_frame>& frame)
   {
-    for (octave_idx_type i = 0; i < map.nfields (); i++)
-      map.contents(i).break_closure_cycles (frame);
+    for (octave_idx_type i = 0; i < m_map.nfields (); i++)
+      m_map.contents(i).break_closure_cycles (frame);
   }
 
   octave_value_list
@@ -699,14 +699,14 @@
 
     std::list<cdef_class> supcls_list = lookup_classes (supcls);
 
-    ctor_list[cls] = supcls_list;
+    m_ctor_list[cls] = supcls_list;
   }
 
   bool
   cdef_object_scalar::is_constructed_for (const cdef_class& cls) const
   {
     return (is_constructed ()
-            || ctor_list.find (cls) == ctor_list.end ());
+            || m_ctor_list.find (cls) == m_ctor_list.end ());
   }
 
   bool
@@ -716,9 +716,9 @@
       return true;
 
     std::map<cdef_class, std::list<cdef_class>>::const_iterator it
-      = ctor_list.find (cls);
+      = m_ctor_list.find (cls);
 
-    if (it == ctor_list.end () || it->second.empty ())
+    if (it == m_ctor_list.end () || it->second.empty ())
       return true;
 
     for (const auto& cdef_cls : it->second)
@@ -731,7 +731,7 @@
   void
   cdef_object_scalar::mark_as_constructed (const cdef_class& cls)
   {
-    ctor_list.erase (cls);
+    m_ctor_list.erase (cls);
   }
 
   handle_cdef_object::~handle_cdef_object (void)
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-object.h
--- a/libinterp/octave-value/cdef-object.h	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-object.h	Mon Aug 30 13:33:47 2021 -0400
@@ -206,22 +206,22 @@
   public:
 
     // FIXME: use a null object?
-    cdef_object (void) : rep (new cdef_object_rep ()) { }
+    cdef_object (void) : m_rep (new cdef_object_rep ()) { }
 
-    cdef_object (const cdef_object& obj) : rep (obj.rep) { rep->m_count++; }
+    cdef_object (const cdef_object& obj) : m_rep (obj.m_rep) { m_rep->m_count++; }
 
-    cdef_object (cdef_object_rep *r) : rep (r) { }
+    cdef_object (cdef_object_rep *r) : m_rep (r) { }
 
-    virtual ~cdef_object (void) { rep->release (*this); }
+    virtual ~cdef_object (void) { m_rep->release (*this); }
 
     cdef_object& operator = (const cdef_object& obj)
     {
-      if (rep != obj.rep)
+      if (m_rep != obj.m_rep)
         {
-          rep->release (*this);
+          m_rep->release (*this);
 
-          rep = obj.rep;
-          rep->m_count++;
+          m_rep = obj.m_rep;
+          m_rep->m_count++;
         }
 
       return *this;
@@ -229,61 +229,61 @@
 
     OCTINTERP_API cdef_class get_class (void) const;
 
-    void set_class (const cdef_class& cls) { rep->set_class (cls); }
+    void set_class (const cdef_class& cls) { m_rep->set_class (cls); }
 
-    std::string class_name (void) const { return rep->class_name (); }
+    std::string class_name (void) const { return m_rep->class_name (); }
 
-    cdef_object clone (void) const { return cdef_object (rep->clone ()); }
+    cdef_object clone (void) const { return cdef_object (m_rep->clone ()); }
 
     cdef_object empty_clone (void) const
     {
-      return cdef_object (rep->empty_clone ());
+      return cdef_object (m_rep->empty_clone ());
     }
 
-    dim_vector dims (void) const { return rep->dims (); }
+    dim_vector dims (void) const { return m_rep->dims (); }
 
     cdef_object make_array (void) const
     {
-      return cdef_object (rep->make_array ());
+      return cdef_object (m_rep->make_array ());
     }
 
-    cdef_object copy (void) const { return cdef_object (rep->copy ()); }
+    cdef_object copy (void) const { return cdef_object (m_rep->copy ()); }
 
-    bool is_array (void) const { return rep->is_array (); }
+    bool is_array (void) const { return m_rep->is_array (); }
 
-    bool is_value_object (void) const { return rep->is_value_object (); }
+    bool is_value_object (void) const { return m_rep->is_value_object (); }
 
-    bool is_handle_object (void) const { return rep->is_handle_object (); }
+    bool is_handle_object (void) const { return m_rep->is_handle_object (); }
 
-    bool is_meta_object (void) const { return rep->is_meta_object (); }
+    bool is_meta_object (void) const { return m_rep->is_meta_object (); }
 
-    Array<cdef_object> array_value (void) const { return rep->array_value (); }
+    Array<cdef_object> array_value (void) const { return m_rep->array_value (); }
 
     void put (const std::string& pname, const octave_value& val)
     {
-      rep->put (pname, val);
+      m_rep->put (pname, val);
     }
 
     octave_value get (const std::string& pname) const
     {
-      return rep->get (pname);
+      return m_rep->get (pname);
     }
 
     void set_property (octave_idx_type idx, const std::string& pname,
                        const octave_value& pval)
     {
-      return rep->set_property (idx, pname, pval);
+      return m_rep->set_property (idx, pname, pval);
     }
 
     octave_value
     get_property (octave_idx_type idx, const std::string& pname) const
     {
-      return rep->get_property (idx, pname);
+      return m_rep->get_property (idx, pname);
     }
 
     void break_closure_cycles (const std::shared_ptr<stack_frame>& frame)
     {
-      rep->break_closure_cycles (frame);
+      m_rep->break_closure_cycles (frame);
     }
 
     octave_value_list
@@ -291,7 +291,7 @@
              int nargout, std::size_t& skip, const cdef_class& context,
              bool auto_add = false)
     {
-      return rep->subsref (type, idx, nargout, skip, context, auto_add);
+      return m_rep->subsref (type, idx, nargout, skip, context, auto_add);
     }
 
     octave_value
@@ -299,54 +299,54 @@
               const octave_value& rhs, int ignore_copies = 0)
     {
       make_unique (ignore_copies);
-      return rep->subsasgn (type, idx, rhs);
+      return m_rep->subsasgn (type, idx, rhs);
     }
 
-    string_vector map_keys (void) const { return rep->map_keys (); }
+    string_vector map_keys (void) const { return m_rep->map_keys (); }
 
     OCTINTERP_API octave_map map_value (void) const;
 
-    const cdef_object_rep * get_rep (void) const { return rep; }
+    const cdef_object_rep * get_rep (void) const { return m_rep; }
 
-    bool ok (void) const { return rep->is_valid (); }
+    bool ok (void) const { return m_rep->is_valid (); }
 
     void mark_for_construction (const cdef_class& cls)
     {
-      rep->mark_for_construction (cls);
+      m_rep->mark_for_construction (cls);
     }
 
-    bool is_constructed (void) const { return rep->is_constructed (); }
+    bool is_constructed (void) const { return m_rep->is_constructed (); }
 
     bool is_constructed_for (const cdef_class& cls) const
     {
-      return rep->is_constructed_for (cls);
+      return m_rep->is_constructed_for (cls);
     }
 
     bool is_partially_constructed_for (const cdef_class& cls) const
     {
-      return rep->is_partially_constructed_for (cls);
+      return m_rep->is_partially_constructed_for (cls);
     }
 
-    void mark_as_constructed (void) { rep->mark_as_constructed (); }
+    void mark_as_constructed (void) { m_rep->mark_as_constructed (); }
 
     void mark_as_constructed (const cdef_class& cls)
-    { rep->mark_as_constructed (cls); }
+    { m_rep->mark_as_constructed (cls); }
 
-    bool is (const cdef_object& obj) const { return rep == obj.rep; }
+    bool is (const cdef_object& obj) const { return m_rep == obj.m_rep; }
 
   protected:
 
-    cdef_object_rep * get_rep (void) { return rep; }
+    cdef_object_rep * get_rep (void) { return m_rep; }
 
     void make_unique (int ignore_copies)
     {
-      if (rep->m_count > ignore_copies + 1)
+      if (m_rep->m_count > ignore_copies + 1)
         *this = clone ();
     }
 
   private:
 
-    cdef_object_rep *rep;
+    cdef_object_rep *m_rep;
   };
 
   class
@@ -355,7 +355,7 @@
   public:
 
     cdef_object_base (void)
-      : cdef_object_rep (), klass ()
+      : cdef_object_rep (), m_klass ()
     { }
 
     cdef_object_base& operator = (const cdef_object_base&) = delete;
@@ -377,13 +377,13 @@
 
     // Restricted copying!
     cdef_object_base (const cdef_object_base& obj)
-      : cdef_object_rep (obj), klass (obj.klass)
+      : cdef_object_rep (obj), m_klass (obj.m_klass)
     { }
 
   private:
 
     // The class of the object
-    cdef_object klass;
+    cdef_object m_klass;
   };
 
   class
@@ -394,7 +394,7 @@
     cdef_object_array (void) : cdef_object_base () { }
 
     cdef_object_array (const Array<cdef_object>& a)
-      : cdef_object_base (), array (a)
+      : cdef_object_base (), m_array (a)
     { }
 
     cdef_object_array& operator = (const cdef_object_array&) = delete;
@@ -406,13 +406,13 @@
       return new cdef_object_array (*this);
     }
 
-    dim_vector dims (void) const { return array.dims (); }
+    dim_vector dims (void) const { return m_array.dims (); }
 
     bool is_valid (void) const { return true; }
 
     bool is_array (void) const { return true; }
 
-    Array<cdef_object> array_value (void) const { return array; }
+    Array<cdef_object> array_value (void) const { return m_array; }
 
     OCTINTERP_API octave_value_list
     subsref (const std::string& type, const std::list<octave_value_list>& idx,
@@ -426,7 +426,7 @@
     void set_property (octave_idx_type idx, const std::string& pname,
                        const octave_value& pval)
     {
-      cdef_object& tmp = array.elem (idx);
+      cdef_object& tmp = m_array.elem (idx);
 
       return tmp.put (pname, pval);
     }
@@ -434,22 +434,22 @@
     octave_value
     get_property (octave_idx_type idx, const std::string& pname) const
     {
-      cdef_object tmp = array.elem (idx);
+      cdef_object tmp = m_array.elem (idx);
 
       return tmp.get (pname);
     }
 
   private:
 
-    Array<cdef_object> array;
+    Array<cdef_object> m_array;
 
-    void fill_empty_values (void) { fill_empty_values (array); }
+    void fill_empty_values (void) { fill_empty_values (m_array); }
 
     OCTINTERP_API void fill_empty_values (Array<cdef_object>& arr);
 
     // Private copying!
     cdef_object_array (const cdef_object_array& obj)
-      : cdef_object_base (obj), array (obj.array)
+      : cdef_object_base (obj), m_array (obj.m_array)
     { }
   };
 
@@ -470,12 +470,12 @@
 
     void put (const std::string& pname, const octave_value& val)
     {
-      map.assign (pname, val);
+      m_map.assign (pname, val);
     }
 
     octave_value get (const std::string& pname) const
     {
-      Cell val = map.contents (pname);
+      Cell val = m_map.contents (pname);
 
       if (val.numel () < 1)
         error ("get: unknown slot: %s", pname.c_str ());
@@ -517,25 +517,25 @@
     OCTINTERP_API bool
     is_partially_constructed_for (const cdef_class& cls) const;
 
-    void mark_as_constructed (void) { ctor_list.clear (); }
+    void mark_as_constructed (void) { m_ctor_list.clear (); }
 
     OCTINTERP_API void mark_as_constructed (const cdef_class& cls);
 
-    bool is_constructed (void) const { return ctor_list.empty (); }
+    bool is_constructed (void) const { return m_ctor_list.empty (); }
 
   protected:
 
     // Object property values
-    octave_scalar_map map;
+    octave_scalar_map m_map;
 
     // Internal/temporary structure used during object construction
-    std::map< cdef_class, std::list<cdef_class>> ctor_list;
+    std::map< cdef_class, std::list<cdef_class>> m_ctor_list;
 
   protected:
 
     // Restricted object copying!
     cdef_object_scalar (const cdef_object_scalar& obj)
-      : cdef_object_base (obj), map (obj.map), ctor_list (obj.ctor_list)
+      : cdef_object_base (obj), m_map (obj.m_map), m_ctor_list (obj.m_ctor_list)
     { }
   };
 
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-package.cc
--- a/libinterp/octave-value/cdef-package.cc	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-package.cc	Mon Aug 30 13:33:47 2021 -0400
@@ -57,25 +57,25 @@
   cdef_package::cdef_package_rep::install_class (const cdef_class& cls,
                                                  const std::string& nm)
   {
-    class_map[nm] = cls;
+    m_class_map[nm] = cls;
 
-    member_count++;
+    m_member_count++;
   }
 
   void
   cdef_package::cdef_package_rep::install_function (const octave_value& fcn,
                                                     const std::string& nm)
   {
-    function_map[nm] = fcn;
+    m_function_map[nm] = fcn;
   }
 
   void
   cdef_package::cdef_package_rep::install_package (const cdef_package& pack,
                                                    const std::string& nm)
   {
-    package_map[nm] = pack;
+    m_package_map[nm] = pack;
 
-    member_count++;
+    m_member_count++;
   }
 
   template <typename T1, typename T2>
@@ -94,19 +94,19 @@
   Cell
   cdef_package::cdef_package_rep::get_classes (void) const
   {
-    return map2Cell (class_map);
+    return map2Cell (m_class_map);
   }
 
   Cell
   cdef_package::cdef_package_rep::get_functions (void) const
   {
-    return map2Cell (function_map);
+    return map2Cell (m_function_map);
   }
 
   Cell
   cdef_package::cdef_package_rep::get_packages (void) const
   {
-    return map2Cell (package_map);
+    return map2Cell (m_package_map);
   }
 
   octave_value
diff -r 93f576a35b23 -r 0e0cc2760540 libinterp/octave-value/cdef-package.h
--- a/libinterp/octave-value/cdef-package.h	Mon Aug 30 09:55:32 2021 -0700
+++ b/libinterp/octave-value/cdef-package.h	Mon Aug 30 13:33:47 2021 -0400
@@ -53,7 +53,7 @@
     {
     public:
 
-      cdef_package_rep (void) : cdef_meta_object_rep (), member_count (0) { }
+      cdef_package_rep (void) : cdef_meta_object_rep (), m_member_count (0) { }
 
       cdef_package_rep& operator = (const cdef_package_rep&) = delete;
 
@@ -82,18 +82,18 @@
 
       OCTINTERP_API Cell get_packages (void) const;
 
-      octave_idx_type static_count (void) const { return member_count; }
+      octave_idx_type static_count (void) const { return m_member_count; }
 
       void destroy (void)
       {
-        if (member_count)
+        if (m_member_count)
           {
             m_count++;
             cdef_package lock (this);
 
-            member_count = 0;
-            class_map.clear ();
-            package_map.clear ();
+            m_member_count = 0;
+            m_class_map.clear ();
+            m_package_map.clear ();
           }
         else
           delete this;
@@ -114,14 +114,14 @@
 
     private:
 
-      std::string full_name;
-      std::map<std::string, cdef_class> class_map;
-      std::map<std::string, octave_value> function_map;
-      std::map<std::string, cdef_package> package_map;
+      std::string m_full_name;
+      std::map<std::string, cdef_class> m_class_map;
+      std::map<std::string, octave_value> m_function_map;
+      std::map<std::string, cdef_package> m_package_map;
 
       // The number of registered members in this package (classes, packages).
       // This only accounts for the members that back-reference to this package.
-      octave_idx_type member_count;
+      octave_idx_type m_member_count;
 
       typedef std::map<std::string, cdef_class>::iterator class_iterator;
       typedef std::map<std::string, cdef_class>::const_iterator class_const_iterator;
@@ -133,9 +133,9 @@
         package_const_iterator;
 
       cdef_package_rep (const cdef_package_rep& p)
-        : cdef_meta_object_rep (p), full_name (p.full_name),
-          class_map (p.class_map), function_map (p.function_map),
-          package_map (p.package_map), member_count (p.member_count)
+        : cdef_meta_object_rep (p), m_full_name (p.m_full_name),
+          m_class_map (p.m_class_map), m_function_map (p.m_function_map),
+          m_package_map (p.m_package_map), m_member_count (p.m_member_count)
       { }
 
       cdef_package wrap (void)