Mercurial > octave

changeset 29568:a7cbd0e54e7a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use m_ prefix for data members in idx_vector classes * idx-vector.h, idx-vector.cc: Use m_ prefix for data members in all idx_vector classes.
author John W. Eaton <jwe@octave.org>
date Wed, 28 Apr 2021 12:55:19 -0400
parents 345c42c067cb
children 29a1f8fd8ee6
files liboctave/array/idx-vector.cc liboctave/array/idx-vector.h
diffstat 2 files changed, 396 insertions(+), 396 deletions(-) [+]
line wrap: on
line diff
--- a/liboctave/array/idx-vector.cc	Wed Apr 28 10:23:41 2021 -0400
+++ b/liboctave/array/idx-vector.cc	Wed Apr 28 12:55:19 2021 -0400
@@ -102,39 +102,39 @@
   return os << ':';
 }
 
-idx_vector::idx_range_rep::idx_range_rep (octave_idx_type _start,
-                                          octave_idx_type _limit,
-                                          octave_idx_type _step)
-  : idx_base_rep (), start(_start),
-    len (_step ? std::max ((_limit - _start) / _step,
-                           static_cast<octave_idx_type> (0))
+idx_vector::idx_range_rep::idx_range_rep (octave_idx_type start,
+                                          octave_idx_type limit,
+                                          octave_idx_type step)
+  : idx_base_rep (), m_start(start),
+    m_len (step ? std::max ((limit - start) / step,
+                            static_cast<octave_idx_type> (0))
                : -1),
-    step (_step)
+    m_step (step)
 {
-  if (len < 0)
+  if (m_len < 0)
     err_invalid_range ();
-  if (start < 0)
-    octave::err_invalid_index (start);
-  if (step < 0 && start + (len-1)*step < 0)
-    octave::err_invalid_index (start + (len-1)*step);
+  if (m_start < 0)
+    octave::err_invalid_index (m_start);
+  if (m_step < 0 && m_start + (m_len-1)*m_step < 0)
+    octave::err_invalid_index (m_start + (m_len-1)*m_step);
 }
 
 idx_vector::idx_range_rep::idx_range_rep (const octave::range<double>& r)
-  : idx_base_rep (), start (0), len (r.numel ()), step (1)
+  : idx_base_rep (), m_start (0), m_len (r.numel ()), m_step (1)
 {
-  if (len < 0)
+  if (m_len < 0)
     err_invalid_range ();
 
-  if (len > 0)
+  if (m_len > 0)
     {
       if (r.all_elements_are_ints ())
         {
-          start = static_cast<octave_idx_type> (r.base ()) - 1;
-          step = static_cast<octave_idx_type> (r.increment ());
-          if (start < 0)
-            octave::err_invalid_index (start);
-          if (step < 0 && start + (len - 1)*step < 0)
-            octave::err_invalid_index (start + (len - 1)*step);
+          m_start = static_cast<octave_idx_type> (r.base ()) - 1;
+          m_step = static_cast<octave_idx_type> (r.increment ());
+          if (m_start < 0)
+            octave::err_invalid_index (m_start);
+          if (m_step < 0 && m_start + (m_len - 1)*m_step < 0)
+            octave::err_invalid_index (m_start + (m_len - 1)*m_step);
         }
       else
         {
@@ -149,20 +149,20 @@
 octave_idx_type
 idx_vector::idx_range_rep::checkelem (octave_idx_type i) const
 {
-  if (i < 0 || i >= len)
+  if (i < 0 || i >= m_len)
     err_index_out_of_range ();
 
-  return start + i*step;
+  return m_start + i*m_step;
 }
 
 idx_vector::idx_base_rep *
 idx_vector::idx_range_rep::sort_uniq_clone (bool)
 {
-  if (step < 0)
-    return new idx_range_rep (start + (len - 1)*step, len, -step, DIRECT);
+  if (m_step < 0)
+    return new idx_range_rep (m_start + (m_len - 1)*m_step, m_len, -m_step, DIRECT);
   else
     {
-      count++;
+      m_count++;
       return this;
     }
 }
@@ -170,19 +170,19 @@
 idx_vector::idx_base_rep *
 idx_vector::idx_range_rep::sort_idx (Array<octave_idx_type>& idx)
 {
-  if (step < 0 && len > 0)
+  if (m_step < 0 && m_len > 0)
     {
-      idx.clear (1, len);
-      for (octave_idx_type i = 0; i < len; i++)
-        idx.xelem (i) = len - 1 - i;
-      return new idx_range_rep (start + (len - 1)*step, len, -step, DIRECT);
+      idx.clear (1, m_len);
+      for (octave_idx_type i = 0; i < m_len; i++)
+        idx.xelem (i) = m_len - 1 - i;
+      return new idx_range_rep (m_start + (m_len - 1)*m_step, m_len, -m_step, DIRECT);
     }
   else
     {
-      idx.clear (1, len);
-      for (octave_idx_type i = 0; i < len; i++)
+      idx.clear (1, m_len);
+      for (octave_idx_type i = 0; i < m_len; i++)
         idx.xelem (i) = i;
-      count++;
+      m_count++;
       return this;
     }
 }
@@ -190,7 +190,7 @@
 std::ostream&
 idx_vector::idx_range_rep::print (std::ostream& os) const
 {
-  os << start << ':' << step << ':' << start + len*step;
+  os << m_start << ':' << m_step << ':' << m_start + m_len*m_step;
   return os;
 }
 
@@ -198,15 +198,15 @@
 idx_vector::idx_range_rep::unconvert (void) const
 {
   return octave::range<double>::make_n_element_range
-    (static_cast<double> (start+1), static_cast<double> (step), len);
+    (static_cast<double> (m_start+1), static_cast<double> (m_step), m_len);
 }
 
 Array<octave_idx_type>
 idx_vector::idx_range_rep::as_array (void)
 {
-  Array<octave_idx_type> retval (dim_vector (1, len));
-  for (octave_idx_type i = 0; i < len; i++)
-    retval.xelem (i) = start + i*step;
+  Array<octave_idx_type> retval (dim_vector (1, m_len));
+  for (octave_idx_type i = 0; i < m_len; i++)
+    retval.xelem (i) = m_start + i*m_step;
 
   return retval;
 }
@@ -251,18 +251,18 @@
 
 template <typename T>
 idx_vector::idx_scalar_rep::idx_scalar_rep (T x)
-  : idx_base_rep (), data (0)
+  : idx_base_rep (), m_data (0)
 {
   octave_idx_type dummy = 0;
 
-  data = convert_index (x, dummy);
+  m_data = convert_index (x, dummy);
 }
 
 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i)
-  : idx_base_rep (), data (i)
+  : idx_base_rep (), m_data (i)
 {
-  if (data < 0)
-    octave::err_invalid_index (data);
+  if (m_data < 0)
+    octave::err_invalid_index (m_data);
 }
 
 octave_idx_type
@@ -271,7 +271,7 @@
   if (i != 0)
     err_index_out_of_range ();
 
-  return data;
+  return m_data;
 }
 
 idx_vector::idx_base_rep *
@@ -279,53 +279,53 @@
 {
   idx.clear (1, 1);
   idx.fill (0);
-  count++;
+  m_count++;
   return this;
 }
 
 std::ostream& idx_vector::idx_scalar_rep::print (std::ostream& os) const
 {
-  return os << data;
+  return os << m_data;
 }
 
 double
 idx_vector::idx_scalar_rep::unconvert (void) const
 {
-  return data + 1;
+  return m_data + 1;
 }
 
 Array<octave_idx_type>
 idx_vector::idx_scalar_rep::as_array (void)
 {
-  return Array<octave_idx_type> (dim_vector (1, 1), data);
+  return Array<octave_idx_type> (dim_vector (1, 1), m_data);
 }
 
 template <typename T>
 idx_vector::idx_vector_rep::idx_vector_rep (const Array<T>& nda)
-  : idx_base_rep (), data (nullptr), len (nda.numel ()), ext (0),
-    aowner (nullptr), orig_dims (nda.dims ())
+  : idx_base_rep (), m_data (nullptr), m_len (nda.numel ()), m_ext (0),
+    m_aowner (nullptr), m_orig_dims (nda.dims ())
 {
-  if (len != 0)
+  if (m_len != 0)
     {
-      std::unique_ptr<octave_idx_type []> d (new octave_idx_type [len]);
+      std::unique_ptr<octave_idx_type []> d (new octave_idx_type [m_len]);
 
-      for (octave_idx_type i = 0; i < len; i++)
-        d[i] = convert_index (nda.xelem (i), ext);
+      for (octave_idx_type i = 0; i < m_len; i++)
+        d[i] = convert_index (nda.xelem (i), m_ext);
 
-      data = d.release ();
+      m_data = d.release ();
     }
 }
 
 // Note that this makes a shallow copy of the index array.
 
 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda)
-  : idx_base_rep (), data (inda.data ()), len (inda.numel ()), ext (0),
-    aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ())
+  : idx_base_rep (), m_data (inda.data ()), m_len (inda.numel ()), m_ext (0),
+    m_aowner (new Array<octave_idx_type> (inda)), m_orig_dims (inda.dims ())
 {
-  if (len != 0)
+  if (m_len != 0)
     {
       octave_idx_type max = -1;
-      for (octave_idx_type i = 0; i < len; i++)
+      for (octave_idx_type i = 0; i < m_len; i++)
         {
           octave_idx_type k = inda.xelem (i);
           if (k < 0)
@@ -334,55 +334,56 @@
             max = k;
         }
 
-      ext = max + 1;
+      m_ext = max + 1;
     }
 }
 
 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda,
-                                            octave_idx_type _ext, direct)
-  : idx_base_rep (), data (inda.data ()), len (inda.numel ()), ext (_ext),
-    aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ())
+                                            octave_idx_type ext, direct)
+  : idx_base_rep (), m_data (inda.data ()), m_len (inda.numel ()),
+    m_ext (ext), m_aowner (new Array<octave_idx_type> (inda)),
+    m_orig_dims (inda.dims ())
 {
   // No checking.
-  if (ext < 0)
+  if (m_ext < 0)
     {
       octave_idx_type max = -1;
-      for (octave_idx_type i = 0; i < len; i++)
-        if (data[i] > max)
-          max = data[i];
+      for (octave_idx_type i = 0; i < m_len; i++)
+        if (m_data[i] > max)
+          max = m_data[i];
 
-      ext = max + 1;
+      m_ext = max + 1;
     }
 }
 
 idx_vector::idx_vector_rep::idx_vector_rep (bool b)
-  : idx_base_rep (), data (nullptr), len (b ? 1 : 0), ext (0),
-    aowner (nullptr), orig_dims (len, len)
+  : idx_base_rep (), m_data (nullptr), m_len (b ? 1 : 0), m_ext (0),
+    m_aowner (nullptr), m_orig_dims (m_len, m_len)
 {
-  if (len != 0)
+  if (m_len != 0)
     {
       octave_idx_type *d = new octave_idx_type [1];
       d[0] = 0;
-      data = d;
-      ext = 1;
+      m_data = d;
+      m_ext = 1;
     }
 }
 
 idx_vector::idx_vector_rep::idx_vector_rep (const Array<bool>& bnda,
                                             octave_idx_type nnz)
-  : idx_base_rep (), data (nullptr), len (nnz), ext (0), aowner (nullptr),
-    orig_dims ()
+  : idx_base_rep (), m_data (nullptr), m_len (nnz), m_ext (0),
+    m_aowner (nullptr), m_orig_dims ()
 {
   if (nnz < 0)
-    len = bnda.nnz ();
+    m_len = bnda.nnz ();
 
   const dim_vector dv = bnda.dims ();
 
-  orig_dims = dv.make_nd_vector (len);
+  m_orig_dims = dv.make_nd_vector (m_len);
 
-  if (len != 0)
+  if (m_len != 0)
     {
-      octave_idx_type *d = new octave_idx_type [len];
+      octave_idx_type *d = new octave_idx_type [m_len];
 
       octave_idx_type ntot = bnda.numel ();
 
@@ -391,23 +392,23 @@
         if (bnda.xelem (i))
           d[k++] = i;
 
-      data = d;
+      m_data = d;
 
-      ext = d[k-1] + 1;
+      m_ext = d[k-1] + 1;
     }
 }
 
 idx_vector::idx_vector_rep::idx_vector_rep (const Sparse<bool>& bnda)
-  : idx_base_rep (), data (nullptr), len (bnda.nnz ()), ext (0),
-    aowner (nullptr), orig_dims ()
+  : idx_base_rep (), m_data (nullptr), m_len (bnda.nnz ()), m_ext (0),
+    m_aowner (nullptr), m_orig_dims ()
 {
   const dim_vector dv = bnda.dims ();
 
-  orig_dims = dv.make_nd_vector (len);
+  m_orig_dims = dv.make_nd_vector (m_len);
 
-  if (len != 0)
+  if (m_len != 0)
     {
-      octave_idx_type *d = new octave_idx_type [len];
+      octave_idx_type *d = new octave_idx_type [m_len];
 
       octave_idx_type k = 0;
       octave_idx_type nc = bnda.cols ();
@@ -418,24 +419,24 @@
           if (bnda.data (i))
             d[k++] = j * nr + bnda.ridx (i);
 
-      data = d;
+      m_data = d;
 
-      ext = d[k-1] + 1;
+      m_ext = d[k-1] + 1;
     }
 }
 
 idx_vector::idx_vector_rep::~idx_vector_rep (void)
 {
-  if (aowner)
-    delete aowner;
+  if (m_aowner)
+    delete m_aowner;
   else
-    delete [] data;
+    delete [] m_data;
 }
 
 octave_idx_type
 idx_vector::idx_vector_rep::checkelem (octave_idx_type n) const
 {
-  if (n < 0 || n >= len)
+  if (n < 0 || n >= m_len)
     octave::err_invalid_index (n);
 
   return xelem (n);
@@ -444,73 +445,73 @@
 idx_vector::idx_base_rep *
 idx_vector::idx_vector_rep::sort_uniq_clone (bool uniq)
 {
-  if (len == 0)
+  if (m_len == 0)
     {
-      count++;
+      m_count++;
       return this;
     }
 
   // This is wrapped in unique_ptr so that we don't leak on out-of-memory.
   std::unique_ptr<idx_vector_rep> new_rep
-    (new idx_vector_rep (nullptr, len, ext, orig_dims, DIRECT));
+    (new idx_vector_rep (nullptr, m_len, m_ext, m_orig_dims, DIRECT));
 
-  if (ext > len*octave::math::log2 (1.0 + len))
+  if (m_ext > m_len*octave::math::log2 (1.0 + m_len))
     {
       // Use standard sort via octave_sort.
-      octave_idx_type *new_data = new octave_idx_type [len];
-      new_rep->data = new_data;
+      octave_idx_type *new_data = new octave_idx_type [m_len];
+      new_rep->m_data = new_data;
 
-      std::copy_n (data, len, new_data);
+      std::copy_n (m_data, m_len, new_data);
       octave_sort<octave_idx_type> lsort;
       lsort.set_compare (ASCENDING);
-      lsort.sort (new_data, len);
+      lsort.sort (new_data, m_len);
 
       if (uniq)
         {
-          octave_idx_type new_len = std::unique (new_data, new_data + len)
+          octave_idx_type new_len = std::unique (new_data, new_data + m_len)
                                     - new_data;
-          new_rep->len = new_len;
-          if (new_rep->orig_dims.ndims () == 2 && new_rep->orig_dims(0) == 1)
-            new_rep->orig_dims = dim_vector (1, new_len);
+          new_rep->m_len = new_len;
+          if (new_rep->m_orig_dims.ndims () == 2 && new_rep->m_orig_dims(0) == 1)
+            new_rep->m_orig_dims = dim_vector (1, new_len);
           else
-            new_rep->orig_dims = dim_vector (new_len, 1);
+            new_rep->m_orig_dims = dim_vector (new_len, 1);
         }
     }
   else if (uniq)
     {
       // Use two-pass bucket sort (only a mask array needed).
-      OCTAVE_LOCAL_BUFFER_INIT (bool, has, ext, false);
-      for (octave_idx_type i = 0; i < len; i++)
-        has[data[i]] = true;
+      OCTAVE_LOCAL_BUFFER_INIT (bool, has, m_ext, false);
+      for (octave_idx_type i = 0; i < m_len; i++)
+        has[m_data[i]] = true;
 
       octave_idx_type new_len = 0;
-      for (octave_idx_type i = 0; i < ext; i++)
+      for (octave_idx_type i = 0; i < m_ext; i++)
         new_len += has[i];
 
-      new_rep->len = new_len;
-      if (new_rep->orig_dims.ndims () == 2 && new_rep->orig_dims(0) == 1)
-        new_rep->orig_dims = dim_vector (1, new_len);
+      new_rep->m_len = new_len;
+      if (new_rep->m_orig_dims.ndims () == 2 && new_rep->m_orig_dims(0) == 1)
+        new_rep->m_orig_dims = dim_vector (1, new_len);
       else
-        new_rep->orig_dims = dim_vector (new_len, 1);
+        new_rep->m_orig_dims = dim_vector (new_len, 1);
 
       octave_idx_type *new_data = new octave_idx_type [new_len];
-      new_rep->data = new_data;
+      new_rep->m_data = new_data;
 
-      for (octave_idx_type i = 0, j = 0; i < ext; i++)
+      for (octave_idx_type i = 0, j = 0; i < m_ext; i++)
         if (has[i])
           new_data[j++] = i;
     }
   else
     {
       // Use two-pass bucket sort.
-      OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, ext, 0);
-      for (octave_idx_type i = 0; i < len; i++)
-        cnt[data[i]]++;
+      OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, m_ext, 0);
+      for (octave_idx_type i = 0; i < m_len; i++)
+        cnt[m_data[i]]++;
 
-      octave_idx_type *new_data = new octave_idx_type [len];
-      new_rep->data = new_data;
+      octave_idx_type *new_data = new octave_idx_type [m_len];
+      new_rep->m_data = new_data;
 
-      for (octave_idx_type i = 0, j = 0; i < ext; i++)
+      for (octave_idx_type i = 0, j = 0; i < m_ext; i++)
         {
           for (octave_idx_type k = 0; k < cnt[i]; k++)
             new_data[j++] = i;
@@ -525,48 +526,48 @@
 {
   // This is wrapped in unique_ptr so that we don't leak on out-of-memory.
   std::unique_ptr<idx_vector_rep> new_rep
-    (new idx_vector_rep (nullptr, len, ext, orig_dims, DIRECT));
+    (new idx_vector_rep (nullptr, m_len, m_ext, m_orig_dims, DIRECT));
 
-  if (ext > len*octave::math::log2 (1.0 + len))
+  if (m_ext > m_len*octave::math::log2 (1.0 + m_len))
     {
       // Use standard sort via octave_sort.
-      idx.clear (orig_dims);
+      idx.clear (m_orig_dims);
       octave_idx_type *idx_data = idx.fortran_vec ();
-      for (octave_idx_type i = 0; i < len; i++)
+      for (octave_idx_type i = 0; i < m_len; i++)
         idx_data[i] = i;
 
-      octave_idx_type *new_data = new octave_idx_type [len];
-      new_rep->data = new_data;
-      std::copy_n (data, len, new_data);
+      octave_idx_type *new_data = new octave_idx_type [m_len];
+      new_rep->m_data = new_data;
+      std::copy_n (m_data, m_len, new_data);
 
       octave_sort<octave_idx_type> lsort;
       lsort.set_compare (ASCENDING);
-      lsort.sort (new_data, idx_data, len);
+      lsort.sort (new_data, idx_data, m_len);
     }
   else
     {
       // Use two-pass bucket sort.
-      OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, ext, 0);
+      OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, m_ext, 0);
 
-      for (octave_idx_type i = 0; i < len; i++)
-        cnt[data[i]]++;
+      for (octave_idx_type i = 0; i < m_len; i++)
+        cnt[m_data[i]]++;
 
-      idx.clear (orig_dims);
+      idx.clear (m_orig_dims);
       octave_idx_type *idx_data = idx.fortran_vec ();
 
-      octave_idx_type *new_data = new octave_idx_type [len];
-      new_rep->data = new_data;
+      octave_idx_type *new_data = new octave_idx_type [m_len];
+      new_rep->m_data = new_data;
 
-      for (octave_idx_type i = 0, k = 0; i < ext; i++)
+      for (octave_idx_type i = 0, k = 0; i < m_ext; i++)
         {
           octave_idx_type j = cnt[i];
           cnt[i] = k;
           k += j;
         }
 
-      for (octave_idx_type i = 0; i < len; i++)
+      for (octave_idx_type i = 0; i < m_len; i++)
         {
-          octave_idx_type j = data[i];
+          octave_idx_type j = m_data[i];
           octave_idx_type k = cnt[j]++;
           new_data[k] = j;
           idx_data[k] = i;
@@ -581,11 +582,11 @@
 {
   os << '[';
 
-  for (octave_idx_type i = 0; i < len - 1; i++)
-    os << data[i] << ',' << ' ';
+  for (octave_idx_type i = 0; i < m_len - 1; i++)
+    os << m_data[i] << ',' << ' ';
 
-  if (len > 0)
-    os << data[len-1];
+  if (m_len > 0)
+    os << m_data[m_len-1];
 
   os << ']';
 
@@ -595,99 +596,99 @@
 Array<double>
 idx_vector::idx_vector_rep::unconvert (void) const
 {
-  Array<double> retval (orig_dims);
-  for (octave_idx_type i = 0; i < len; i++)
-    retval.xelem (i) = data[i] + 1;
+  Array<double> retval (m_orig_dims);
+  for (octave_idx_type i = 0; i < m_len; i++)
+    retval.xelem (i) = m_data[i] + 1;
   return retval;
 }
 
 Array<octave_idx_type>
 idx_vector::idx_vector_rep::as_array (void)
 {
-  if (aowner)
-    return *aowner;
+  if (m_aowner)
+    return *m_aowner;
   else
     {
-      Array<octave_idx_type> retval (orig_dims);
+      Array<octave_idx_type> retval (m_orig_dims);
 
-      if (data)
+      if (m_data)
         {
-          std::memcpy (retval.fortran_vec (), data, len*sizeof (octave_idx_type));
-          // Delete the old copy and share the data instead to save memory.
-          delete [] data;
+          std::memcpy (retval.fortran_vec (), m_data, m_len*sizeof (octave_idx_type));
+          // Delete the old copy and share the m_data instead to save memory.
+          delete [] m_data;
         }
 
-      data = retval.fortran_vec ();
-      aowner = new Array<octave_idx_type> (retval);
+      m_data = retval.fortran_vec ();
+      m_aowner = new Array<octave_idx_type> (retval);
 
       return retval;
     }
 }
 
 idx_vector::idx_mask_rep::idx_mask_rep (bool b)
-  : idx_base_rep (), data (nullptr), len (b ? 1 : 0), ext (0),
-    lsti (-1), lste (-1), aowner (nullptr), orig_dims (len, len)
+  : idx_base_rep (), m_data (nullptr), m_len (b ? 1 : 0), m_ext (0),
+    m_lsti (-1), m_lste (-1), m_aowner (nullptr), m_orig_dims (m_len, m_len)
 {
-  if (len != 0)
+  if (m_len != 0)
     {
       bool *d = new bool [1];
       d[0] = true;
-      data = d;
-      ext = 1;
+      m_data = d;
+      m_ext = 1;
     }
 }
 
 idx_vector::idx_mask_rep::idx_mask_rep (const Array<bool>& bnda,
                                         octave_idx_type nnz)
-  : idx_base_rep (), data (nullptr), len (nnz), ext (bnda.numel ()),
-    lsti (-1), lste (-1), aowner (nullptr), orig_dims ()
+  : idx_base_rep (), m_data (nullptr), m_len (nnz), m_ext (bnda.numel ()),
+    m_lsti (-1), m_lste (-1), m_aowner (nullptr), m_orig_dims ()
 {
   if (nnz < 0)
-    len = bnda.nnz ();
+    m_len = bnda.nnz ();
 
   // We truncate the extent as much as possible.  For Matlab
   // compatibility, but maybe it's not a bad idea anyway.
-  while (ext > 0 && ! bnda(ext-1))
-    ext--;
+  while (m_ext > 0 && ! bnda(m_ext-1))
+    m_ext--;
 
   const dim_vector dv = bnda.dims ();
 
-  orig_dims = dv.make_nd_vector (len);
+  m_orig_dims = dv.make_nd_vector (m_len);
 
-  aowner = new Array<bool> (bnda);
-  data = bnda.data ();
+  m_aowner = new Array<bool> (bnda);
+  m_data = bnda.data ();
 }
 
 idx_vector::idx_mask_rep::~idx_mask_rep (void)
 {
-  if (aowner)
-    delete aowner;
+  if (m_aowner)
+    delete m_aowner;
   else
-    delete [] data;
+    delete [] m_data;
 }
 
 octave_idx_type
 idx_vector::idx_mask_rep::xelem (octave_idx_type n) const
 {
-  if (n == lsti + 1)
+  if (n == m_lsti + 1)
     {
-      lsti = n;
-      while (! data[++lste]) ;
+      m_lsti = n;
+      while (! m_data[++m_lste]) ;
     }
   else
     {
-      lsti = n++;
-      lste = -1;
+      m_lsti = n++;
+      m_lste = -1;
       while (n > 0)
-        if (data[++lste]) --n;
+        if (m_data[++m_lste]) --n;
     }
-  return lste;
+  return m_lste;
 }
 
 octave_idx_type
 idx_vector::idx_mask_rep::checkelem (octave_idx_type n) const
 {
-  if (n < 0 || n >= len)
+  if (n < 0 || n >= m_len)
     octave::err_invalid_index (n);
 
   return xelem (n);
@@ -698,11 +699,11 @@
 {
   os << '[';
 
-  for (octave_idx_type i = 0; i < ext - 1; i++)
-    os << data[i] << ',' << ' ';
+  for (octave_idx_type i = 0; i < m_ext - 1; i++)
+    os << m_data[i] << ',' << ' ';
 
-  if (ext > 0)
-    os << data[ext-1];
+  if (m_ext > 0)
+    os << m_data[m_ext-1];
 
   os << ']';
 
@@ -712,13 +713,13 @@
 Array<bool>
 idx_vector::idx_mask_rep::unconvert (void) const
 {
-  if (aowner)
-    return *aowner;
+  if (m_aowner)
+    return *m_aowner;
   else
     {
-      Array<bool> retval (dim_vector (ext, 1));
-      for (octave_idx_type i = 0; i < ext; i++)
-        retval.xelem (i) = data[i];
+      Array<bool> retval (dim_vector (m_ext, 1));
+      for (octave_idx_type i = 0; i < m_ext; i++)
+        retval.xelem (i) = m_data[i];
       return retval;
     }
 }
@@ -726,13 +727,13 @@
 Array<octave_idx_type>
 idx_vector::idx_mask_rep::as_array (void)
 {
-  if (aowner)
-    return aowner->find ().reshape (orig_dims);
+  if (m_aowner)
+    return m_aowner->find ().reshape (m_orig_dims);
   else
     {
-      Array<bool> retval (orig_dims);
-      for (octave_idx_type i = 0, j = 0; i < ext; i++)
-        if (data[i])
+      Array<bool> retval (m_orig_dims);
+      for (octave_idx_type i = 0, j = 0; i < m_ext; i++)
+        if (m_data[i])
           retval.xelem (j++) = i;
 
       return retval;
@@ -742,26 +743,26 @@
 idx_vector::idx_base_rep *
 idx_vector::idx_mask_rep::sort_idx (Array<octave_idx_type>& idx)
 {
-  idx.clear (len, 1);
-  for (octave_idx_type i = 0; i < len; i++)
+  idx.clear (m_len, 1);
+  for (octave_idx_type i = 0; i < m_len; i++)
     idx.xelem (i) = i;
 
-  count++;
+  m_count++;
   return this;
 }
 
 const idx_vector idx_vector::colon (new idx_vector::idx_colon_rep ());
 
 idx_vector::idx_vector (const Array<bool>& bnda)
-  : rep (nullptr)
+  : m_rep (nullptr)
 {
   // Convert only if it means saving at least half the memory.
   static const int factor = (2 * sizeof (octave_idx_type));
   octave_idx_type nnz = bnda.nnz ();
   if (nnz <= bnda.numel () / factor)
-    rep = new idx_vector_rep (bnda, nnz);
+    m_rep = new idx_vector_rep (bnda, nnz);
   else
-    rep = new idx_mask_rep (bnda, nnz);
+    m_rep = new idx_mask_rep (bnda, nnz);
 }
 
 bool
@@ -771,14 +772,14 @@
   bool reduced = false;
 
   // Empty index always reduces.
-  if (rep->length (n) == 0)
+  if (m_rep->length (n) == 0)
     {
       *this = idx_vector ();
       return true;
     }
 
   // Possibly skip singleton dims.
-  if (n == 1 && rep->is_colon_equiv (n))
+  if (n == 1 && m_rep->is_colon_equiv (n))
     {
       *this = j;
       return true;
@@ -790,7 +791,7 @@
   switch (j.idx_class ())
     {
     case class_colon:
-      switch (rep->idx_class ())
+      switch (m_rep->idx_class ())
         {
         case class_colon:
           // (:,:) reduces to (:)
@@ -800,7 +801,7 @@
         case class_scalar:
           {
             // (i,:) reduces to a range.
-            idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+            idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
             octave_idx_type k = r->get_data ();
             *this = new idx_range_rep (k, nj, n, DIRECT);
             reduced = true;
@@ -810,7 +811,7 @@
         case class_range:
           {
             // (i:k:end,:) reduces to a range if i <= k and k divides n.
-            idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+            idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
             octave_idx_type s = r->get_start ();
             octave_idx_type l = r->length (n);
             octave_idx_type t = r->get_step ();
@@ -828,12 +829,12 @@
       break;
 
     case class_range:
-      switch (rep->idx_class ())
+      switch (m_rep->idx_class ())
         {
         case class_colon:
           {
-            // (:,i:j) reduces to a range (the step must be 1)
-            idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.rep);
+            // (:,i:j) reduces to a range (the m_step must be 1)
+            idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.m_rep);
             if (rj->get_step () == 1)
               {
                 octave_idx_type sj = rj->get_start ();
@@ -847,8 +848,8 @@
         case class_scalar:
           {
             // (k,i:d:j) reduces to a range.
-            idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
-            idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.rep);
+            idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
+            idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.m_rep);
             octave_idx_type k = r->get_data ();
             octave_idx_type sj = rj->get_start ();
             octave_idx_type lj = rj->length (nj);
@@ -862,11 +863,11 @@
           {
             // (i:k:end,p:q) reduces to a range if i <= k and k divides n.
             // (ones (1, m), ones (1, n)) reduces to (ones (1, m*n))
-            idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+            idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
             octave_idx_type s = r->get_start ();
             octave_idx_type l = r->length (n);
             octave_idx_type t = r->get_step ();
-            idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.rep);
+            idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.m_rep);
             octave_idx_type sj = rj->get_start ();
             octave_idx_type lj = rj->length (nj);
             octave_idx_type tj = rj->get_step ();
@@ -884,13 +885,13 @@
       break;
 
     case class_scalar:
-      switch (rep->idx_class ())
+      switch (m_rep->idx_class ())
         {
         case class_scalar:
           {
             // (i,j) reduces to a single index.
-            idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
-            idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.rep);
+            idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
+            idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.m_rep);
             octave_idx_type k = r->get_data () + n * rj->get_data ();
             *this = new idx_scalar_rep (k, DIRECT);
             reduced = true;
@@ -900,8 +901,8 @@
         case class_range:
           {
             // (i:d:j,k) reduces to a range.
-            idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
-            idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.rep);
+            idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
+            idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.m_rep);
             octave_idx_type s = r->get_start ();
             octave_idx_type l = r->length (nj);
             octave_idx_type t = r->get_step ();
@@ -914,7 +915,7 @@
         case class_colon:
           {
             // (:,k) reduces to a range.
-            idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.rep);
+            idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.m_rep);
             octave_idx_type k = rj->get_data ();
             *this = new idx_range_rep (n * k, n, 1, DIRECT);
             reduced = true;
@@ -939,7 +940,7 @@
 {
   bool res = false;
 
-  switch (rep->idx_class ())
+  switch (m_rep->idx_class ())
     {
     case class_colon:
       l = 0; u = n;
@@ -948,7 +949,7 @@
 
     case class_range:
       {
-        idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+        idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
         if (r->get_step () == 1)
           {
             l = r->get_start ();
@@ -960,7 +961,7 @@
 
     case class_scalar:
       {
-        idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+        idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
         l = r->get_data ();
         u = l + 1;
         res = true;
@@ -969,13 +970,13 @@
 
     case class_mask:
       {
-        idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
-        octave_idx_type ext = r->extent (0);
-        octave_idx_type len = r->length (0);
-        if (ext == len)
+        idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
+        octave_idx_type m_ext = r->extent (0);
+        octave_idx_type m_len = r->length (0);
+        if (m_ext == m_len)
           {
             l = 0;
-            u = len;
+            u = m_len;
             res = true;
           }
       }
@@ -992,14 +993,14 @@
 {
   octave_idx_type retval = 0;
 
-  switch (rep->idx_class ())
+  switch (m_rep->idx_class ())
     {
     case class_colon:
       retval = 1;
       break;
 
     case class_range:
-      retval = dynamic_cast<idx_range_rep *> (rep) -> get_step ();
+      retval = dynamic_cast<idx_range_rep *> (m_rep) -> get_step ();
       break;
 
     case class_vector:
@@ -1020,10 +1021,10 @@
 const octave_idx_type *
 idx_vector::raw (void)
 {
-  if (rep->idx_class () != class_vector)
+  if (m_rep->idx_class () != class_vector)
     *this = idx_vector (as_array (), extent (0));
 
-  idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+  idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
 
   assert (r != nullptr);
 
@@ -1031,11 +1032,11 @@
 }
 
 void
-idx_vector::copy_data (octave_idx_type *data) const
+idx_vector::copy_data (octave_idx_type *m_data) const
 {
-  octave_idx_type len = rep->length (0);
+  octave_idx_type m_len = m_rep->length (0);
 
-  switch (rep->idx_class ())
+  switch (m_rep->idx_class ())
     {
     case class_colon:
       (*current_liboctave_error_handler) ("colon not allowed");
@@ -1043,42 +1044,42 @@
 
     case class_range:
       {
-        idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
-        octave_idx_type start = r->get_start ();
-        octave_idx_type step = r->get_step ();
+        idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
+        octave_idx_type m_start = r->get_start ();
+        octave_idx_type m_step = r->get_step ();
         octave_idx_type i, j;
-        if (step == 1)
-          for (i = start, j = start + len; i < j; i++) *data++ = i;
-        else if (step == -1)
-          for (i = start, j = start - len; i > j; i--) *data++ = i;
+        if (m_step == 1)
+          for (i = m_start, j = m_start + m_len; i < j; i++) *m_data++ = i;
+        else if (m_step == -1)
+          for (i = m_start, j = m_start - m_len; i > j; i--) *m_data++ = i;
         else
-          for (i = 0, j = start; i < len; i++, j += step) *data++ = j;
+          for (i = 0, j = m_start; i < m_len; i++, j += m_step) *m_data++ = j;
       }
       break;
 
     case class_scalar:
       {
-        idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
-        *data = r->get_data ();
+        idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
+        *m_data = r->get_data ();
       }
       break;
 
     case class_vector:
       {
-        idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+        idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
         const octave_idx_type *rdata = r->get_data ();
-        std::copy_n (rdata, len, data);
+        std::copy_n (rdata, m_len, m_data);
       }
       break;
 
     case class_mask:
       {
-        idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+        idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
         const bool *mask = r->get_data ();
-        octave_idx_type ext = r->extent (0);
-        for (octave_idx_type i = 0, j = 0; i < ext; i++)
+        octave_idx_type m_ext = r->extent (0);
+        for (octave_idx_type i = 0, j = 0; i < m_ext; i++)
           if (mask[i])
-            data[j++] = i;
+            m_data[j++] = i;
       }
       break;
 
@@ -1098,15 +1099,15 @@
 
   if (idx_class () == class_mask)
     {
-      idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+      idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
       octave_idx_type nz = r->length (0);
-      octave_idx_type ext = r->extent (0);
+      octave_idx_type m_ext = r->extent (0);
       Array<bool> mask (dim_vector (n, 1));
-      const bool *data = r->get_data ();
+      const bool *m_data = r->get_data ();
       bool *ndata = mask.fortran_vec ();
-      for (octave_idx_type i = 0; i < ext; i++)
-        ndata[i] = ! data[i];
-      std::fill_n (ndata + ext, n - ext, true);
+      for (octave_idx_type i = 0; i < m_ext; i++)
+        ndata[i] = ! m_data[i];
+      std::fill_n (ndata + m_ext, n - m_ext, true);
       retval = new idx_mask_rep (mask, n - nz);
     }
   else
@@ -1132,7 +1133,7 @@
 
       retval = true;
 
-      for (octave_idx_type i = 0, len = length (); i < len; i++)
+      for (octave_idx_type i = 0, m_len = length (); i < m_len; i++)
         {
           octave_idx_type k = xelem (i);
           if (left[k])
@@ -1167,7 +1168,7 @@
       }
     case class_vector:
       {
-        idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+        idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
         const octave_idx_type *ri = r->get_data ();
         Array<octave_idx_type> idx (orig_dimensions ());
         for (octave_idx_type i = 0; i < n; i++)
@@ -1188,19 +1189,19 @@
 {
   if (idx_class () == class_mask)
     {
-      idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
-      const bool *data = r->get_data ();
-      octave_idx_type ext = r->extent (0);
-      octave_idx_type len = r->length (0);
-      octave_idx_type *idata = new octave_idx_type [len];
+      idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
+      const bool *m_data = r->get_data ();
+      octave_idx_type m_ext = r->extent (0);
+      octave_idx_type m_len = r->length (0);
+      octave_idx_type *idata = new octave_idx_type [m_len];
 
-      for (octave_idx_type i = 0, j = 0; i < ext; i++)
-        if (data[i])
+      for (octave_idx_type i = 0, j = 0; i < m_ext; i++)
+        if (m_data[i])
           idata[j++] = i;
 
-      ext = (len > 0 ? idata[len - 1] + 1 : 0);
+      m_ext = (m_len > 0 ? idata[m_len - 1] + 1 : 0);
 
-      return new idx_vector_rep (idata, len, ext, r->orig_dimensions (),
+      return new idx_vector_rep (idata, m_len, m_ext, r->orig_dimensions (),
                                  DIRECT);
     }
   else
@@ -1219,28 +1220,28 @@
 
     case class_range:
       {
-        idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+        idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
         range = r->unconvert ();
       }
       break;
 
     case class_scalar:
       {
-        idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+        idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
         scalar = r->unconvert ();
       }
       break;
 
     case class_vector:
       {
-        idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+        idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
         array = r->unconvert ();
       }
       break;
 
     case class_mask:
       {
-        idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+        idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
         mask = r->unconvert ();
       }
       break;
@@ -1254,7 +1255,7 @@
 Array<octave_idx_type>
 idx_vector::as_array (void) const
 {
-  return rep->as_array ();
+  return m_rep->as_array ();
 }
 
 bool
--- a/liboctave/array/idx-vector.h	Wed Apr 28 10:23:41 2021 -0400
+++ b/liboctave/array/idx-vector.h	Wed Apr 28 12:55:19 2021 -0400
@@ -81,7 +81,7 @@
   {
   public:
 
-    idx_base_rep (void) : count (1) { }
+    idx_base_rep (void) : m_count (1) { }
 
     // No copying!
 
@@ -122,7 +122,7 @@
 
     virtual Array<octave_idx_type> as_array (void);
 
-    octave::refcount<octave_idx_type> count;
+    octave::refcount<octave_idx_type> m_count;
   };
 
   // The magic colon index.
@@ -151,7 +151,7 @@
     idx_class_type idx_class (void) const { return class_colon; }
 
     idx_base_rep * sort_uniq_clone (bool = false)
-    { count++; return this; }
+    { m_count++; return this; }
 
     OCTAVE_NORETURN idx_base_rep * sort_idx (Array<octave_idx_type>&);
 
@@ -170,13 +170,13 @@
 
     idx_range_rep (void) = delete;
 
-    idx_range_rep (octave_idx_type _start, octave_idx_type _len,
-                   octave_idx_type _step, direct)
-      : idx_base_rep (), start(_start), len(_len), step(_step) { }
+    idx_range_rep (octave_idx_type start, octave_idx_type len,
+                   octave_idx_type step, direct)
+      : idx_base_rep (), m_start (start), m_len (len), m_step (step) { }
 
     // Zero-based constructor.
-    idx_range_rep (octave_idx_type _start, octave_idx_type _limit,
-                   octave_idx_type _step);
+    idx_range_rep (octave_idx_type start, octave_idx_type limit,
+                   octave_idx_type step);
 
     idx_range_rep (const octave::range<double>&);
 
@@ -187,16 +187,15 @@
     idx_range_rep& operator = (const idx_range_rep& idx) = delete;
 
     octave_idx_type xelem (octave_idx_type i) const
-    { return start + i * step; }
+    { return m_start + i * m_step; }
 
     octave_idx_type checkelem (octave_idx_type i) const;
 
-    octave_idx_type length (octave_idx_type) const { return len; }
+    octave_idx_type length (octave_idx_type) const { return m_len; }
 
     octave_idx_type extent (octave_idx_type n) const
     {
-      return len ? std::max (n, start + 1 + (step < 0 ? 0 : step * (len - 1)))
-                 : n;
+      return m_len ? std::max (n, m_start + 1 + (m_step < 0 ? 0 : m_step * (m_len - 1))) : n;
     }
 
     idx_class_type idx_class (void) const { return class_range; }
@@ -206,14 +205,14 @@
     idx_base_rep * sort_idx (Array<octave_idx_type>&);
 
     bool is_colon_equiv (octave_idx_type n) const
-    { return start == 0 && step == 1 && len == n; }
+    { return m_start == 0 && m_step == 1 && m_len == n; }
 
     dim_vector orig_dimensions (void) const
-    { return dim_vector (1, len); }
+    { return dim_vector (1, m_len); }
 
-    octave_idx_type get_start (void) const { return start; }
+    octave_idx_type get_start (void) const { return m_start; }
 
-    octave_idx_type get_step (void) const { return step; }
+    octave_idx_type get_step (void) const { return m_step; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -223,7 +222,7 @@
 
   private:
 
-    octave_idx_type start, len, step;
+    octave_idx_type m_start, m_len, m_step;
   };
 
   // The integer scalar index.
@@ -233,7 +232,7 @@
 
     idx_scalar_rep (void) = delete;
 
-    idx_scalar_rep (octave_idx_type i, direct) : idx_base_rep (), data (i) { }
+    idx_scalar_rep (octave_idx_type i, direct) : idx_base_rep (), m_data (i) { }
 
     // No copying!
 
@@ -247,28 +246,28 @@
     template <typename T>
     idx_scalar_rep (T x);
 
-    octave_idx_type xelem (octave_idx_type) const { return data; }
+    octave_idx_type xelem (octave_idx_type) const { return m_data; }
 
     octave_idx_type checkelem (octave_idx_type i) const;
 
     octave_idx_type length (octave_idx_type) const { return 1; }
 
     octave_idx_type extent (octave_idx_type n) const
-    { return std::max (n, data + 1); }
+    { return std::max (n, m_data + 1); }
 
     idx_class_type idx_class (void) const { return class_scalar; }
 
     idx_base_rep * sort_uniq_clone (bool = false)
-    { count++; return this; }
+    { m_count++; return this; }
 
     idx_base_rep * sort_idx (Array<octave_idx_type>&);
 
     bool is_colon_equiv (octave_idx_type n) const
-    { return n == 1 && data == 0; }
+    { return n == 1 && m_data == 0; }
 
     dim_vector orig_dimensions (void) const { return dim_vector (1, 1); }
 
-    octave_idx_type get_data (void) const { return data; }
+    octave_idx_type get_data (void) const { return m_data; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -278,7 +277,7 @@
 
   private:
 
-    octave_idx_type data;
+    octave_idx_type m_data;
   };
 
   // The integer vector index.
@@ -287,20 +286,20 @@
   public:
 
     idx_vector_rep (void)
-      : data (nullptr), len (0), ext (0), aowner (nullptr), orig_dims () { }
+      : m_data (nullptr), m_len (0), m_ext (0), m_aowner (nullptr), m_orig_dims () { }
 
     // Direct constructor.
-    idx_vector_rep (octave_idx_type *_data, octave_idx_type _len,
-                    octave_idx_type _ext, const dim_vector& od, direct)
-      : idx_base_rep (), data (_data), len (_len), ext (_ext),
-        aowner (nullptr), orig_dims (od)
+    idx_vector_rep (octave_idx_type *data, octave_idx_type len,
+                    octave_idx_type ext, const dim_vector& od, direct)
+      : idx_base_rep (), m_data (data), m_len (len), m_ext (ext),
+        m_aowner (nullptr), m_orig_dims (od)
     { }
 
     // Zero-based constructor.
     idx_vector_rep (const Array<octave_idx_type>& inda);
 
     idx_vector_rep (const Array<octave_idx_type>& inda,
-                    octave_idx_type _ext, direct);
+                    octave_idx_type ext, direct);
 
     template <typename T>
     idx_vector_rep (const Array<T>&);
@@ -319,14 +318,14 @@
 
     ~idx_vector_rep (void);
 
-    octave_idx_type xelem (octave_idx_type i) const { return data[i]; }
+    octave_idx_type xelem (octave_idx_type i) const { return m_data[i]; }
 
     octave_idx_type checkelem (octave_idx_type i) const;
 
-    octave_idx_type length (octave_idx_type) const { return len; }
+    octave_idx_type length (octave_idx_type) const { return m_len; }
 
     octave_idx_type extent (octave_idx_type n) const
-    { return std::max (n, ext); }
+    { return std::max (n, m_ext); }
 
     idx_class_type idx_class (void) const { return class_vector; }
 
@@ -334,9 +333,9 @@
 
     idx_base_rep * sort_idx (Array<octave_idx_type>&);
 
-    dim_vector orig_dimensions (void) const { return orig_dims; }
+    dim_vector orig_dimensions (void) const { return m_orig_dims; }
 
-    const octave_idx_type * get_data (void) const { return data; }
+    const octave_idx_type * get_data (void) const { return m_data; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -346,9 +345,9 @@
 
   private:
 
-    const octave_idx_type *data;
-    octave_idx_type len;
-    octave_idx_type ext;
+    const octave_idx_type *m_data;
+    octave_idx_type m_len;
+    octave_idx_type m_ext;
 
     // This is a trick to allow user-given zero-based arrays to be used
     // as indices without copying.  If the following pointer is nonzero,
@@ -357,9 +356,9 @@
     // because we deferred the Array<T> declaration and we do not want
     // it yet to be defined.
 
-    Array<octave_idx_type> *aowner;
+    Array<octave_idx_type> *m_aowner;
 
-    dim_vector orig_dims;
+    dim_vector m_orig_dims;
   };
 
   // The logical mask index.
@@ -370,10 +369,10 @@
     idx_mask_rep (void) = delete;
 
     // Direct constructor.
-    idx_mask_rep (bool *_data, octave_idx_type _len,
-                  octave_idx_type _ext, const dim_vector& od, direct)
-      : idx_base_rep (), data (_data), len (_len), ext (_ext),
-        lsti (-1), lste (-1), aowner (nullptr), orig_dims (od)
+    idx_mask_rep (bool *data, octave_idx_type len,
+                  octave_idx_type ext, const dim_vector& od, direct)
+      : idx_base_rep (), m_data (data), m_len (len), m_ext (ext),
+        m_lsti (-1), m_lste (-1), m_aowner (nullptr), m_orig_dims (od)
     { }
 
     idx_mask_rep (bool);
@@ -392,24 +391,24 @@
 
     octave_idx_type checkelem (octave_idx_type i) const;
 
-    octave_idx_type length (octave_idx_type) const { return len; }
+    octave_idx_type length (octave_idx_type) const { return m_len; }
 
     octave_idx_type extent (octave_idx_type n) const
-    { return std::max (n, ext); }
+    { return std::max (n, m_ext); }
 
     idx_class_type idx_class (void) const { return class_mask; }
 
     idx_base_rep * sort_uniq_clone (bool = false)
-    { count++; return this; }
+    { m_count++; return this; }
 
     idx_base_rep * sort_idx (Array<octave_idx_type>&);
 
-    dim_vector orig_dimensions (void) const { return orig_dims; }
+    dim_vector orig_dimensions (void) const { return m_orig_dims; }
 
     bool is_colon_equiv (octave_idx_type n) const
-    { return len == n && ext == n; }
+    { return m_len == n && m_ext == n; }
 
-    const bool * get_data (void) const { return data; }
+    const bool * get_data (void) const { return m_data; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -419,14 +418,14 @@
 
   private:
 
-    const bool *data;
-    octave_idx_type len;
-    octave_idx_type ext;
+    const bool *m_data;
+    octave_idx_type m_len;
+    octave_idx_type m_ext;
 
     // FIXME: I'm not sure if this is a good design.  Maybe it would be
     // better to employ some sort of generalized iteration scheme.
-    mutable octave_idx_type lsti;
-    mutable octave_idx_type lste;
+    mutable octave_idx_type m_lsti;
+    mutable octave_idx_type m_lste;
 
     // This is a trick to allow user-given mask arrays to be used as
     // indices without copying.  If the following pointer is nonzero, we
@@ -435,12 +434,12 @@
     // deferred the Array<T> declaration and we do not want it yet to be
     // defined.
 
-    Array<bool> *aowner;
+    Array<bool> *m_aowner;
 
-    dim_vector orig_dims;
+    dim_vector m_orig_dims;
   };
 
-  idx_vector (idx_base_rep *r) : rep (r) { }
+  idx_vector (idx_base_rep *r) : m_rep (r) { }
 
   // The shared empty vector representation (for fast default
   // constructor).
@@ -449,19 +448,19 @@
 public:
 
   // Fast empty constructor.
-  idx_vector (void) : rep (nil_rep ()) { rep->count++; }
+  idx_vector (void) : m_rep (nil_rep ()) { m_rep->m_count++; }
 
   // Zero-based constructors (for use from C++).
-  idx_vector (octave_idx_type i) : rep (new idx_scalar_rep (i)) { }
+  idx_vector (octave_idx_type i) : m_rep (new idx_scalar_rep (i)) { }
 
 #if OCTAVE_SIZEOF_F77_INT_TYPE != OCTAVE_SIZEOF_IDX_TYPE
   idx_vector (octave_f77_int_type i)
-    : rep (new idx_scalar_rep (static_cast<octave_idx_type> (i))) { }
+    : m_rep (new idx_scalar_rep (static_cast<octave_idx_type> (i))) { }
 #endif
 
   idx_vector (octave_idx_type start, octave_idx_type limit,
               octave_idx_type step = 1)
-    : rep (new idx_range_rep (start, limit, step)) { }
+    : m_rep (new idx_range_rep (start, limit, step)) { }
 
   static idx_vector
   make_range (octave_idx_type start, octave_idx_type step,
@@ -471,105 +470,105 @@
   }
 
   idx_vector (const Array<octave_idx_type>& inda)
-    : rep (new idx_vector_rep (inda)) { }
+    : m_rep (new idx_vector_rep (inda)) { }
 
   // Directly pass extent, no checking.
   idx_vector (const Array<octave_idx_type>& inda, octave_idx_type ext)
-    : rep (new idx_vector_rep (inda, ext, DIRECT)) { }
+    : m_rep (new idx_vector_rep (inda, ext, DIRECT)) { }
 
   // Colon is best constructed by simply copying (or referencing) this member.
   static const idx_vector colon;
 
   // or passing ':' here
-  idx_vector (char c) : rep (new idx_colon_rep (c)) { }
+  idx_vector (char c) : m_rep (new idx_colon_rep (c)) { }
 
   // Conversion constructors (used by interpreter).
 
   template <typename T>
-  idx_vector (octave_int<T> x) : rep (new idx_scalar_rep (x)) { }
+  idx_vector (octave_int<T> x) : m_rep (new idx_scalar_rep (x)) { }
 
-  idx_vector (double x) : rep (new idx_scalar_rep (x)) { }
+  idx_vector (double x) : m_rep (new idx_scalar_rep (x)) { }
 
-  idx_vector (float x) : rep (new idx_scalar_rep (x)) { }
+  idx_vector (float x) : m_rep (new idx_scalar_rep (x)) { }
 
   // A scalar bool does not necessarily map to scalar index.
-  idx_vector (bool x) : rep (new idx_mask_rep (x)) { }
+  idx_vector (bool x) : m_rep (new idx_mask_rep (x)) { }
 
   template <typename T>
   idx_vector (const Array<octave_int<T>>& nda)
-    : rep (new idx_vector_rep (nda)) { }
+    : m_rep (new idx_vector_rep (nda)) { }
 
-  idx_vector (const Array<double>& nda) : rep (new idx_vector_rep (nda)) { }
+  idx_vector (const Array<double>& nda) : m_rep (new idx_vector_rep (nda)) { }
 
-  idx_vector (const Array<float>& nda) : rep (new idx_vector_rep (nda)) { }
+  idx_vector (const Array<float>& nda) : m_rep (new idx_vector_rep (nda)) { }
 
   idx_vector (const Array<bool>& nda);
 
-  idx_vector (const octave::range<double>& r) : rep (new idx_range_rep (r)) { }
+  idx_vector (const octave::range<double>& r) : m_rep (new idx_range_rep (r)) { }
 
-  idx_vector (const Sparse<bool>& nda) : rep (new idx_vector_rep (nda)) { }
+  idx_vector (const Sparse<bool>& nda) : m_rep (new idx_vector_rep (nda)) { }
 
-  idx_vector (const idx_vector& a) : rep (a.rep) { rep->count++; }
+  idx_vector (const idx_vector& a) : m_rep (a.m_rep) { m_rep->m_count++; }
 
   ~idx_vector (void)
   {
-    if (--rep->count == 0 && rep != nil_rep ())
-      delete rep;
+    if (--m_rep->m_count == 0 && m_rep != nil_rep ())
+      delete m_rep;
   }
 
   idx_vector& operator = (const idx_vector& a)
   {
     if (this != &a)
       {
-        if (--rep->count == 0 && rep != nil_rep ())
-          delete rep;
+        if (--m_rep->m_count == 0 && m_rep != nil_rep ())
+          delete m_rep;
 
-        rep = a.rep;
-        rep->count++;
+        m_rep = a.m_rep;
+        m_rep->m_count++;
       }
     return *this;
   }
 
-  idx_class_type idx_class (void) const { return rep->idx_class (); }
+  idx_class_type idx_class (void) const { return m_rep->idx_class (); }
 
   octave_idx_type length (octave_idx_type n = 0) const
-  { return rep->length (n); }
+  { return m_rep->length (n); }
 
   octave_idx_type extent (octave_idx_type n) const
-  { return rep->extent (n); }
+  { return m_rep->extent (n); }
 
   octave_idx_type xelem (octave_idx_type n) const
-  { return rep->xelem (n); }
+  { return m_rep->xelem (n); }
 
   octave_idx_type checkelem (octave_idx_type n) const
-  { return rep->xelem (n); }
+  { return m_rep->xelem (n); }
 
   octave_idx_type operator () (octave_idx_type n) const
-  { return rep->xelem (n); }
+  { return m_rep->xelem (n); }
 
   // FIXME: idx_vector objects are either created successfully or an
   // error is thrown, so this method no longer makes sense.
   operator bool (void) const { return true; }
 
   bool is_colon (void) const
-  { return rep->idx_class () == class_colon; }
+  { return m_rep->idx_class () == class_colon; }
 
   bool is_scalar (void) const
-  { return rep->idx_class () == class_scalar; }
+  { return m_rep->idx_class () == class_scalar; }
 
   bool is_range (void) const
-  { return rep->idx_class () == class_range; }
+  { return m_rep->idx_class () == class_range; }
 
   bool is_colon_equiv (octave_idx_type n) const
-  { return rep->is_colon_equiv (n); }
+  { return m_rep->is_colon_equiv (n); }
 
   idx_vector sorted (bool uniq = false) const
-  { return idx_vector (rep->sort_uniq_clone (uniq)); }
+  { return idx_vector (m_rep->sort_uniq_clone (uniq)); }
 
   idx_vector sorted (Array<octave_idx_type>& sidx) const
-  { return idx_vector (rep->sort_idx (sidx)); }
+  { return idx_vector (m_rep->sort_idx (sidx)); }
 
-  dim_vector orig_dimensions (void) const { return rep->orig_dimensions (); }
+  dim_vector orig_dimensions (void) const { return m_rep->orig_dimensions (); }
 
   octave_idx_type orig_rows (void) const
   { return orig_dimensions () (0); }
@@ -582,7 +581,7 @@
 
   // i/o
 
-  std::ostream& print (std::ostream& os) const { return rep->print (os); }
+  std::ostream& print (std::ostream& os) const { return m_rep->print (os); }
 
   friend std::ostream& operator << (std::ostream& os, const idx_vector& a)
   { return a.print (os); }
@@ -599,9 +598,9 @@
   octave_idx_type
   index (const T *src, octave_idx_type n, T *dest) const
   {
-    octave_idx_type len = rep->length (n);
+    octave_idx_type len = m_rep->length (n);
 
-    switch (rep->idx_class ())
+    switch (m_rep->idx_class ())
       {
       case class_colon:
         std::copy_n (src, len, dest);
@@ -609,7 +608,7 @@
 
       case class_range:
         {
-          idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+          idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
           octave_idx_type start = r->get_start ();
           octave_idx_type step = r->get_step ();
           const T *ssrc = src + start;
@@ -629,14 +628,14 @@
 
       case class_scalar:
         {
-          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
           dest[0] = src[r->get_data ()];
         }
         break;
 
       case class_vector:
         {
-          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
           const octave_idx_type *data = r->get_data ();
           for (octave_idx_type i = 0; i < len; i++)
             dest[i] = src[data[i]];
@@ -645,7 +644,7 @@
 
       case class_mask:
         {
-          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
           const bool *data = r->get_data ();
           octave_idx_type ext = r->extent (0);
           for (octave_idx_type i = 0; i < ext; i++)
@@ -673,9 +672,9 @@
   octave_idx_type
   assign (const T *src, octave_idx_type n, T *dest) const
   {
-    octave_idx_type len = rep->length (n);
+    octave_idx_type len = m_rep->length (n);
 
-    switch (rep->idx_class ())
+    switch (m_rep->idx_class ())
       {
       case class_colon:
         std::copy_n (src, len, dest);
@@ -683,7 +682,7 @@
 
       case class_range:
         {
-          idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+          idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
           octave_idx_type start = r->get_start ();
           octave_idx_type step = r->get_step ();
           T *sdest = dest + start;
@@ -701,14 +700,14 @@
 
       case class_scalar:
         {
-          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
           dest[r->get_data ()] = src[0];
         }
         break;
 
       case class_vector:
         {
-          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
           const octave_idx_type *data = r->get_data ();
           for (octave_idx_type i = 0; i < len; i++)
             dest[data[i]] = src[i];
@@ -717,7 +716,7 @@
 
       case class_mask:
         {
-          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
           const bool *data = r->get_data ();
           octave_idx_type ext = r->extent (0);
           for (octave_idx_type i = 0; i < ext; i++)
@@ -745,9 +744,9 @@
   octave_idx_type
   fill (const T& val, octave_idx_type n, T *dest) const
   {
-    octave_idx_type len = rep->length (n);
+    octave_idx_type len = m_rep->length (n);
 
-    switch (rep->idx_class ())
+    switch (m_rep->idx_class ())
       {
       case class_colon:
         std::fill_n (dest, len, val);
@@ -755,7 +754,7 @@
 
       case class_range:
         {
-          idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+          idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
           octave_idx_type start = r->get_start ();
           octave_idx_type step = r->get_step ();
           T *sdest = dest + start;
@@ -773,14 +772,14 @@
 
       case class_scalar:
         {
-          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
           dest[r->get_data ()] = val;
         }
         break;
 
       case class_vector:
         {
-          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
           const octave_idx_type *data = r->get_data ();
           for (octave_idx_type i = 0; i < len; i++)
             dest[data[i]] = val;
@@ -789,7 +788,7 @@
 
       case class_mask:
         {
-          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
           const bool *data = r->get_data ();
           octave_idx_type ext = r->extent (0);
           for (octave_idx_type i = 0; i < ext; i++)
@@ -815,9 +814,9 @@
   void
   loop (octave_idx_type n, Functor body) const
   {
-    octave_idx_type len = rep->length (n);
+    octave_idx_type len = m_rep->length (n);
 
-    switch (rep->idx_class ())
+    switch (m_rep->idx_class ())
       {
       case class_colon:
         for (octave_idx_type i = 0; i < len; i++) body (i);
@@ -825,7 +824,7 @@
 
       case class_range:
         {
-          idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+          idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
           octave_idx_type start = r->get_start ();
           octave_idx_type step = r->get_step ();
           octave_idx_type i, j;
@@ -840,14 +839,14 @@
 
       case class_scalar:
         {
-          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
           body (r->get_data ());
         }
         break;
 
       case class_vector:
         {
-          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
           const octave_idx_type *data = r->get_data ();
           for (octave_idx_type i = 0; i < len; i++) body (data[i]);
         }
@@ -855,7 +854,7 @@
 
       case class_mask:
         {
-          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
           const bool *data = r->get_data ();
           octave_idx_type ext = r->extent (0);
           for (octave_idx_type i = 0; i < ext; i++)
@@ -883,9 +882,9 @@
   octave_idx_type
   bloop (octave_idx_type n, Functor body) const
   {
-    octave_idx_type len = rep->length (n), ret;
+    octave_idx_type len = m_rep->length (n), ret;
 
-    switch (rep->idx_class ())
+    switch (m_rep->idx_class ())
       {
       case class_colon:
         {
@@ -897,7 +896,7 @@
 
       case class_range:
         {
-          idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
+          idx_range_rep *r = dynamic_cast<idx_range_rep *> (m_rep);
           octave_idx_type start = r->get_start ();
           octave_idx_type step = r->get_step ();
           octave_idx_type i, j;
@@ -913,14 +912,14 @@
 
       case class_scalar:
         {
-          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
+          idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (m_rep);
           ret = (body (r->get_data ()) ? 1 : 0);
         }
         break;
 
       case class_vector:
         {
-          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
+          idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (m_rep);
           const octave_idx_type *data = r->get_data ();
           octave_idx_type i;
           for (i = 0; i < len && body (data[i]); i++) ;
@@ -930,7 +929,7 @@
 
       case class_mask:
         {
-          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
+          idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (m_rep);
           const bool *data = r->get_data ();
           octave_idx_type ext = r->extent (0);
           octave_idx_type j = 0;
@@ -1023,7 +1022,7 @@
 
 private:
 
-  idx_base_rep *rep;
+  idx_base_rep *m_rep;
 
 };