--- a/libinterp/octave-value/ov-range.cc	Fri Jul 31 13:18:01 2020 -0400
+++ b/libinterp/octave-value/ov-range.cc	Tue Aug 04 10:56:14 2020 -0400
@@ -85,10 +85,10 @@
 {
   octave_base_value *retval = nullptr;
 
-  switch (range.numel ())
+  switch (m_range.numel ())
     {
     case 1:
-      retval = new octave_scalar (range.base ());
+      retval = new octave_scalar (m_range.base ());
       break;
 
     case 0:
@@ -96,7 +96,7 @@
       break;
 
     case -2:
-      retval = new octave_matrix (range.matrix_value ());
+      retval = new octave_matrix (m_range.matrix_value ());
       break;
 
     default:
@@ -146,10 +146,10 @@
         {
           idx_vector i = idx(0).index_vector ();
 
-          if (i.is_scalar () && i(0) < range.numel ())
-            retval = range.elem (i(0));
+          if (i.is_scalar () && i(0) < m_range.numel ())
+            retval = m_range.elem (i(0));
           else
-            retval = range.index (i);
+            retval = m_range.index (i);
         }
       catch (octave::index_exception& e)
         {
@@ -163,7 +163,7 @@
     }
   else
     {
-      octave_value tmp (new octave_matrix (range.matrix_value ()));
+      octave_value tmp (new octave_matrix (m_range.matrix_value ()));
 
       return tmp.index_op (idx, resize_ok);
     }
@@ -172,12 +172,12 @@
 idx_vector
 octave_range::index_vector (bool require_integers) const
 {
-  if (idx_cache)
-    return *idx_cache;
+  if (m_idx_cache)
+    return *m_idx_cache;
   else
     {
-      if (require_integers || range.all_elements_are_ints ())
-        return set_idx_cache (idx_vector (range));
+      if (require_integers || m_range.all_elements_are_ints ())
+        return set_idx_cache (idx_vector (m_range));
       else
         {
           warning_with_id ("Octave:noninteger-range-as-index",
@@ -191,7 +191,7 @@
 double
 octave_range::double_value (bool) const
 {
-  octave_idx_type nel = range.numel ();
+  octave_idx_type nel = m_range.numel ();
 
   if (nel == 0)
     err_invalid_conversion ("range", "real scalar");
@@ -199,13 +199,13 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "range", "real scalar");
 
-  return range.base ();
+  return m_range.base ();
 }
 
 float
 octave_range::float_value (bool) const
 {
-  octave_idx_type nel = range.numel ();
+  octave_idx_type nel = m_range.numel ();
 
   if (nel == 0)
     err_invalid_conversion ("range", "real scalar");
@@ -213,13 +213,13 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "range", "real scalar");
 
-  return range.base ();
+  return m_range.base ();
 }
 
 charNDArray
 octave_range::char_array_value (bool) const
 {
-  const Matrix matrix = range.matrix_value ();
+  const Matrix matrix = m_range.matrix_value ();
   charNDArray retval (dims ());
 
   octave_idx_type nel = numel ();
@@ -235,7 +235,7 @@
 {
   // FIXME: this is a potential waste of memory.
 
-  Matrix m = range.matrix_value ();
+  Matrix m = m_range.matrix_value ();
 
   return m.all (dim);
 }
@@ -245,7 +245,7 @@
 {
   // FIXME: this is a potential waste of memory.
 
-  Matrix m = range.matrix_value ();
+  Matrix m = m_range.matrix_value ();
 
   return m.any (dim);
 }
@@ -255,14 +255,14 @@
 {
   return
     (k == 0
-       ? octave_value (DiagMatrix (DiagArray2<double> (range.matrix_value ())))
-       : octave_value (range.diag (k)));
+       ? octave_value (DiagMatrix (DiagArray2<double> (m_range.matrix_value ())))
+       : octave_value (m_range.diag (k)));
 }
 
 octave_value
 octave_range::diag (octave_idx_type m, octave_idx_type n) const
 {
-  Matrix mat = range.matrix_value ();
+  Matrix mat = m_range.matrix_value ();
 
   return mat.diag (m, n);
 }
@@ -274,7 +274,7 @@
 {
   bool retval = false;
 
-  if (! range.isempty ())
+  if (! m_range.isempty ())
     {
       if (dims ().numel () > 1)
         warn_array_as_logical (dims ());
@@ -296,7 +296,7 @@
           */
 
           // FIXME: this is a waste of memory.
-          Matrix m ((range.matrix_value ().all ()).all ());
+          Matrix m ((m_range.matrix_value ().all ()).all ());
 
           retval = ! m.isempty () && m(0, 0) != 0.0;
         }
@@ -308,7 +308,7 @@
 Complex
 octave_range::complex_value (bool) const
 {
-  octave_idx_type nel = range.numel ();
+  octave_idx_type nel = m_range.numel ();
 
   if (nel == 0)
     err_invalid_conversion ("range", "complex scalar");
@@ -316,7 +316,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "range", "complex scalar");
 
-  return Complex (range.base (), 0);
+  return Complex (m_range.base (), 0);
 }
 
 FloatComplex
@@ -326,7 +326,7 @@
 
   FloatComplex retval (tmp, tmp);
 
-  octave_idx_type nel = range.numel ();
+  octave_idx_type nel = m_range.numel ();
 
   if (nel == 0)
     err_invalid_conversion ("range", "complex scalar");
@@ -334,7 +334,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "range", "complex scalar");
 
-  retval = range.base ();
+  retval = m_range.base ();
 
   return retval;
 }
@@ -342,7 +342,7 @@
 boolNDArray
 octave_range::bool_array_value (bool warn) const
 {
-  Matrix m = range.matrix_value ();
+  Matrix m = m_range.matrix_value ();
 
   if (m.any_element_is_nan ())
     octave::err_nan_to_logical_conversion ();
@@ -366,68 +366,68 @@
 octave_value
 octave_range::convert_to_str_internal (bool pad, bool force, char type) const
 {
-  octave_value tmp (range.matrix_value ());
+  octave_value tmp (m_range.matrix_value ());
   return tmp.convert_to_str (pad, force, type);
 }
 
 octave_value
 octave_range::as_double (void) const
 {
-  return range;
+  return m_range;
 }
 
 octave_value
 octave_range::as_single (void) const
 {
-  return FloatMatrix (range.matrix_value ());
+  return FloatMatrix (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_int8 (void) const
 {
-  return int8NDArray (range.matrix_value ());
+  return int8NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_int16 (void) const
 {
-  return int16NDArray (range.matrix_value ());
+  return int16NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_int32 (void) const
 {
-  return int32NDArray (range.matrix_value ());
+  return int32NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_int64 (void) const
 {
-  return int64NDArray (range.matrix_value ());
+  return int64NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_uint8 (void) const
 {
-  return uint8NDArray (range.matrix_value ());
+  return uint8NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_uint16 (void) const
 {
-  return uint16NDArray (range.matrix_value ());
+  return uint16NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_uint32 (void) const
 {
-  return uint32NDArray (range.matrix_value ());
+  return uint32NDArray (m_range.matrix_value ());
 }
 
 octave_value
 octave_range::as_uint64 (void) const
 {
-  return uint64NDArray (range.matrix_value ());
+  return uint64NDArray (m_range.matrix_value ());
 }
 
 void
@@ -440,7 +440,7 @@
 void
 octave_range::print_raw (std::ostream& os, bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, range, pr_as_read_syntax,
+  octave_print_internal (os, m_range, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -449,7 +449,7 @@
 {
   bool retval = false;
 
-  octave_idx_type n = range.numel ();
+  octave_idx_type n = m_range.numel ();
 
   indent (os);
 
@@ -471,20 +471,20 @@
 void
 octave_range::short_disp (std::ostream& os) const
 {
-  octave_idx_type len = range.numel ();
+  octave_idx_type len = m_range.numel ();
 
   if (len == 0)
     os << "[]";
   else
     {
-      os << range.base () << ':';
+      os << m_range.base () << ':';
 
       if (len > 1)
         {
-          if (range.inc () != 1)
-            os << range.inc () << ':';
+          if (m_range.inc () != 1)
+            os << m_range.inc () << ':';
 
-          os << range.limit ();
+          os << m_range.limit ();
         }
     }
 }
@@ -517,7 +517,7 @@
                             octave_idx_type, octave_idx_type j) const
 {
   std::ostringstream buf;
-  octave_print_internal (buf, fmt, range.elem (j));
+  octave_print_internal (buf, fmt, m_range.elem (j));
   return buf.str ();
 }
 
@@ -561,9 +561,9 @@
     error ("load: failed to load range constant");
 
   if (inc != 0)
-    range = Range (base, limit, inc);
+    m_range = Range (base, limit, inc);
   else
-    range = Range (base, inc, static_cast<octave_idx_type> (limit));
+    m_range = Range (base, inc, static_cast<octave_idx_type> (limit));
 
   return true;
 }
@@ -608,9 +608,9 @@
   if (swap)
     swap_bytes<8> (&inc);
   if (inc != 0)
-    range = Range (bas, lim, inc);
+    m_range = Range (bas, lim, inc);
   else
-    range = Range (bas, inc, static_cast<octave_idx_type> (lim));
+    m_range = Range (bas, inc, static_cast<octave_idx_type> (lim));
 
   return true;
 }
@@ -745,13 +745,13 @@
       octave_idx_type nel;
       if (hdf5_get_scalar_attr (data_hid, H5T_NATIVE_IDX,
                                 "OCTAVE_RANGE_NELEM", &nel))
-        range = Range (rangevals[0], rangevals[2], nel);
+        m_range = Range (rangevals[0], rangevals[2], nel);
       else
         {
           if (rangevals[2] != 0)
-            range = Range (rangevals[0], rangevals[1], rangevals[2]);
+            m_range = Range (rangevals[0], rangevals[1], rangevals[2]);
           else
-            range = Range (rangevals[0], rangevals[2],
+            m_range = Range (rangevals[0], rangevals[2],
                            static_cast<octave_idx_type> (rangevals[1]));
         }
     }
@@ -792,6 +792,6 @@
 octave_value
 octave_range::fast_elem_extract (octave_idx_type n) const
 {
-  return (n < range.numel ()) ? octave_value (range.elem (n))
-                              : octave_value ();
+  return (n < m_range.numel ()
+          ? octave_value (m_range.elem (n)) : octave_value ());
 }

--- a/libinterp/octave-value/ov-range.h	Fri Jul 31 13:18:01 2020 -0400
+++ b/libinterp/octave-value/ov-range.h	Tue Aug 04 10:56:14 2020 -0400
@@ -56,29 +56,29 @@
 public:
 
   octave_range (void)
-    : octave_base_value (), range (), idx_cache () { }
+    : octave_base_value (), m_range (), m_idx_cache () { }
 
   octave_range (double base, double limit, double inc)
-    : octave_base_value (), range (base, limit, inc), idx_cache ()
+    : octave_base_value (), m_range (base, limit, inc), m_idx_cache ()
   {
-    if (range.numel () < 0)
+    if (m_range.numel () < 0)
       error ("invalid range");
   }
 
   octave_range (const Range& r)
-    : octave_base_value (), range (r), idx_cache ()
+    : octave_base_value (), m_range (r), m_idx_cache ()
   {
-    if (range.numel () < 0 && range.numel () != -2)
+    if (m_range.numel () < 0 && m_range.numel () != -2)
       error ("invalid range");
   }
 
   octave_range (const octave_range& r)
-    : octave_base_value (), range (r.range),
-      idx_cache (r.idx_cache ? new idx_vector (*r.idx_cache) : nullptr)
+    : octave_base_value (), m_range (r.m_range),
+      m_idx_cache (r.m_idx_cache ? new idx_vector (*r.m_idx_cache) : nullptr)
   { }
 
   octave_range (const Range& r, const idx_vector& cache)
-    : octave_base_value (), range (r), idx_cache ()
+    : octave_base_value (), m_range (r), m_idx_cache ()
   {
     set_idx_cache (cache);
   }
@@ -115,11 +115,11 @@
 
   dim_vector dims (void) const
   {
-    octave_idx_type n = range.numel ();
+    octave_idx_type n = m_range.numel ();
     return dim_vector (n > 0, n);
   }
 
-  octave_idx_type nnz (void) const { return range.nnz (); }
+  octave_idx_type nnz (void) const { return m_range.nnz (); }
 
   octave_value resize (const dim_vector& dv, bool fill = false) const;
 
@@ -131,9 +131,9 @@
   octave_value permute (const Array<int>& vec, bool inv = false) const
   { return NDArray (array_value ().permute (vec, inv)); }
 
-  octave_value squeeze (void) const { return range; }
+  octave_value squeeze (void) const { return m_range; }
 
-  octave_value full_value (void) const { return range.matrix_value (); }
+  octave_value full_value (void) const { return m_range.matrix_value (); }
 
   bool is_defined (void) const { return true; }
 
@@ -150,14 +150,14 @@
   octave_value diag (octave_idx_type m, octave_idx_type n) const;
 
   octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
-  { return range.sort (dim, mode); }
+  { return m_range.sort (dim, mode); }
 
   octave_value sort (Array<octave_idx_type>& sidx, octave_idx_type dim = 0,
                      sortmode mode = ASCENDING) const
-  { return range.sort (sidx, dim, mode); }
+  { return m_range.sort (sidx, dim, mode); }
 
   sortmode issorted (sortmode mode = UNSORTED) const
-  { return range.issorted (mode); }
+  { return m_range.issorted (mode); }
 
   Array<octave_idx_type> sort_rows_idx (sortmode) const
   { return Array<octave_idx_type> (dim_vector (1, 0)); }
@@ -188,16 +188,16 @@
   { return float_value (frc_str_conv); }
 
   Matrix matrix_value (bool = false) const
-  { return range.matrix_value (); }
+  { return m_range.matrix_value (); }
 
   FloatMatrix float_matrix_value (bool = false) const
-  { return range.matrix_value (); }
+  { return m_range.matrix_value (); }
 
   NDArray array_value (bool = false) const
-  { return range.matrix_value (); }
+  { return m_range.matrix_value (); }
 
   FloatNDArray float_array_value (bool = false) const
-  { return FloatMatrix (range.matrix_value ()); }
+  { return FloatMatrix (m_range.matrix_value ()); }
 
   charNDArray char_array_value (bool = false) const;
 
@@ -230,7 +230,7 @@
   uint64_array_value (void) const { return uint64NDArray (array_value ()); }
 
   SparseMatrix sparse_matrix_value (bool = false) const
-  { return SparseMatrix (range.matrix_value ()); }
+  { return SparseMatrix (m_range.matrix_value ()); }
 
   SparseComplexMatrix sparse_complex_matrix_value (bool = false) const
   { return SparseComplexMatrix (sparse_matrix_value ()); }
@@ -242,18 +242,18 @@
   boolNDArray bool_array_value (bool warn = false) const;
 
   ComplexMatrix complex_matrix_value (bool = false) const
-  { return ComplexMatrix (range.matrix_value ()); }
+  { return ComplexMatrix (m_range.matrix_value ()); }
 
   FloatComplexMatrix float_complex_matrix_value (bool = false) const
-  { return FloatComplexMatrix (range.matrix_value ()); }
+  { return FloatComplexMatrix (m_range.matrix_value ()); }
 
   ComplexNDArray complex_array_value (bool = false) const
-  { return ComplexMatrix (range.matrix_value ()); }
+  { return ComplexMatrix (m_range.matrix_value ()); }
 
   FloatComplexNDArray float_complex_array_value (bool = false) const
-  { return FloatComplexMatrix (range.matrix_value ()); }
+  { return FloatComplexMatrix (m_range.matrix_value ()); }
 
-  Range range_value (void) const { return range; }
+  Range range_value (void) const { return m_range; }
 
   octave_value convert_to_str_internal (bool pad, bool force, char type) const;
 
@@ -318,21 +318,21 @@
 
 private:
 
-  Range range;
+  Range m_range;
 
   idx_vector set_idx_cache (const idx_vector& idx) const
   {
-    delete idx_cache;
-    idx_cache = (idx ? new idx_vector (idx) : nullptr);
+    delete m_idx_cache;
+    m_idx_cache = (idx ? new idx_vector (idx) : nullptr);
     return idx;
   }
 
   void clear_cached_info (void) const
   {
-    delete idx_cache; idx_cache = nullptr;
+    delete m_idx_cache; m_idx_cache = nullptr;
   }
 
-  mutable idx_vector *idx_cache;
+  mutable idx_vector *m_idx_cache;
 
   // No assignment.