# HG changeset patch
# User Rik <rik@octave.org>
# Date 1657502784 25200
# Node ID b3ca7f891750085dae7ea6deabad0505c1f5e914
# Parent  6308ce73bdca939c5aa4d43af84f84dfc7539fc8
maint: use "m_" prefix for member variables in class octave_base_matrix.

* ov-base-int.cc, ov-base-mat.cc, ov-base-mat.h, ov-base.h, ov-bool-mat.cc,
ov-bool-mat.h, ov-cell.cc, ov-cell.h, ov-ch-mat.cc, ov-ch-mat.h, ov-cx-mat.cc,
ov-cx-mat.h, ov-flt-cx-mat.cc, ov-flt-cx-mat.h, ov-flt-re-mat.cc,
ov-flt-re-mat.h, ov-intx.h, ov-re-mat.cc, ov-re-mat.h, ov-str-mat.cc,
ov-str-mat.h:
use "m_" prefix for member variables in class octave_base_matrix.

diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-base-int.cc
--- a/libinterp/octave-value/ov-base-int.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-base-int.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -148,9 +148,9 @@
 {
   octave_base_value *retval = nullptr;
 
-  if (this->matrix.numel () == 1)
+  if (this->m_matrix.numel () == 1)
     retval = new typename octave_value_int_traits<T>::scalar_type
-               (this->matrix (0));
+               (this->m_matrix (0));
 
   return retval;
 }
@@ -171,7 +171,7 @@
     {
       octave_quit ();
 
-      typename T::element_type tmp = this->matrix(i);
+      typename T::element_type tmp = this->m_matrix(i);
 
       typedef typename T::element_type::val_type val_type;
 
@@ -207,70 +207,70 @@
 octave_value
 octave_base_int_matrix<MT>::as_double (void) const
 {
-  return NDArray (this->matrix);
+  return NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_single (void) const
 {
-  return FloatNDArray (this->matrix);
+  return FloatNDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_int8 (void) const
 {
-  return int8NDArray (this->matrix);
+  return int8NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_int16 (void) const
 {
-  return int16NDArray (this->matrix);
+  return int16NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_int32 (void) const
 {
-  return int32NDArray (this->matrix);
+  return int32NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_int64 (void) const
 {
-  return int64NDArray (this->matrix);
+  return int64NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_uint8 (void) const
 {
-  return uint8NDArray (this->matrix);
+  return uint8NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_uint16 (void) const
 {
-  return uint16NDArray (this->matrix);
+  return uint16NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_uint32 (void) const
 {
-  return uint32NDArray (this->matrix);
+  return uint32NDArray (this->m_matrix);
 }
 
 template <typename MT>
 octave_value
 octave_base_int_matrix<MT>::as_uint64 (void) const
 {
-  return uint64NDArray (this->matrix);
+  return uint64NDArray (this->m_matrix);
 }
 
 template <typename T>
@@ -280,7 +280,7 @@
                                          octave_idx_type j) const
 {
   std::ostringstream buf;
-  octave_print_internal (buf, fmt, this->matrix(i, j));
+  octave_print_internal (buf, fmt, this->m_matrix(i, j));
   return buf.str ();
 }
 
@@ -295,7 +295,7 @@
   for (int i = 0; i < dv.ndims (); i++)
     os << ' ' << dv(i);
 
-  os << "\n" << this->matrix;
+  os << "\n" << this->m_matrix;
 
   return true;
 }
@@ -325,7 +325,7 @@
   if (! is)
     error ("load: failed to load matrix constant");
 
-  this->matrix = tmp;
+  this->m_matrix = tmp;
 
   return true;
 }
@@ -347,7 +347,7 @@
       os.write (reinterpret_cast<char *> (&tmp), 4);
     }
 
-  os.write (reinterpret_cast<const char *> (this->matrix.data ()),
+  os.write (reinterpret_cast<const char *> (this->m_matrix.data ()),
             this->byte_size ());
 
   return true;
@@ -419,7 +419,7 @@
           }
     }
 
-  this->matrix = m;
+  this->m_matrix = m;
   return true;
 }
 
@@ -466,7 +466,7 @@
     }
 
   retval = H5Dwrite (data_hid, save_type_hid, octave_H5S_ALL, octave_H5S_ALL,
-                     octave_H5P_DEFAULT, this->matrix.data ()) >= 0;
+                     octave_H5P_DEFAULT, this->m_matrix.data ()) >= 0;
 
   H5Dclose (data_hid);
   H5Sclose (space_hid);
@@ -496,7 +496,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    this->matrix.resize (dv);
+    this->m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -540,7 +540,7 @@
                octave_H5P_DEFAULT, m.fortran_vec ()) >= 0)
     {
       retval = true;
-      this->matrix = m;
+      this->m_matrix = m;
     }
 
   H5Sclose (space_id);
@@ -562,7 +562,7 @@
 octave_base_int_matrix<T>::print_raw (std::ostream& os,
                                       bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, this->matrix, pr_as_read_syntax,
+  octave_print_internal (os, this->m_matrix, pr_as_read_syntax,
                          this->current_print_indent_level ());
 }
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-base-mat.cc
--- a/libinterp/octave-value/ov-base-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-base-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -137,8 +137,8 @@
 
   octave_idx_type n_idx = idx.length ();
 
-  int nd = matrix.ndims ();
-  const MT& cmatrix = matrix;
+  int nd = m_matrix.ndims ();
+  const MT& cmatrix = m_matrix;
 
   // If we catch an indexing error in index_vector, we flag an error in
   // index k.  Ensure it is the right value before each idx_vector call.
@@ -152,7 +152,7 @@
         {
         case 0:
           warn_empty_index (type_name ());
-          retval = matrix;
+          retval = m_matrix;
           break;
 
         case 1:
@@ -163,7 +163,7 @@
             if (! resize_ok && i.is_scalar ())
               retval = cmatrix.checkelem (i(0));
             else
-              retval = MT (matrix.index (i, resize_ok));
+              retval = MT (m_matrix.index (i, resize_ok));
           }
           break;
 
@@ -178,7 +178,7 @@
             if (! resize_ok && i.is_scalar () && j.is_scalar ())
               retval = cmatrix.checkelem (i(0), j(0));
             else
-              retval = MT (matrix.index (i, j, resize_ok));
+              retval = MT (m_matrix.index (i, j, resize_ok));
           }
           break;
 
@@ -186,7 +186,7 @@
           {
             Array<octave::idx_vector> idx_vec (dim_vector (n_idx, 1));
             bool scalar_opt = n_idx == nd && ! resize_ok;
-            const dim_vector dv = matrix.dims ();
+            const dim_vector dv = m_matrix.dims ();
 
             for (k = 0; k < n_idx; k++)
               {
@@ -198,7 +198,7 @@
             if (scalar_opt)
               retval = cmatrix.checkelem (conv_to_int_array (idx_vec));
             else
-              retval = MT (matrix.index (idx_vec, resize_ok));
+              retval = MT (m_matrix.index (idx_vec, resize_ok));
           }
           break;
         }
@@ -244,7 +244,7 @@
           {
             octave::idx_vector i = idx (0).index_vector ();
 
-            matrix.assign (i, rhs);
+            m_matrix.assign (i, rhs);
           }
           break;
 
@@ -255,7 +255,7 @@
             k = 1;
             octave::idx_vector j = idx (1).index_vector ();
 
-            matrix.assign (i, j, rhs);
+            m_matrix.assign (i, j, rhs);
           }
           break;
 
@@ -266,7 +266,7 @@
             for (k = 0; k < n_idx; k++)
               idx_vec(k) = idx(k).index_vector ();
 
-            matrix.assign (idx_vec, rhs);
+            m_matrix.assign (idx_vec, rhs);
           }
           break;
         }
@@ -284,11 +284,11 @@
 
 template <typename MT>
 MatrixType
-octave_base_matrix<MT>::matrix_type (const MatrixType& _typ) const
+octave_base_matrix<MT>::matrix_type (const MatrixType& typ) const
 {
-  delete typ;
-  typ = new MatrixType (_typ);
-  return *typ;
+  delete m_typ;
+  m_typ = new MatrixType (typ);
+  return *m_typ;
 }
 
 template <typename MT>
@@ -298,7 +298,7 @@
 {
   octave_idx_type n_idx = idx.length ();
 
-  int nd = matrix.ndims ();
+  int nd = m_matrix.ndims ();
 
   MT mrhs (dim_vector (1, 1), rhs);
 
@@ -321,10 +321,10 @@
             octave::idx_vector i = idx (0).index_vector ();
 
             // optimize single scalar index.
-            if (i.is_scalar () && i(0) < matrix.numel ())
-              matrix(i(0)) = rhs;
+            if (i.is_scalar () && i(0) < m_matrix.numel ())
+              m_matrix(i(0)) = rhs;
             else
-              matrix.assign (i, mrhs);
+              m_matrix.assign (i, mrhs);
           }
           break;
 
@@ -337,10 +337,10 @@
 
             // optimize two scalar indices.
             if (i.is_scalar () && j.is_scalar () && nd == 2
-                && i(0) < matrix.rows () && j(0) < matrix.columns ())
-              matrix(i(0), j(0)) = rhs;
+                && i(0) < m_matrix.rows () && j(0) < m_matrix.columns ())
+              m_matrix(i(0), j(0)) = rhs;
             else
-              matrix.assign (i, j, mrhs);
+              m_matrix.assign (i, j, mrhs);
           }
           break;
 
@@ -348,7 +348,7 @@
           {
             Array<octave::idx_vector> idx_vec (dim_vector (n_idx, 1));
             bool scalar_opt = n_idx == nd;
-            const dim_vector dv = matrix.dims ().redim (n_idx);
+            const dim_vector dv = m_matrix.dims ().redim (n_idx);
 
             for (k = 0; k < n_idx; k++)
               {
@@ -369,10 +369,10 @@
                     j += idx_vec(i)(0) * n;
                     n *= dv (i);
                   }
-                matrix(j) = rhs;
+                m_matrix(j) = rhs;
               }
             else
-              matrix.assign (idx_vec, mrhs);
+              m_matrix.assign (idx_vec, mrhs);
           }
           break;
         }
@@ -399,7 +399,7 @@
   for (octave_idx_type i = 0; i < len; i++)
     ra_idx(i) = idx(i).index_vector ();
 
-  matrix.delete_elements (ra_idx);
+  m_matrix.delete_elements (ra_idx);
 
   // Clear cache.
   clear_cached_info ();
@@ -409,7 +409,7 @@
 octave_value
 octave_base_matrix<MT>::resize (const dim_vector& dv, bool fill) const
 {
-  MT retval (matrix);
+  MT retval (m_matrix);
   if (fill)
     retval.resize (dv, 0);
   else
@@ -423,12 +423,12 @@
 octave_base_matrix<MT>::is_true (void) const
 {
   bool retval = false;
-  dim_vector dv = matrix.dims ();
+  dim_vector dv = m_matrix.dims ();
   int nel = dv.numel ();
 
   if (nel > 0)
     {
-      MT t1 (matrix.reshape (dim_vector (nel, 1)));
+      MT t1 (m_matrix.reshape (dim_vector (nel, 1)));
 
       if (t1.any_element_is_nan ())
         octave::err_nan_to_logical_conversion ();
@@ -466,25 +466,25 @@
 octave_base_matrix<MT>::print_info (std::ostream& os,
                                     const std::string& prefix) const
 {
-  matrix.print_info (os, prefix);
+  m_matrix.print_info (os, prefix);
 }
 
 template <typename MT>
 void
 octave_base_matrix<MT>::short_disp (std::ostream& os) const
 {
-  if (matrix.isempty ())
+  if (m_matrix.isempty ())
     os << "[]";
-  else if (matrix.ndims () == 2)
+  else if (m_matrix.ndims () == 2)
     {
       // FIXME: should this be configurable?
       octave_idx_type max_elts = 10;
       octave_idx_type elts = 0;
 
-      octave_idx_type nel = matrix.numel ();
+      octave_idx_type nel = m_matrix.numel ();
 
-      octave_idx_type nr = matrix.rows ();
-      octave_idx_type nc = matrix.columns ();
+      octave_idx_type nr = m_matrix.rows ();
+      octave_idx_type nc = m_matrix.columns ();
 
       os << '[';
 
@@ -493,7 +493,7 @@
           for (octave_idx_type j = 0; j < nc; j++)
             {
               std::ostringstream buf;
-              octave_print_internal (buf, matrix(j*nr+i));
+              octave_print_internal (buf, m_matrix(j*nr+i));
               std::string tmp = buf.str ();
               std::size_t pos = tmp.find_first_not_of (' ');
               if (pos != std::string::npos)
@@ -525,7 +525,7 @@
 float_display_format
 octave_base_matrix<MT>::get_edit_display_format (void) const
 {
-  return make_format (matrix);
+  return make_format (m_matrix);
 }
 
 template <typename MT>
@@ -535,7 +535,7 @@
                                       octave_idx_type j) const
 {
   std::ostringstream buf;
-  octave_print_internal (buf, fmt, matrix(i, j));
+  octave_print_internal (buf, fmt, m_matrix(i, j));
   return buf.str ();
 }
 
@@ -543,8 +543,8 @@
 octave_value
 octave_base_matrix<MT>::fast_elem_extract (octave_idx_type n) const
 {
-  if (n < matrix.numel ())
-    return matrix(n);
+  if (n < m_matrix.numel ())
+    return m_matrix(n);
   else
     return octave_value ();
 }
@@ -554,7 +554,7 @@
 octave_base_matrix<MT>::fast_elem_insert (octave_idx_type n,
                                           const octave_value& x)
 {
-  if (n < matrix.numel ())
+  if (n < m_matrix.numel ())
     {
       // Don't use builtin_type () here to avoid an extra VM call.
       typedef typename MT::element_type ET;
@@ -563,7 +563,7 @@
         return false;
 
       // Set up the pointer to the proper place.
-      void *here = reinterpret_cast<void *> (&matrix(n));
+      void *here = reinterpret_cast<void *> (&m_matrix(n));
       // Ask x to store there if it can.
       return x.get_rep ().fast_elem_insert_self (here, btyp);
     }
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-base-mat.h
--- a/libinterp/octave-value/ov-base-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-base-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -54,31 +54,32 @@
   typedef MT object_type;
 
   octave_base_matrix (void)
-    : octave_base_value (), matrix (), typ (), idx_cache () { }
+    : octave_base_value (), m_matrix (), m_typ (), m_idx_cache () { }
 
   octave_base_matrix (const MT& m, const MatrixType& t = MatrixType ())
-    : octave_base_value (), matrix (m),
-      typ (t.is_known () ? new MatrixType (t) : nullptr), idx_cache ()
+    : octave_base_value (), m_matrix (m),
+      m_typ (t.is_known () ? new MatrixType (t) : nullptr), m_idx_cache ()
   {
-    if (matrix.ndims () == 0)
-      matrix.resize (dim_vector (0, 0));
+    if (m_matrix.ndims () == 0)
+      m_matrix.resize (dim_vector (0, 0));
   }
 
   octave_base_matrix (const octave_base_matrix& m)
-    : octave_base_value (), matrix (m.matrix),
-      typ (m.typ ? new MatrixType (*m.typ) : nullptr),
-      idx_cache (m.idx_cache ? new octave::idx_vector (*m.idx_cache) : nullptr)
+    : octave_base_value (), m_matrix (m.m_matrix),
+      m_typ (m.m_typ ? new MatrixType (*m.m_typ) : nullptr),
+      m_idx_cache (m.m_idx_cache ? new octave::idx_vector (*m.m_idx_cache)
+                                 : nullptr)
   { }
 
   ~octave_base_matrix (void) { clear_cached_info (); }
 
-  std::size_t byte_size (void) const { return matrix.byte_size (); }
+  std::size_t byte_size (void) const { return m_matrix.byte_size (); }
 
-  octave_value squeeze (void) const { return MT (matrix.squeeze ()); }
+  octave_value squeeze (void) const { return MT (m_matrix.squeeze ()); }
 
-  octave_value full_value (void) const { return matrix; }
+  octave_value full_value (void) const { return m_matrix; }
 
-  void maybe_economize (void) { matrix.maybe_economize (); }
+  void maybe_economize (void) { m_matrix.maybe_economize (); }
 
   // We don't need to override all three forms of subsref.  The using
   // declaration will avoid warnings about partially-overloaded virtual
@@ -113,48 +114,48 @@
 
   OCTINTERP_API void delete_elements (const octave_value_list& idx);
 
-  dim_vector dims (void) const { return matrix.dims (); }
+  dim_vector dims (void) const { return m_matrix.dims (); }
 
-  octave_idx_type numel (void) const { return matrix.numel (); }
+  octave_idx_type numel (void) const { return m_matrix.numel (); }
 
-  int ndims (void) const { return matrix.ndims (); }
+  int ndims (void) const { return m_matrix.ndims (); }
 
-  octave_idx_type nnz (void) const { return matrix.nnz (); }
+  octave_idx_type nnz (void) const { return m_matrix.nnz (); }
 
   octave_value reshape (const dim_vector& new_dims) const
-  { return MT (matrix.reshape (new_dims)); }
+  { return MT (m_matrix.reshape (new_dims)); }
 
   octave_value permute (const Array<int>& vec, bool inv = false) const
-  { return MT (matrix.permute (vec, inv)); }
+  { return MT (m_matrix.permute (vec, inv)); }
 
   octave_value resize (const dim_vector& dv, bool fill = false) const;
 
-  octave_value all (int dim = 0) const { return matrix.all (dim); }
-  octave_value any (int dim = 0) const { return matrix.any (dim); }
+  octave_value all (int dim = 0) const { return m_matrix.all (dim); }
+  octave_value any (int dim = 0) const { return m_matrix.any (dim); }
 
-  MatrixType matrix_type (void) const { return typ ? *typ : MatrixType (); }
+  MatrixType matrix_type (void) const { return m_typ ? *m_typ : MatrixType (); }
   MatrixType matrix_type (const MatrixType& _typ) const;
 
   octave_value diag (octave_idx_type k = 0) const
-  { return octave_value (matrix.diag (k)); }
+  { return octave_value (m_matrix.diag (k)); }
 
   octave_value diag (octave_idx_type m, octave_idx_type n) const
-  { return octave_value (matrix.diag (m, n)); }
+  { return octave_value (m_matrix.diag (m, n)); }
 
   octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
-  { return octave_value (matrix.sort (dim, mode)); }
+  { return octave_value (m_matrix.sort (dim, mode)); }
   octave_value sort (Array<octave_idx_type>& sidx, octave_idx_type dim = 0,
                      sortmode mode = ASCENDING) const
-  { return octave_value (matrix.sort (sidx, dim, mode)); }
+  { return octave_value (m_matrix.sort (sidx, dim, mode)); }
 
   sortmode issorted (sortmode mode = UNSORTED) const
-  { return matrix.issorted (mode); }
+  { return m_matrix.issorted (mode); }
 
   Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const
-  { return matrix.sort_rows_idx (mode); }
+  { return m_matrix.sort_rows_idx (mode); }
 
   sortmode is_sorted_rows (sortmode mode = UNSORTED) const
-  { return matrix.is_sorted_rows (mode); }
+  { return m_matrix.is_sorted_rows (mode); }
 
   bool is_matrix_type (void) const { return true; }
 
@@ -184,12 +185,12 @@
   MT& matrix_ref (void)
   {
     clear_cached_info ();
-    return matrix;
+    return m_matrix;
   }
 
   const MT& matrix_ref (void) const
   {
-    return matrix;
+    return m_matrix;
   }
 
   OCTINTERP_API octave_value
@@ -200,27 +201,27 @@
 
   // This function exists to support the MEX interface.
   // You should not use it anywhere else.
-  const void * mex_get_data (void) const { return matrix.data (); }
+  const void * mex_get_data (void) const { return m_matrix.data (); }
 
 protected:
 
-  MT matrix;
+  MT m_matrix;
 
   octave::idx_vector set_idx_cache (const octave::idx_vector& idx) const
   {
-    delete idx_cache;
-    idx_cache = (idx ? new octave::idx_vector (idx) : nullptr);
+    delete m_idx_cache;
+    m_idx_cache = (idx ? new octave::idx_vector (idx) : nullptr);
     return idx;
   }
 
   void clear_cached_info (void) const
   {
-    delete typ; typ = nullptr;
-    delete idx_cache; idx_cache = nullptr;
+    delete m_typ; m_typ = nullptr;
+    delete m_idx_cache; m_idx_cache = nullptr;
   }
 
-  mutable MatrixType *typ;
-  mutable octave::idx_vector *idx_cache;
+  mutable MatrixType *m_typ;
+  mutable octave::idx_vector *m_idx_cache;
 
 private:
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-base.h
--- a/libinterp/octave-value/ov-base.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-base.h	Sun Jul 10 18:26:24 2022 -0700
@@ -57,9 +57,9 @@
 
   extern OCTINTERP_API type_info& __get_type_info__ (void);
 
-  // For now just preserve the old interface and don't mark it as deprecated.  This function
-  // is currently an internal, private function.  Additional changes may be made before
-  // version 8 is finally released.
+  // For now just preserve the old interface and don't mark it as deprecated.
+  // This function is currently an internal, private function.  Additional
+  // changes may be made before version 8 is finally released.
   inline type_info& __get_type_info__ (const std::string&) { return __get_type_info__ (); }
 }
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-bool-mat.cc
--- a/libinterp/octave-value/ov-bool-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-bool-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -90,9 +90,9 @@
 {
   octave_base_value *retval = nullptr;
 
-  if (matrix.ndims () == 2)
+  if (m_matrix.ndims () == 2)
     {
-      boolMatrix bm (matrix);
+      boolMatrix bm (m_matrix);
 
       octave_idx_type nr = bm.rows ();
       octave_idx_type nc = bm.cols ();
@@ -113,7 +113,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "bool matrix", "real scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 float
@@ -125,7 +125,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "bool matrix", "real scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 Complex
@@ -137,7 +137,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "bool matrix", "complex scalar");
 
-  return Complex (matrix(0, 0), 0);
+  return Complex (m_matrix(0, 0), 0);
 }
 
 FloatComplex
@@ -153,7 +153,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "bool matrix", "complex scalar");
 
-  retval = matrix(0, 0);
+  retval = m_matrix(0, 0);
 
   return retval;
 }
@@ -169,68 +169,68 @@
 octave_value
 octave_bool_matrix::as_double (void) const
 {
-  return NDArray (matrix);
+  return NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_single (void) const
 {
-  return FloatNDArray (matrix);
+  return FloatNDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_int8 (void) const
 {
-  return int8NDArray (matrix);
+  return int8NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_int16 (void) const
 {
-  return int16NDArray (matrix);
+  return int16NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_int32 (void) const
 {
-  return int32NDArray (matrix);
+  return int32NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_int64 (void) const
 {
-  return int64NDArray (matrix);
+  return int64NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_uint8 (void) const
 {
-  return uint8NDArray (matrix);
+  return uint8NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_uint16 (void) const
 {
-  return uint16NDArray (matrix);
+  return uint16NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_uint32 (void) const
 {
-  return uint32NDArray (matrix);
+  return uint32NDArray (m_matrix);
 }
 
 octave_value
 octave_bool_matrix::as_uint64 (void) const
 {
-  return uint64NDArray (matrix);
+  return uint64NDArray (m_matrix);
 }
 
 void
 octave_bool_matrix::print_raw (std::ostream& os,
                                bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -296,7 +296,7 @@
       boolNDArray btmp (dv);
 
       if (btmp.isempty ())
-        matrix = btmp;
+        m_matrix = btmp;
       else
         {
           NDArray tmp(dv);
@@ -308,7 +308,7 @@
           for (octave_idx_type i = 0; i < btmp.numel (); i++)
             btmp.elem (i) = (tmp.elem (i) != 0.);
 
-          matrix = btmp;
+          m_matrix = btmp;
         }
     }
   else if (kw == "rows")
@@ -331,10 +331,10 @@
             for (octave_idx_type i = 0; i < nr; i++)
               btmp.elem (i, j) = (tmp.elem (i, j) != 0.);
 
-          matrix = btmp;
+          m_matrix = btmp;
         }
       else if (nr == 0 || nc == 0)
-        matrix = boolMatrix (nr, nc);
+        m_matrix = boolMatrix (nr, nc);
       else
         panic_impossible ();
     }
@@ -423,7 +423,7 @@
   bool *mtmp = m.fortran_vec ();
   for (octave_idx_type i = 0; i < nel; i++)
     mtmp[i] = (htmp[i] ? 1 : 0);
-  matrix = m;
+  m_matrix = m;
 
   return true;
 }
@@ -501,7 +501,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -551,7 +551,7 @@
       for (octave_idx_type i = 0; i < nel; i++)
         btmp.elem (i) = htmp[i];
 
-      matrix = btmp;
+      m_matrix = btmp;
     }
 
   H5Dclose (data_hid);
@@ -575,7 +575,7 @@
 
   mwSize nel = numel ();
 
-  const bool *pdata = matrix.data ();
+  const bool *pdata = m_matrix.data ();
 
   for (mwIndex i = 0; i < nel; i++)
     pd[i] = pdata[i];
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-bool-mat.h
--- a/libinterp/octave-value/ov-bool-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-bool-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -91,7 +91,8 @@
 
   octave::idx_vector index_vector (bool /* require_integers */ = false) const
   {
-    return idx_cache ? *idx_cache : set_idx_cache (octave::idx_vector (matrix));
+    return m_idx_cache ? *m_idx_cache
+                       : set_idx_cache (octave::idx_vector (m_matrix));
   }
 
   builtin_type_t builtin_type (void) const { return btyp_bool; }
@@ -105,28 +106,28 @@
   bool isnumeric (void) const { return false; }
 
   int8NDArray
-  int8_array_value (void) const { return int8NDArray (matrix); }
+  int8_array_value (void) const { return int8NDArray (m_matrix); }
 
   int16NDArray
-  int16_array_value (void) const { return int16NDArray (matrix); }
+  int16_array_value (void) const { return int16NDArray (m_matrix); }
 
   int32NDArray
-  int32_array_value (void) const { return int32NDArray (matrix); }
+  int32_array_value (void) const { return int32NDArray (m_matrix); }
 
   int64NDArray
-  int64_array_value (void) const { return int64NDArray (matrix); }
+  int64_array_value (void) const { return int64NDArray (m_matrix); }
 
   uint8NDArray
-  uint8_array_value (void) const { return uint8NDArray (matrix); }
+  uint8_array_value (void) const { return uint8NDArray (m_matrix); }
 
   uint16NDArray
-  uint16_array_value (void) const { return uint16NDArray (matrix); }
+  uint16_array_value (void) const { return uint16NDArray (m_matrix); }
 
   uint32NDArray
-  uint32_array_value (void) const { return uint32NDArray (matrix); }
+  uint32_array_value (void) const { return uint32NDArray (m_matrix); }
 
   uint64NDArray
-  uint64_array_value (void) const { return uint64NDArray (matrix); }
+  uint64_array_value (void) const { return uint64NDArray (m_matrix); }
 
   double double_value (bool = false) const;
 
@@ -136,32 +137,32 @@
   { return double_value (frc_str_conv); }
 
   Matrix matrix_value (bool = false) const
-  { return Matrix (boolMatrix (matrix)); }
+  { return Matrix (boolMatrix (m_matrix)); }
 
   FloatMatrix float_matrix_value (bool = false) const
-  { return FloatMatrix (boolMatrix (matrix)); }
+  { return FloatMatrix (boolMatrix (m_matrix)); }
 
   NDArray array_value (bool = false) const
-  { return NDArray (matrix); }
+  { return NDArray (m_matrix); }
 
   FloatNDArray float_array_value (bool = false) const
-  { return FloatNDArray (matrix); }
+  { return FloatNDArray (m_matrix); }
 
   Complex complex_value (bool = false) const;
 
   FloatComplex float_complex_value (bool = false) const;
 
   ComplexMatrix complex_matrix_value (bool = false) const
-  { return ComplexMatrix (boolMatrix (matrix)); }
+  { return ComplexMatrix (boolMatrix (m_matrix)); }
 
   FloatComplexMatrix float_complex_matrix_value (bool = false) const
-  { return FloatComplexMatrix (boolMatrix (matrix)); }
+  { return FloatComplexMatrix (boolMatrix (m_matrix)); }
 
   ComplexNDArray complex_array_value (bool = false) const
-  { return ComplexNDArray (matrix); }
+  { return ComplexNDArray (m_matrix); }
 
   FloatComplexNDArray float_complex_array_value (bool = false) const
-  { return FloatComplexNDArray (matrix); }
+  { return FloatComplexNDArray (m_matrix); }
 
   charNDArray
   char_array_value (bool = false) const
@@ -171,25 +172,25 @@
     octave_idx_type nel = numel ();
 
     for (octave_idx_type i = 0; i < nel; i++)
-      retval(i) = static_cast<char> (matrix(i));
+      retval(i) = static_cast<char> (m_matrix(i));
 
     return retval;
   }
 
   boolMatrix bool_matrix_value (bool = false) const
-  { return boolMatrix (matrix); }
+  { return boolMatrix (m_matrix); }
 
   boolNDArray bool_array_value (bool = false) const
-  { return matrix; }
+  { return m_matrix; }
 
   SparseMatrix sparse_matrix_value (bool = false) const
-  { return SparseMatrix (Matrix (boolMatrix (matrix))); }
+  { return SparseMatrix (Matrix (boolMatrix (m_matrix))); }
 
   SparseComplexMatrix sparse_complex_matrix_value (bool = false) const
-  { return SparseComplexMatrix (ComplexMatrix (boolMatrix (matrix))); }
+  { return SparseComplexMatrix (ComplexMatrix (boolMatrix (m_matrix))); }
 
   SparseBoolMatrix sparse_bool_matrix_value (bool = false) const
-  { return SparseBoolMatrix (boolMatrix (matrix)); }
+  { return SparseBoolMatrix (boolMatrix (m_matrix)); }
 
   octave_value convert_to_str_internal (bool pad, bool force, char type) const;
 
@@ -227,7 +228,7 @@
   int write (octave::stream& os, int block_size,
              oct_data_conv::data_type output_type, int skip,
              octave::mach_info::float_format flt_fmt) const
-  { return os.write (matrix, block_size, output_type, skip, flt_fmt); }
+  { return os.write (m_matrix, block_size, output_type, skip, flt_fmt); }
 
   mxArray * as_mxArray (bool interleaved) const;
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-cell.cc
--- a/libinterp/octave-value/ov-cell.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-cell.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -70,14 +70,14 @@
 octave_base_matrix<Cell>::do_index_op (const octave_value_list& idx,
                                        bool resize_ok)
 {
-  return matrix.index (idx, resize_ok);
+  return m_matrix.index (idx, resize_ok);
 }
 
 template <>
 void
 octave_base_matrix<Cell>::assign (const octave_value_list& idx, const Cell& rhs)
 {
-  matrix.assign (idx, rhs);
+  m_matrix.assign (idx, rhs);
 }
 
 template <>
@@ -87,16 +87,16 @@
 {
   // FIXME: Really?
   if (rhs.iscell ())
-    matrix.assign (idx, rhs.cell_value ());
+    m_matrix.assign (idx, rhs.cell_value ());
   else
-    matrix.assign (idx, Cell (rhs));
+    m_matrix.assign (idx, Cell (rhs));
 }
 
 template <>
 void
 octave_base_matrix<Cell>::delete_elements (const octave_value_list& idx)
 {
-  matrix.delete_elements (idx);
+  m_matrix.delete_elements (idx);
 }
 
 // FIXME: this list of specializations is becoming so long that we should
@@ -108,7 +108,7 @@
                                         octave_idx_type i,
                                         octave_idx_type j) const
 {
-  octave_value val = matrix(i, j);
+  octave_value val = m_matrix(i, j);
 
   std::string tname = val.type_name ();
   dim_vector dv = val.dims ();
@@ -120,8 +120,8 @@
 octave_value
 octave_base_matrix<Cell>::fast_elem_extract (octave_idx_type n) const
 {
-  if (n < matrix.numel ())
-    return Cell (matrix(n));
+  if (n < m_matrix.numel ())
+    return Cell (m_matrix(n));
   else
     return octave_value ();
 }
@@ -133,9 +133,9 @@
 {
   const octave_cell *xrep = dynamic_cast<const octave_cell *> (&x.get_rep ());
 
-  bool retval = xrep && xrep->matrix.numel () == 1 && n < matrix.numel ();
+  bool retval = xrep && xrep->m_matrix.numel () == 1 && n < m_matrix.numel ();
   if (retval)
-    matrix(n) = xrep->matrix(0);
+    m_matrix(n) = xrep->m_matrix(0);
 
   return retval;
 }
@@ -146,8 +146,8 @@
 
 void octave_cell::break_closure_cycles (const std::shared_ptr<octave::stack_frame>& frame)
 {
-  for (octave_idx_type i = 0; i < matrix.numel (); i++)
-    matrix(i).break_closure_cycles (frame);
+  for (octave_idx_type i = 0; i < m_matrix.numel (); i++)
+    m_matrix(i).break_closure_cycles (frame);
 }
 
 octave_value_list
@@ -306,8 +306,8 @@
 
         case '{':
           {
-            matrix.make_unique ();
-            Cell tmpc = matrix.index (idx.front (), true);
+            m_matrix.make_unique ();
+            Cell tmpc = m_matrix.index (idx.front (), true);
 
             std::list<octave_value_list> next_idx (idx);
 
@@ -435,7 +435,7 @@
     retval = true;
   else
     {
-      retval = matrix.iscellstr ();
+      retval = m_matrix.iscellstr ();
       // Allocate empty cache to mark that this is indeed a cellstr.
       if (retval)
         m_cellstr_cache.reset (new Array<std::string> ());
@@ -471,7 +471,7 @@
   std::size_t retval = 0;
 
   for (octave_idx_type i = 0; i < numel (); i++)
-    retval += matrix(i).byte_size ();
+    retval += m_matrix(i).byte_size ();
 
   return retval;
 }
@@ -567,7 +567,7 @@
 octave_value_list
 octave_cell::list_value (void) const
 {
-  return octave_value_list (matrix);
+  return octave_value_list (m_matrix);
 }
 
 string_vector
@@ -585,7 +585,7 @@
 
   for (octave_idx_type i = 0; i < nel; i++)
     {
-      string_vector s = matrix(i).string_vector_value ();
+      string_vector s = m_matrix(i).string_vector_value ();
 
       octave_idx_type s_len = s.numel ();
 
@@ -639,7 +639,7 @@
     error ("invalid conversion from cell array to array of strings");
 
   if (m_cellstr_cache->isempty ())
-    *m_cellstr_cache = matrix.cellstr_value ();
+    *m_cellstr_cache = m_matrix.cellstr_value ();
 
   return *m_cellstr_cache;
 }
@@ -659,7 +659,7 @@
 void
 octave_cell::print_raw (std::ostream& os, bool) const
 {
-  int nd = matrix.ndims ();
+  int nd = m_matrix.ndims ();
 
   if (nd == 2)
     {
@@ -683,7 +683,7 @@
                   std::ostringstream buf;
                   buf << '[' << i+1 << ',' << j+1 << ']';
 
-                  octave_value val = matrix(i, j);
+                  octave_value val = m_matrix(i, j);
 
                   val.print_with_name (os, buf.str ());
                 }
@@ -707,7 +707,7 @@
   else
     {
       indent (os);
-      dim_vector dv = matrix.dims ();
+      dim_vector dv = m_matrix.dims ();
       os << '{' << dv.str () << " Cell Array}";
       newline (os);
     }
@@ -735,7 +735,7 @@
 void
 octave_cell::short_disp (std::ostream& os) const
 {
-  os << (matrix.isempty () ? "{}" : "...");
+  os << (m_matrix.isempty () ? "{}" : "...");
 }
 
 #define CELL_ELT_TAG "<cell-element>"
@@ -844,7 +844,7 @@
       if (! is)
         error ("load: failed to load matrix constant");
 
-      matrix = tmp;
+      m_matrix = tmp;
     }
   else if (kw == "rows")
     {
@@ -880,10 +880,10 @@
           if (! is)
             error ("load: failed to load cell element");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
       else if (nr == 0 || nc == 0)
-        matrix = Cell (nr, nc);
+        m_matrix = Cell (nr, nc);
       else
         panic_impossible ();
     }
@@ -989,7 +989,7 @@
   if (! is)
     error ("load: failed to load matrix constant");
 
-  matrix = tmp;
+  m_matrix = tmp;
 
   return true;
 }
@@ -998,7 +998,7 @@
 octave_cell::mex_get_data (void) const
 {
   clear_cellstr_cache ();
-  return matrix.data ();
+  return m_matrix.data ();
 }
 
 bool
@@ -1119,7 +1119,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -1206,7 +1206,7 @@
 
   if (retval2 >= 0)
     {
-      matrix = m;
+      m_matrix = m;
       retval = true;
     }
 
@@ -1426,7 +1426,7 @@
 
   mwSize nel = numel ();
 
-  const octave_value *p = matrix.data ();
+  const octave_value *p = m_matrix.data ();
 
   for (mwIndex i = 0; i < nel; i++)
     elts[i] = new mxArray (interleaved, p[i]);
@@ -1441,7 +1441,7 @@
     {
 #define FORWARD_MAPPER(UMAP)                  \
     case umap_ ## UMAP:                       \
-      return matrix.UMAP ()
+      return m_matrix.UMAP ()
 
     FORWARD_MAPPER (xisalnum);
     FORWARD_MAPPER (xisalpha);
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-cell.h
--- a/libinterp/octave-value/ov-cell.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-cell.h	Sun Jul 10 18:26:24 2022 -0700
@@ -136,7 +136,7 @@
 
   bool is_true (void) const;
 
-  Cell cell_value (void) const { return matrix; }
+  Cell cell_value (void) const { return m_matrix; }
 
   octave_value_list list_value (void) const;
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-ch-mat.cc
--- a/libinterp/octave-value/ov-ch-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-ch-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -60,7 +60,7 @@
 octave::idx_vector
 octave_char_matrix::index_vector (bool /* require_integers */) const
 {
-  const char *p = matrix.data ();
+  const char *p = m_matrix.data ();
   if (numel () == 1 && *p == ':')
     return octave::idx_vector (':');
   else
@@ -76,7 +76,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "character matrix", "real scalar");
 
-  return static_cast<unsigned char> (matrix(0, 0));
+  return static_cast<unsigned char> (m_matrix(0, 0));
 }
 
 float
@@ -88,7 +88,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "character matrix", "real scalar");
 
-  return static_cast<unsigned char> (matrix(0, 0));
+  return static_cast<unsigned char> (m_matrix(0, 0));
 }
 
 octave_int64
@@ -102,7 +102,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "character matrix", "int64 scalar");
 
-  retval = octave_int64 (matrix(0, 0));
+  retval = octave_int64 (m_matrix(0, 0));
 
   return retval;
 }
@@ -118,7 +118,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "character matrix", "uint64 scalar");
 
-  retval = octave_uint64 (matrix(0, 0));
+  retval = octave_uint64 (m_matrix(0, 0));
 
   return retval;
 }
@@ -132,7 +132,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "character matrix", "complex scalar");
 
-  return Complex (static_cast<unsigned char> (matrix(0, 0)), 0);
+  return Complex (static_cast<unsigned char> (m_matrix(0, 0)), 0);
 }
 
 FloatComplex
@@ -148,7 +148,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "character matrix", "complex scalar");
 
-  retval = static_cast<unsigned char> (matrix(0, 0));
+  retval = static_cast<unsigned char> (m_matrix(0, 0));
 
   return retval;
 }
@@ -156,68 +156,68 @@
 octave_value
 octave_char_matrix::as_double (void) const
 {
-  return NDArray (matrix);
+  return NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_single (void) const
 {
-  return FloatNDArray (matrix);
+  return FloatNDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_int8 (void) const
 {
-  return int8NDArray (matrix);
+  return int8NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_int16 (void) const
 {
-  return int16NDArray (matrix);
+  return int16NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_int32 (void) const
 {
-  return int32NDArray (matrix);
+  return int32NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_int64 (void) const
 {
-  return int64NDArray (matrix);
+  return int64NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_uint8 (void) const
 {
-  return uint8NDArray (matrix);
+  return uint8NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_uint16 (void) const
 {
-  return uint16NDArray (matrix);
+  return uint16NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_uint32 (void) const
 {
-  return uint32NDArray (matrix);
+  return uint32NDArray (m_matrix);
 }
 
 octave_value
 octave_char_matrix::as_uint64 (void) const
 {
-  return uint64NDArray (matrix);
+  return uint64NDArray (m_matrix);
 }
 
 void
 octave_char_matrix::print_raw (std::ostream& os,
                                bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -230,7 +230,7 @@
 
   mwSize nel = numel ();
 
-  const char *pdata = matrix.data ();
+  const char *pdata = m_matrix.data ();
 
   for (mwIndex i = 0; i < nel; i++)
     pd[i] = pdata[i];
@@ -261,22 +261,22 @@
     {
 #define STRING_MAPPER(UMAP,FCN,TYPE)                                  \
     case umap_ ## UMAP:                                               \
-      return octave_value (matrix.map<TYPE, int (&) (int)> (FCN))
+      return octave_value (m_matrix.map<TYPE, int (&) (int)> (FCN))
 
     STRING_MAPPER (xisascii, xisascii, bool);
 
 #define STRING_U8_MAPPER(UMAP,FCN)                                             \
     case umap_ ## UMAP:                                                        \
       {                                                                        \
-        charNDArray in_m = matrix;                                             \
-        Array<octave_idx_type> p (dim_vector (matrix.ndims (), 1));            \
-        if (matrix.ndims () > 1)                                               \
+        charNDArray in_m = m_matrix;                                           \
+        Array<octave_idx_type> p (dim_vector (m_matrix.ndims (), 1));          \
+        if (m_matrix.ndims () > 1)                                             \
           {                                                                    \
-            for (octave_idx_type i=0; i < matrix.ndims (); i++)                \
+            for (octave_idx_type i=0; i < m_matrix.ndims (); i++)              \
               p(i) = i;                                                        \
             p(0) = 1;                                                          \
             p(1) = 0;                                                          \
-            in_m = matrix.permute (p);                                         \
+            in_m = m_matrix.permute (p);                                       \
           }                                                                    \
         boolNDArray b_array = boolNDArray (in_m.dims ());                      \
         const uint8_t *in = reinterpret_cast<const uint8_t *> (in_m.data ());  \
@@ -291,8 +291,8 @@
             b_array(i+j) = is_upper;                                           \
           i += mblen;                                                          \
         }                                                                      \
-        return octave_value ((matrix.ndims () > 1) ? b_array.permute (p, true) \
-                                                   : b_array);                 \
+        return octave_value ((m_matrix.ndims () > 1) ? b_array.permute (p, true) \
+                                                     : b_array);               \
       }
 
     STRING_U8_MAPPER (xisalnum, octave_uc_is_alnum_wrapper);
@@ -310,29 +310,29 @@
 #define STRING_U8_FCN(UMAP,U8_FCN,STD_FCN)                                     \
     case umap_ ## UMAP:                                                        \
       {                                                                        \
-        charNDArray in_m = matrix;                                             \
-        Array<octave_idx_type> p (dim_vector (matrix.ndims (), 1));            \
-        if (matrix.ndims () > 1)                                               \
+        charNDArray in_m = m_matrix;                                           \
+        Array<octave_idx_type> p (dim_vector (m_matrix.ndims (), 1));          \
+        if (m_matrix.ndims () > 1)                                             \
           {                                                                    \
-            for (octave_idx_type i=0; i < matrix.ndims (); i++)                \
+            for (octave_idx_type i=0; i < m_matrix.ndims (); i++)              \
               p(i) = i;                                                        \
             p(0) = 1;                                                          \
             p(1) = 0;                                                          \
-            in_m = matrix.permute (p);                                         \
+            in_m = m_matrix.permute (p);                                       \
           }                                                                    \
         std::size_t output_length = in_m.numel ();                             \
         charNDArray ch_array = charNDArray (in_m.dims ());                     \
         const uint8_t *in = reinterpret_cast<const uint8_t *> (in_m.data ());  \
         uint8_t *buf = reinterpret_cast<uint8_t *> (ch_array.fortran_vec ());  \
-        U8_FCN (in, matrix.numel (), nullptr, buf, &output_length);            \
-        if (output_length != static_cast<std::size_t> (matrix.numel ()))       \
+        U8_FCN (in, m_matrix.numel (), nullptr, buf, &output_length);          \
+        if (output_length != static_cast<std::size_t> (m_matrix.numel ()))     \
           {                                                                    \
             warning_with_id ("Octave:multi_byte_char_length",                  \
                              "UMAP: Possible multi-byte error.");              \
-            return octave_value (matrix.map<char, int (&) (int)> (STD_FCN));   \
+            return octave_value (m_matrix.map<char, int (&) (int)> (STD_FCN)); \
           }                                                                    \
-        return octave_value ((matrix.ndims () > 1) ? ch_array.permute (p, true)\
-                                                   : ch_array);                \
+        return octave_value ((m_matrix.ndims () > 1) ? ch_array.permute (p, true)\
+                                                     : ch_array);              \
       }
 
     STRING_U8_FCN (xtolower, octave_u8_tolower_wrapper, std::tolower);
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-ch-mat.h
--- a/libinterp/octave-value/ov-ch-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-ch-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -112,41 +112,41 @@
   octave_uint64 uint64_scalar_value () const;
 
   Matrix matrix_value (bool = false) const
-  { return Matrix (charMatrix (matrix)); }
+  { return Matrix (charMatrix (m_matrix)); }
 
   FloatMatrix float_matrix_value (bool = false) const
-  { return FloatMatrix (charMatrix (matrix)); }
+  { return FloatMatrix (charMatrix (m_matrix)); }
 
   NDArray array_value (bool = false) const
-  { return NDArray (matrix); }
+  { return NDArray (m_matrix); }
 
   FloatNDArray float_array_value (bool = false) const
-  { return FloatNDArray (matrix); }
+  { return FloatNDArray (m_matrix); }
 
   Complex complex_value (bool = false) const;
 
   FloatComplex float_complex_value (bool = false) const;
 
   ComplexMatrix complex_matrix_value (bool = false) const
-  { return ComplexMatrix (charMatrix (matrix)); }
+  { return ComplexMatrix (charMatrix (m_matrix)); }
 
   FloatComplexMatrix float_complex_matrix_value (bool = false) const
-  { return FloatComplexMatrix (charMatrix (matrix)); }
+  { return FloatComplexMatrix (charMatrix (m_matrix)); }
 
   ComplexNDArray complex_array_value (bool = false) const
-  { return ComplexNDArray (matrix); }
+  { return ComplexNDArray (m_matrix); }
 
   FloatComplexNDArray float_complex_array_value (bool = false) const
-  { return FloatComplexNDArray (matrix); }
+  { return FloatComplexNDArray (m_matrix); }
 
   charMatrix char_matrix_value (bool = false) const
-  { return charMatrix (matrix); }
+  { return charMatrix (m_matrix); }
 
   charNDArray char_array_value (bool = false) const
-  { return matrix; }
+  { return m_matrix; }
 
   octave_value convert_to_str_internal (bool, bool, char type) const
-  { return octave_value (matrix, type); }
+  { return octave_value (m_matrix, type); }
 
   octave_value as_double (void) const;
   octave_value as_single (void) const;
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-cx-mat.cc
--- a/libinterp/octave-value/ov-cx-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-cx-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -91,17 +91,17 @@
 {
   octave_base_value *retval = nullptr;
 
-  if (matrix.numel () == 1)
+  if (m_matrix.numel () == 1)
     {
-      Complex c = matrix (0);
+      Complex c = m_matrix (0);
 
       if (c.imag () == 0.0)
         retval = new octave_scalar (c.real ());
       else
         retval = new octave_complex (c);
     }
-  else if (matrix.all_elements_are_real ())
-    retval = new octave_matrix (::real (matrix));
+  else if (m_matrix.all_elements_are_real ())
+    retval = new octave_matrix (::real (m_matrix));
 
   return retval;
 }
@@ -119,7 +119,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "real scalar");
 
-  return std::real (matrix(0, 0));
+  return std::real (m_matrix(0, 0));
 }
 
 float
@@ -135,7 +135,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "real scalar");
 
-  return std::real (matrix(0, 0));
+  return std::real (m_matrix(0, 0));
 }
 
 NDArray
@@ -147,7 +147,7 @@
     warn_implicit_conversion ("Octave:imag-to-real",
                               "complex matrix", "real matrix");
 
-  retval = ::real (matrix);
+  retval = ::real (m_matrix);
 
   return retval;
 }
@@ -161,7 +161,7 @@
     warn_implicit_conversion ("Octave:imag-to-real",
                               "complex matrix", "real matrix");
 
-  retval = ::real (ComplexMatrix (matrix));
+  retval = ::real (ComplexMatrix (m_matrix));
 
   return retval;
 }
@@ -175,7 +175,7 @@
     warn_implicit_conversion ("Octave:imag-to-real",
                               "complex matrix", "real matrix");
 
-  retval = ::real (ComplexMatrix (matrix));
+  retval = ::real (ComplexMatrix (m_matrix));
 
   return retval;
 }
@@ -189,7 +189,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "complex scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 FloatComplex
@@ -205,7 +205,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "complex scalar");
 
-  retval = matrix(0, 0);
+  retval = m_matrix(0, 0);
 
   return retval;
 }
@@ -213,25 +213,25 @@
 ComplexMatrix
 octave_complex_matrix::complex_matrix_value (bool) const
 {
-  return ComplexMatrix (matrix);
+  return ComplexMatrix (m_matrix);
 }
 
 FloatComplexMatrix
 octave_complex_matrix::float_complex_matrix_value (bool) const
 {
-  return FloatComplexMatrix (ComplexMatrix (matrix));
+  return FloatComplexMatrix (ComplexMatrix (m_matrix));
 }
 
 boolNDArray
 octave_complex_matrix::bool_array_value (bool warn) const
 {
-  if (matrix.any_element_is_nan ())
+  if (m_matrix.any_element_is_nan ())
     octave::err_nan_to_logical_conversion ();
-  if (warn && (! matrix.all_elements_are_real ()
-               || real (matrix).any_element_not_one_or_zero ()))
+  if (warn && (! m_matrix.all_elements_are_real ()
+               || real (m_matrix).any_element_not_one_or_zero ()))
     warn_logical_conversion ();
 
-  return mx_el_ne (matrix, Complex (0.0));
+  return mx_el_ne (m_matrix, Complex (0.0));
 }
 
 charNDArray
@@ -248,7 +248,7 @@
       octave_idx_type nel = numel ();
 
       for (octave_idx_type i = 0; i < nel; i++)
-        retval.elem (i) = static_cast<char> (std::real (matrix.elem (i)));
+        retval.elem (i) = static_cast<char> (std::real (m_matrix.elem (i)));
     }
 
   return retval;
@@ -257,7 +257,7 @@
 FloatComplexNDArray
 octave_complex_matrix::float_complex_array_value (bool) const
 {
-  return FloatComplexNDArray (matrix);
+  return FloatComplexNDArray (m_matrix);
 }
 
 SparseMatrix
@@ -269,7 +269,7 @@
     warn_implicit_conversion ("Octave:imag-to-real",
                               "complex matrix", "real matrix");
 
-  retval = SparseMatrix (::real (ComplexMatrix (matrix)));
+  retval = SparseMatrix (::real (ComplexMatrix (m_matrix)));
 
   return retval;
 }
@@ -277,28 +277,28 @@
 SparseComplexMatrix
 octave_complex_matrix::sparse_complex_matrix_value (bool) const
 {
-  return SparseComplexMatrix (ComplexMatrix (matrix));
+  return SparseComplexMatrix (ComplexMatrix (m_matrix));
 }
 
 octave_value
 octave_complex_matrix::as_double (void) const
 {
-  return matrix;
+  return m_matrix;
 }
 
 octave_value
 octave_complex_matrix::as_single (void) const
 {
-  return FloatComplexNDArray (matrix);
+  return FloatComplexNDArray (m_matrix);
 }
 
 octave_value
 octave_complex_matrix::diag (octave_idx_type k) const
 {
   octave_value retval;
-  if (k == 0 && matrix.ndims () == 2
-      && (matrix.rows () == 1 || matrix.columns () == 1))
-    retval = ComplexDiagMatrix (DiagArray2<Complex> (matrix));
+  if (k == 0 && m_matrix.ndims () == 2
+      && (m_matrix.rows () == 1 || m_matrix.columns () == 1))
+    retval = ComplexDiagMatrix (DiagArray2<Complex> (m_matrix));
   else
     retval = octave_base_matrix<ComplexNDArray>::diag (k);
 
@@ -308,11 +308,11 @@
 octave_value
 octave_complex_matrix::diag (octave_idx_type m, octave_idx_type n) const
 {
-  if (matrix.ndims () != 2
-      || (matrix.rows () != 1 && matrix.columns () != 1))
+  if (m_matrix.ndims () != 2
+      || (m_matrix.rows () != 1 && m_matrix.columns () != 1))
     error ("diag: expecting vector argument");
 
-  ComplexMatrix mat (matrix);
+  ComplexMatrix mat (m_matrix);
 
   return mat.diag (m, n);
 }
@@ -391,7 +391,7 @@
       if (! is)
         error ("load: failed to load matrix constant");
 
-      matrix = tmp;
+      m_matrix = tmp;
     }
   else if (kw == "rows")
     {
@@ -408,10 +408,10 @@
           if (! is)
             error ("load: failed to load matrix constant");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
       else if (nr == 0 || nc == 0)
-        matrix = ComplexMatrix (nr, nc);
+        m_matrix = ComplexMatrix (nr, nc);
       else
         panic_impossible ();
     }
@@ -512,7 +512,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   else
     {
@@ -533,7 +533,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   return true;
 }
@@ -651,7 +651,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -709,7 +709,7 @@
       >= 0)
     {
       retval = true;
-      matrix = m;
+      m_matrix = m;
     }
 
   H5Tclose (complex_type);
@@ -730,7 +730,7 @@
 octave_complex_matrix::print_raw (std::ostream& os,
                                   bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -742,7 +742,7 @@
 
   mwSize nel = numel ();
 
-  const Complex *pdata = matrix.data ();
+  const Complex *pdata = m_matrix.data ();
 
   if (interleaved)
     {
@@ -777,20 +777,20 @@
     {
     // Mappers handled specially.
     case umap_real:
-      return ::real (matrix);
+      return ::real (m_matrix);
     case umap_imag:
-      return ::imag (matrix);
+      return ::imag (m_matrix);
     case umap_conj:
-      return ::conj (matrix);
+      return ::conj (m_matrix);
 
     // Special cases for Matlab compatibility.
     case umap_xtolower:
     case umap_xtoupper:
-      return matrix;
+      return m_matrix;
 
 #define ARRAY_METHOD_MAPPER(UMAP, FCN)        \
     case umap_ ## UMAP:                       \
-      return octave_value (matrix.FCN ())
+      return octave_value (m_matrix.FCN ())
 
     ARRAY_METHOD_MAPPER (abs, abs);
     ARRAY_METHOD_MAPPER (isnan, isnan);
@@ -799,7 +799,7 @@
 
 #define ARRAY_MAPPER(UMAP, TYPE, FCN)                 \
     case umap_ ## UMAP:                               \
-      return octave_value (matrix.map<TYPE> (FCN))
+      return octave_value (m_matrix.map<TYPE> (FCN))
 
     ARRAY_MAPPER (acos, Complex, octave::math::acos);
     ARRAY_MAPPER (acosh, Complex, octave::math::acosh);
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-cx-mat.h
--- a/libinterp/octave-value/ov-cx-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-cx-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -126,7 +126,7 @@
 
   FloatComplexMatrix float_complex_matrix_value (bool = false) const;
 
-  ComplexNDArray complex_array_value (bool = false) const { return matrix; }
+  ComplexNDArray complex_array_value (bool = false) const { return m_matrix; }
 
   FloatComplexNDArray float_complex_array_value (bool = false) const;
 
@@ -145,11 +145,11 @@
 
   octave_value diag (octave_idx_type m, octave_idx_type n) const;
 
-  void increment (void) { matrix += Complex (1.0); }
+  void increment (void) { m_matrix += Complex (1.0); }
 
-  void decrement (void) { matrix -= Complex (1.0); }
+  void decrement (void) { m_matrix -= Complex (1.0); }
 
-  void changesign (void) { matrix.changesign (); }
+  void changesign (void) { m_matrix.changesign (); }
 
   bool save_ascii (std::ostream& os);
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-flt-cx-mat.cc
--- a/libinterp/octave-value/ov-flt-cx-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-flt-cx-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -79,17 +79,17 @@
 {
   octave_base_value *retval = nullptr;
 
-  if (matrix.numel () == 1)
+  if (m_matrix.numel () == 1)
     {
-      FloatComplex c = matrix (0);
+      FloatComplex c = m_matrix (0);
 
       if (c.imag () == 0.0)
         retval = new octave_float_scalar (c.real ());
       else
         retval = new octave_float_complex (c);
     }
-  else if (matrix.all_elements_are_real ())
-    retval = new octave_float_matrix (::real (matrix));
+  else if (m_matrix.all_elements_are_real ())
+    retval = new octave_float_matrix (::real (m_matrix));
 
   return retval;
 }
@@ -107,7 +107,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "real scalar");
 
-  return std::real (matrix(0, 0));
+  return std::real (m_matrix(0, 0));
 }
 
 float
@@ -123,7 +123,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "real scalar");
 
-  return std::real (matrix(0, 0));
+  return std::real (m_matrix(0, 0));
 }
 
 Matrix
@@ -135,7 +135,7 @@
     warn_implicit_conversion ("Octave:imag-to-real",
                               "complex matrix", "real matrix");
 
-  retval = ::real (FloatComplexMatrix (matrix));
+  retval = ::real (FloatComplexMatrix (m_matrix));
 
   return retval;
 }
@@ -149,7 +149,7 @@
     warn_implicit_conversion ("Octave:imag-to-real",
                               "complex matrix", "real matrix");
 
-  retval = ::real (FloatComplexMatrix (matrix));
+  retval = ::real (FloatComplexMatrix (m_matrix));
 
   return retval;
 }
@@ -163,7 +163,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "complex scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 FloatComplex
@@ -179,7 +179,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "complex matrix", "complex scalar");
 
-  retval = matrix(0, 0);
+  retval = m_matrix(0, 0);
 
   return retval;
 }
@@ -187,25 +187,25 @@
 ComplexMatrix
 octave_float_complex_matrix::complex_matrix_value (bool) const
 {
-  return FloatComplexMatrix (matrix);
+  return FloatComplexMatrix (m_matrix);
 }
 
 FloatComplexMatrix
 octave_float_complex_matrix::float_complex_matrix_value (bool) const
 {
-  return FloatComplexMatrix (matrix);
+  return FloatComplexMatrix (m_matrix);
 }
 
 boolNDArray
 octave_float_complex_matrix::bool_array_value (bool warn) const
 {
-  if (matrix.any_element_is_nan ())
+  if (m_matrix.any_element_is_nan ())
     octave::err_nan_to_logical_conversion ();
-  if (warn && (! matrix.all_elements_are_real ()
-               || real (matrix).any_element_not_one_or_zero ()))
+  if (warn && (! m_matrix.all_elements_are_real ()
+               || real (m_matrix).any_element_not_one_or_zero ()))
     warn_logical_conversion ();
 
-  return mx_el_ne (matrix, FloatComplex (0.0));
+  return mx_el_ne (m_matrix, FloatComplex (0.0));
 }
 
 charNDArray
@@ -222,7 +222,7 @@
       octave_idx_type nel = numel ();
 
       for (octave_idx_type i = 0; i < nel; i++)
-        retval.elem (i) = static_cast<char> (std::real (matrix.elem (i)));
+        retval.elem (i) = static_cast<char> (std::real (m_matrix.elem (i)));
     }
 
   return retval;
@@ -231,7 +231,7 @@
 FloatComplexNDArray
 octave_float_complex_matrix::float_complex_array_value (bool) const
 {
-  return FloatComplexNDArray (matrix);
+  return FloatComplexNDArray (m_matrix);
 }
 
 SparseMatrix
@@ -257,22 +257,22 @@
 octave_value
 octave_float_complex_matrix::as_double (void) const
 {
-  return ComplexNDArray (matrix);
+  return ComplexNDArray (m_matrix);
 }
 
 octave_value
 octave_float_complex_matrix::as_single (void) const
 {
-  return matrix;
+  return m_matrix;
 }
 
 octave_value
 octave_float_complex_matrix::diag (octave_idx_type k) const
 {
   octave_value retval;
-  if (k == 0 && matrix.ndims () == 2
-      && (matrix.rows () == 1 || matrix.columns () == 1))
-    retval = FloatComplexDiagMatrix (DiagArray2<FloatComplex> (matrix));
+  if (k == 0 && m_matrix.ndims () == 2
+      && (m_matrix.rows () == 1 || m_matrix.columns () == 1))
+    retval = FloatComplexDiagMatrix (DiagArray2<FloatComplex> (m_matrix));
   else
     retval = octave_base_matrix<FloatComplexNDArray>::diag (k);
 
@@ -282,11 +282,11 @@
 octave_value
 octave_float_complex_matrix::diag (octave_idx_type m, octave_idx_type n) const
 {
-  if (matrix.ndims () != 2
-      || (matrix.rows () != 1 && matrix.columns () != 1))
+  if (m_matrix.ndims () != 2
+      || (m_matrix.rows () != 1 && m_matrix.columns () != 1))
     error ("diag: expecting vector argument");
 
-  FloatComplexMatrix mat (matrix);
+  FloatComplexMatrix mat (m_matrix);
 
   return mat.diag (m, n);
 }
@@ -366,7 +366,7 @@
       if (! is)
         error ("load: failed to load matrix constant");
 
-      matrix = tmp;
+      m_matrix = tmp;
     }
   else if (kw == "rows")
     {
@@ -383,10 +383,10 @@
           if (! is)
             error ("load: failed to load matrix constant");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
       else if (nr == 0 || nc == 0)
-        matrix = FloatComplexMatrix (nr, nc);
+        m_matrix = FloatComplexMatrix (nr, nc);
       else
         panic_impossible ();
     }
@@ -477,7 +477,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   else
     {
@@ -498,7 +498,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   return true;
 }
@@ -604,7 +604,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -662,7 +662,7 @@
       >= 0)
     {
       retval = true;
-      matrix = m;
+      m_matrix = m;
     }
 
   H5Tclose (complex_type);
@@ -683,7 +683,7 @@
 octave_float_complex_matrix::print_raw (std::ostream& os,
                                         bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -695,7 +695,7 @@
 
   mwSize nel = numel ();
 
-  const FloatComplex *pdata = matrix.data ();
+  const FloatComplex *pdata = m_matrix.data ();
 
   if (interleaved)
     {
@@ -730,20 +730,20 @@
     {
     // Mappers handled specially.
     case umap_real:
-      return ::real (matrix);
+      return ::real (m_matrix);
     case umap_imag:
-      return ::imag (matrix);
+      return ::imag (m_matrix);
     case umap_conj:
-      return ::conj (matrix);
+      return ::conj (m_matrix);
 
     // Special cases for Matlab compatibility.
     case umap_xtolower:
     case umap_xtoupper:
-      return matrix;
+      return m_matrix;
 
 #define ARRAY_METHOD_MAPPER(UMAP, FCN)        \
     case umap_ ## UMAP:                       \
-      return octave_value (matrix.FCN ())
+      return octave_value (m_matrix.FCN ())
 
     ARRAY_METHOD_MAPPER (abs, abs);
     ARRAY_METHOD_MAPPER (isnan, isnan);
@@ -752,7 +752,7 @@
 
 #define ARRAY_MAPPER(UMAP, TYPE, FCN)                 \
     case umap_ ## UMAP:                               \
-      return octave_value (matrix.map<TYPE> (FCN))
+      return octave_value (m_matrix.map<TYPE> (FCN))
 
     ARRAY_MAPPER (acos, FloatComplex, octave::math::acos);
     ARRAY_MAPPER (acosh, FloatComplex, octave::math::acosh);
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-flt-cx-mat.h
--- a/libinterp/octave-value/ov-flt-cx-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-flt-cx-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -122,7 +122,7 @@
 
   FloatComplexMatrix float_complex_matrix_value (bool = false) const;
 
-  ComplexNDArray complex_array_value (bool = false) const { return matrix; }
+  ComplexNDArray complex_array_value (bool = false) const { return m_matrix; }
 
   FloatComplexNDArray float_complex_array_value (bool = false) const;
 
@@ -141,11 +141,11 @@
 
   octave_value diag (octave_idx_type m, octave_idx_type n) const;
 
-  void increment (void) { matrix += FloatComplex (1.0); }
+  void increment (void) { m_matrix += FloatComplex (1.0); }
 
-  void decrement (void) { matrix -= FloatComplex (1.0); }
+  void decrement (void) { m_matrix -= FloatComplex (1.0); }
 
-  void changesign (void) { matrix.changesign (); }
+  void changesign (void) { m_matrix.changesign (); }
 
   bool save_ascii (std::ostream& os);
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-flt-re-mat.cc
--- a/libinterp/octave-value/ov-flt-re-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-flt-re-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -94,8 +94,8 @@
 {
   octave_base_value *retval = nullptr;
 
-  if (matrix.numel () == 1)
-    retval = new octave_float_scalar (matrix (0));
+  if (m_matrix.numel () == 1)
+    retval = new octave_float_scalar (m_matrix (0));
 
   return retval;
 }
@@ -109,7 +109,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "real scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 float
@@ -121,7 +121,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "real scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 // FIXME
@@ -129,13 +129,13 @@
 Matrix
 octave_float_matrix::matrix_value (bool) const
 {
-  return Matrix (FloatMatrix (matrix));
+  return Matrix (FloatMatrix (m_matrix));
 }
 
 FloatMatrix
 octave_float_matrix::float_matrix_value (bool) const
 {
-  return FloatMatrix (matrix);
+  return FloatMatrix (m_matrix);
 }
 
 Complex
@@ -147,7 +147,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "complex scalar");
 
-  return Complex (matrix(0, 0), 0);
+  return Complex (m_matrix(0, 0), 0);
 }
 
 FloatComplex
@@ -163,7 +163,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "complex scalar");
 
-  retval = matrix(0, 0);
+  retval = m_matrix(0, 0);
 
   return retval;
 }
@@ -173,42 +173,42 @@
 ComplexMatrix
 octave_float_matrix::complex_matrix_value (bool) const
 {
-  return ComplexMatrix (FloatMatrix (matrix));
+  return ComplexMatrix (FloatMatrix (m_matrix));
 }
 
 FloatComplexMatrix
 octave_float_matrix::float_complex_matrix_value (bool) const
 {
-  return FloatComplexMatrix (FloatMatrix (matrix));
+  return FloatComplexMatrix (FloatMatrix (m_matrix));
 }
 
 ComplexNDArray
 octave_float_matrix::complex_array_value (bool) const
 {
-  return ComplexNDArray (matrix);
+  return ComplexNDArray (m_matrix);
 }
 
 FloatComplexNDArray
 octave_float_matrix::float_complex_array_value (bool) const
 {
-  return FloatComplexNDArray (matrix);
+  return FloatComplexNDArray (m_matrix);
 }
 
 NDArray
 octave_float_matrix::array_value (bool) const
 {
-  return NDArray (matrix);
+  return NDArray (m_matrix);
 }
 
 boolNDArray
 octave_float_matrix::bool_array_value (bool warn) const
 {
-  if (matrix.any_element_is_nan ())
+  if (m_matrix.any_element_is_nan ())
     octave::err_nan_to_logical_conversion ();
-  if (warn && matrix.any_element_not_one_or_zero ())
+  if (warn && m_matrix.any_element_not_one_or_zero ())
     warn_logical_conversion ();
 
-  return boolNDArray (matrix);
+  return boolNDArray (m_matrix);
 }
 
 charNDArray
@@ -219,7 +219,7 @@
   octave_idx_type nel = numel ();
 
   for (octave_idx_type i = 0; i < nel; i++)
-    retval.elem (i) = static_cast<char> (matrix.elem (i));
+    retval.elem (i) = static_cast<char> (m_matrix.elem (i));
 
   return retval;
 }
@@ -242,70 +242,70 @@
 octave_value
 octave_float_matrix::as_double (void) const
 {
-  return NDArray (matrix);
+  return NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_single (void) const
 {
-  return FloatNDArray (matrix);
+  return FloatNDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_int8 (void) const
 {
-  return int8NDArray (matrix);
+  return int8NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_int16 (void) const
 {
-  return int16NDArray (matrix);
+  return int16NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_int32 (void) const
 {
-  return int32NDArray (matrix);
+  return int32NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_int64 (void) const
 {
-  return int64NDArray (matrix);
+  return int64NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_uint8 (void) const
 {
-  return uint8NDArray (matrix);
+  return uint8NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_uint16 (void) const
 {
-  return uint16NDArray (matrix);
+  return uint16NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_uint32 (void) const
 {
-  return uint32NDArray (matrix);
+  return uint32NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::as_uint64 (void) const
 {
-  return uint64NDArray (matrix);
+  return uint64NDArray (m_matrix);
 }
 
 octave_value
 octave_float_matrix::diag (octave_idx_type k) const
 {
   octave_value retval;
-  if (k == 0 && matrix.ndims () == 2
-      && (matrix.rows () == 1 || matrix.columns () == 1))
-    retval = FloatDiagMatrix (DiagArray2<float> (matrix));
+  if (k == 0 && m_matrix.ndims () == 2
+      && (m_matrix.rows () == 1 || m_matrix.columns () == 1))
+    retval = FloatDiagMatrix (DiagArray2<float> (m_matrix));
   else
     retval = octave_base_matrix<FloatNDArray>::diag (k);
 
@@ -315,11 +315,11 @@
 octave_value
 octave_float_matrix::diag (octave_idx_type m, octave_idx_type n) const
 {
-  if (matrix.ndims () != 2
-      || (matrix.rows () != 1 && matrix.columns () != 1))
+  if (m_matrix.ndims () != 2
+      || (m_matrix.rows () != 1 && m_matrix.columns () != 1))
     error ("diag: expecting vector argument");
 
-  FloatMatrix mat (matrix);
+  FloatMatrix mat (m_matrix);
 
   return mat.diag (m, n);
 }
@@ -339,7 +339,7 @@
     {
       octave_quit ();
 
-      float d = matrix(i);
+      float d = m_matrix(i);
 
       if (octave::math::isnan (d))
         octave::err_nan_to_character_conversion ();
@@ -442,7 +442,7 @@
       if (! is)
         error ("load: failed to load matrix constant");
 
-      matrix = tmp;
+      m_matrix = tmp;
     }
   else if (kw == "rows")
     {
@@ -459,10 +459,10 @@
           if (! is)
             error ("load: failed to load matrix constant");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
       else if (nr == 0 || nc == 0)
-        matrix = FloatMatrix (nr, nc);
+        m_matrix = FloatMatrix (nr, nc);
       else
         panic_impossible ();
     }
@@ -552,7 +552,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   else
     {
@@ -572,7 +572,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   return true;
 }
@@ -658,7 +658,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -703,7 +703,7 @@
                octave_H5P_DEFAULT, re) >= 0)
     {
       retval = true;
-      matrix = m;
+      m_matrix = m;
     }
 
   H5Sclose (space_id);
@@ -723,7 +723,7 @@
 octave_float_matrix::print_raw (std::ostream& os,
                                 bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -736,7 +736,7 @@
 
   mwSize nel = numel ();
 
-  const float *pdata = matrix.data ();
+  const float *pdata = m_matrix.data ();
 
   for (mwIndex i = 0; i < nel; i++)
     pd[i] = pdata[i];
@@ -789,16 +789,16 @@
   switch (umap)
     {
     case umap_imag:
-      return FloatNDArray (matrix.dims (), 0.0);
+      return FloatNDArray (m_matrix.dims (), 0.0);
 
     case umap_real:
     case umap_conj:
-      return matrix;
+      return m_matrix;
 
     // Mappers handled specially.
 #define ARRAY_METHOD_MAPPER(UMAP, FCN)        \
     case umap_ ## UMAP:                       \
-      return octave_value (matrix.FCN ())
+      return octave_value (m_matrix.FCN ())
 
     ARRAY_METHOD_MAPPER (abs, abs);
     ARRAY_METHOD_MAPPER (isnan, isnan);
@@ -807,11 +807,11 @@
 
 #define ARRAY_MAPPER(UMAP, TYPE, FCN)                 \
     case umap_ ## UMAP:                               \
-      return octave_value (matrix.map<TYPE> (FCN))
+      return octave_value (m_matrix.map<TYPE> (FCN))
 
 #define RC_ARRAY_MAPPER(UMAP, TYPE, FCN)      \
     case umap_ ## UMAP:                       \
-      return do_rc_map (matrix, FCN)
+      return do_rc_map (m_matrix, FCN)
 
     RC_ARRAY_MAPPER (acos, FloatComplex, octave::math::rc_acos);
     RC_ARRAY_MAPPER (acosh, FloatComplex, octave::math::rc_acosh);
@@ -856,7 +856,7 @@
     // Special cases for Matlab compatibility.
     case umap_xtolower:
     case umap_xtoupper:
-      return matrix;
+      return m_matrix;
 
     case umap_xisalnum:
     case umap_xisalpha:
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-flt-re-mat.h
--- a/libinterp/octave-value/ov-flt-re-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-flt-re-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -92,7 +92,8 @@
 
   octave::idx_vector index_vector (bool /* require_integers */ = false) const
   {
-    return idx_cache ? *idx_cache : set_idx_cache (octave::idx_vector (matrix));
+    return m_idx_cache ? *m_idx_cache
+                       : set_idx_cache (octave::idx_vector (m_matrix));
   }
 
   builtin_type_t builtin_type (void) const { return btyp_float; }
@@ -106,28 +107,28 @@
   bool isfloat (void) const { return true; }
 
   int8NDArray
-  int8_array_value (void) const { return int8NDArray (matrix); }
+  int8_array_value (void) const { return int8NDArray (m_matrix); }
 
   int16NDArray
-  int16_array_value (void) const { return int16NDArray (matrix); }
+  int16_array_value (void) const { return int16NDArray (m_matrix); }
 
   int32NDArray
-  int32_array_value (void) const { return int32NDArray (matrix); }
+  int32_array_value (void) const { return int32NDArray (m_matrix); }
 
   int64NDArray
-  int64_array_value (void) const { return int64NDArray (matrix); }
+  int64_array_value (void) const { return int64NDArray (m_matrix); }
 
   uint8NDArray
-  uint8_array_value (void) const { return uint8NDArray (matrix); }
+  uint8_array_value (void) const { return uint8NDArray (m_matrix); }
 
   uint16NDArray
-  uint16_array_value (void) const { return uint16NDArray (matrix); }
+  uint16_array_value (void) const { return uint16NDArray (m_matrix); }
 
   uint32NDArray
-  uint32_array_value (void) const { return uint32NDArray (matrix); }
+  uint32_array_value (void) const { return uint32NDArray (m_matrix); }
 
   uint64NDArray
-  uint64_array_value (void) const { return uint64NDArray (matrix); }
+  uint64_array_value (void) const { return uint64NDArray (m_matrix); }
 
   double double_value (bool = false) const;
 
@@ -161,7 +162,7 @@
 
   NDArray array_value (bool = false) const;
 
-  FloatNDArray float_array_value (bool = false) const { return matrix; }
+  FloatNDArray float_array_value (bool = false) const { return m_matrix; }
 
   SparseMatrix sparse_matrix_value (bool = false) const;
 
@@ -211,7 +212,7 @@
   int write (octave::stream& os, int block_size,
              oct_data_conv::data_type output_type, int skip,
              octave::mach_info::float_format flt_fmt) const
-  { return os.write (matrix, block_size, output_type, skip, flt_fmt); }
+  { return os.write (m_matrix, block_size, output_type, skip, flt_fmt); }
 
   mxArray * as_mxArray (bool interleaved) const;
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-intx.h
--- a/libinterp/octave-value/ov-intx.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-intx.h	Sun Jul 10 18:26:24 2022 -0700
@@ -83,28 +83,28 @@
 public:
 
   int8NDArray
-  int8_array_value (void) const { return int8NDArray (matrix); }
+  int8_array_value (void) const { return int8NDArray (m_matrix); }
 
   int16NDArray
-  int16_array_value (void) const { return int16NDArray (matrix); }
+  int16_array_value (void) const { return int16NDArray (m_matrix); }
 
   int32NDArray
-  int32_array_value (void) const { return int32NDArray (matrix); }
+  int32_array_value (void) const { return int32NDArray (m_matrix); }
 
   int64NDArray
-  int64_array_value (void) const { return int64NDArray (matrix); }
+  int64_array_value (void) const { return int64NDArray (m_matrix); }
 
   uint8NDArray
-  uint8_array_value (void) const { return uint8NDArray (matrix); }
+  uint8_array_value (void) const { return uint8NDArray (m_matrix); }
 
   uint16NDArray
-  uint16_array_value (void) const { return uint16NDArray (matrix); }
+  uint16_array_value (void) const { return uint16NDArray (m_matrix); }
 
   uint32NDArray
-  uint32_array_value (void) const { return uint32NDArray (matrix); }
+  uint32_array_value (void) const { return uint32NDArray (m_matrix); }
 
   uint64NDArray
-  uint64_array_value (void) const { return uint64NDArray (matrix); }
+  uint64_array_value (void) const { return uint64NDArray (m_matrix); }
 
   double
   double_value (bool = false) const
@@ -117,7 +117,7 @@
     warn_implicit_conversion ("Octave:array-to-scalar",
                               type_name (), "real scalar");
 
-    retval = matrix(0).double_value ();
+    retval = m_matrix(0).double_value ();
 
     return retval;
   }
@@ -133,7 +133,7 @@
     warn_implicit_conversion ("Octave:array-to-scalar",
                               type_name (), "real scalar");
 
-    retval = matrix(0).float_value ();
+    retval = m_matrix(0).float_value ();
 
     return retval;
   }
@@ -152,9 +152,9 @@
 
     retval = Matrix (dv(0), dv(1));
     double *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = matrix(i).double_value ();
+      vec[i] = m_matrix(i).double_value ();
 
     return retval;
   }
@@ -169,9 +169,9 @@
 
     retval = FloatMatrix (dv(0), dv(1));
     float *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = matrix(i).float_value ();
+      vec[i] = m_matrix(i).float_value ();
 
     return retval;
   }
@@ -186,9 +186,9 @@
 
     retval = ComplexMatrix (dv(0), dv(1));
     Complex *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = Complex (matrix(i).double_value ());
+      vec[i] = Complex (m_matrix(i).double_value ());
 
     return retval;
   }
@@ -203,9 +203,9 @@
 
     retval = FloatComplexMatrix (dv(0), dv(1));
     FloatComplex *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = FloatComplex (matrix(i).float_value ());
+      vec[i] = FloatComplex (m_matrix(i).float_value ());
 
     return retval;
   }
@@ -213,44 +213,44 @@
   NDArray
   array_value (bool = false) const
   {
-    NDArray retval (matrix.dims ());
+    NDArray retval (m_matrix.dims ());
     double *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = matrix(i).double_value ();
+      vec[i] = m_matrix(i).double_value ();
     return retval;
   }
 
   FloatNDArray
   float_array_value (bool = false) const
   {
-    FloatNDArray retval (matrix.dims ());
+    FloatNDArray retval (m_matrix.dims ());
     float *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = matrix(i).float_value ();
+      vec[i] = m_matrix(i).float_value ();
     return retval;
   }
 
   ComplexNDArray
   complex_array_value (bool = false) const
   {
-    ComplexNDArray retval (matrix.dims ());
+    ComplexNDArray retval (m_matrix.dims ());
     Complex *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = Complex (matrix(i).double_value ());
+      vec[i] = Complex (m_matrix(i).double_value ());
     return retval;
   }
 
   FloatComplexNDArray
   float_complex_array_value (bool = false) const
   {
-    FloatComplexNDArray retval (matrix.dims ());
+    FloatComplexNDArray retval (m_matrix.dims ());
     FloatComplex *vec = retval.fortran_vec ();
-    octave_idx_type nel = matrix.numel ();
+    octave_idx_type nel = m_matrix.numel ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = FloatComplex (matrix(i).float_value ());
+      vec[i] = FloatComplex (m_matrix(i).float_value ());
     return retval;
   }
 
@@ -261,12 +261,12 @@
 
     octave_idx_type nel = numel ();
 
-    if (warn && matrix.any_element_not_one_or_zero ())
+    if (warn && m_matrix.any_element_not_one_or_zero ())
       warn_logical_conversion ();
 
     bool *vec = retval.fortran_vec ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = matrix(i).bool_value ();
+      vec[i] = m_matrix(i).bool_value ();
 
     return retval;
   }
@@ -280,7 +280,7 @@
 
     char *vec = retval.fortran_vec ();
     for (octave_idx_type i = 0; i < nel; i++)
-      vec[i] = matrix(i).char_value ();
+      vec[i] = m_matrix(i).char_value ();
 
     return retval;
   }
@@ -303,13 +303,14 @@
 
   octave::idx_vector index_vector (bool /* require_integers */ = false) const
   {
-    return idx_cache ? *idx_cache : set_idx_cache (octave::idx_vector (matrix));
+    return m_idx_cache ? *m_idx_cache
+                       : set_idx_cache (octave::idx_vector (m_matrix));
   }
 
   int write (octave::stream& os, int block_size,
              oct_data_conv::data_type output_type, int skip,
              octave::mach_info::float_format flt_fmt) const
-  { return os.write (matrix, block_size, output_type, skip, flt_fmt); }
+  { return os.write (m_matrix, block_size, output_type, skip, flt_fmt); }
 
   mxArray * as_mxArray (bool interleaved) const
   {
@@ -321,7 +322,7 @@
 
     mwSize nel = numel ();
 
-    const OCTAVE_INT_T *pdata = matrix.data ();
+    const OCTAVE_INT_T *pdata = m_matrix.data ();
 
     for (mwIndex i = 0; i < nel; i++)
       pd[i] = pdata[i].value ();
@@ -334,29 +335,29 @@
     switch (umap)
       {
       case umap_abs:
-        return matrix.abs ();
+        return m_matrix.abs ();
       case umap_signum:
-        return matrix.signum ();
+        return m_matrix.signum ();
       case umap_ceil:
       case umap_conj:
       case umap_fix:
       case umap_floor:
       case umap_real:
       case umap_round:
-        return matrix;
+        return m_matrix;
       case umap_imag:
-        return intNDArray<OCTAVE_INT_T> (matrix.dims (), OCTAVE_INT_T ());
+        return intNDArray<OCTAVE_INT_T> (m_matrix.dims (), OCTAVE_INT_T ());
       case umap_isnan:
       case umap_isna:
       case umap_isinf:
-        return boolNDArray (matrix.dims (), false);
+        return boolNDArray (m_matrix.dims (), false);
       case umap_isfinite:
-        return boolNDArray (matrix.dims (), true);
+        return boolNDArray (m_matrix.dims (), true);
 
       // Special cases for Matlab compatibility.
       case umap_xtolower:
       case umap_xtoupper:
-        return matrix;
+        return m_matrix;
 
       default:
         {
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-re-mat.cc
--- a/libinterp/octave-value/ov-re-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-re-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -110,8 +110,8 @@
 {
   octave_base_value *retval = nullptr;
 
-  if (matrix.numel () == 1)
-    retval = new octave_scalar (matrix (0));
+  if (m_matrix.numel () == 1)
+    retval = new octave_scalar (m_matrix (0));
 
   return retval;
 }
@@ -125,7 +125,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "real scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 float
@@ -137,7 +137,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "real scalar");
 
-  return matrix(0, 0);
+  return m_matrix(0, 0);
 }
 
 // FIXME
@@ -145,13 +145,13 @@
 Matrix
 octave_matrix::matrix_value (bool) const
 {
-  return Matrix (matrix);
+  return Matrix (m_matrix);
 }
 
 FloatMatrix
 octave_matrix::float_matrix_value (bool) const
 {
-  return FloatMatrix (Matrix (matrix));
+  return FloatMatrix (Matrix (m_matrix));
 }
 
 Complex
@@ -163,7 +163,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "complex scalar");
 
-  return Complex (matrix(0, 0), 0);
+  return Complex (m_matrix(0, 0), 0);
 }
 
 FloatComplex
@@ -179,7 +179,7 @@
   warn_implicit_conversion ("Octave:array-to-scalar",
                             "real matrix", "complex scalar");
 
-  retval = matrix(0, 0);
+  retval = m_matrix(0, 0);
 
   return retval;
 }
@@ -189,36 +189,36 @@
 ComplexMatrix
 octave_matrix::complex_matrix_value (bool) const
 {
-  return ComplexMatrix (Matrix (matrix));
+  return ComplexMatrix (Matrix (m_matrix));
 }
 
 FloatComplexMatrix
 octave_matrix::float_complex_matrix_value (bool) const
 {
-  return FloatComplexMatrix (Matrix (matrix));
+  return FloatComplexMatrix (Matrix (m_matrix));
 }
 
 ComplexNDArray
 octave_matrix::complex_array_value (bool) const
 {
-  return ComplexNDArray (matrix);
+  return ComplexNDArray (m_matrix);
 }
 
 FloatComplexNDArray
 octave_matrix::float_complex_array_value (bool) const
 {
-  return FloatComplexNDArray (matrix);
+  return FloatComplexNDArray (m_matrix);
 }
 
 boolNDArray
 octave_matrix::bool_array_value (bool warn) const
 {
-  if (matrix.any_element_is_nan ())
+  if (m_matrix.any_element_is_nan ())
     octave::err_nan_to_logical_conversion ();
-  if (warn && matrix.any_element_not_one_or_zero ())
+  if (warn && m_matrix.any_element_not_one_or_zero ())
     warn_logical_conversion ();
 
-  return boolNDArray (matrix);
+  return boolNDArray (m_matrix);
 }
 
 charNDArray
@@ -229,7 +229,7 @@
   octave_idx_type nel = numel ();
 
   for (octave_idx_type i = 0; i < nel; i++)
-    retval.elem (i) = static_cast<char> (matrix.elem (i));
+    retval.elem (i) = static_cast<char> (m_matrix.elem (i));
 
   return retval;
 }
@@ -237,7 +237,7 @@
 SparseMatrix
 octave_matrix::sparse_matrix_value (bool) const
 {
-  return SparseMatrix (Matrix (matrix));
+  return SparseMatrix (Matrix (m_matrix));
 }
 
 SparseComplexMatrix
@@ -252,70 +252,70 @@
 octave_value
 octave_matrix::as_double (void) const
 {
-  return NDArray (matrix);
+  return NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_single (void) const
 {
-  return FloatNDArray (matrix);
+  return FloatNDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_int8 (void) const
 {
-  return int8NDArray (matrix);
+  return int8NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_int16 (void) const
 {
-  return int16NDArray (matrix);
+  return int16NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_int32 (void) const
 {
-  return int32NDArray (matrix);
+  return int32NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_int64 (void) const
 {
-  return int64NDArray (matrix);
+  return int64NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_uint8 (void) const
 {
-  return uint8NDArray (matrix);
+  return uint8NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_uint16 (void) const
 {
-  return uint16NDArray (matrix);
+  return uint16NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_uint32 (void) const
 {
-  return uint32NDArray (matrix);
+  return uint32NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::as_uint64 (void) const
 {
-  return uint64NDArray (matrix);
+  return uint64NDArray (m_matrix);
 }
 
 octave_value
 octave_matrix::diag (octave_idx_type k) const
 {
   octave_value retval;
-  if (k == 0 && matrix.ndims () == 2
-      && (matrix.rows () == 1 || matrix.columns () == 1))
-    retval = DiagMatrix (DiagArray2<double> (matrix));
+  if (k == 0 && m_matrix.ndims () == 2
+      && (m_matrix.rows () == 1 || m_matrix.columns () == 1))
+    retval = DiagMatrix (DiagArray2<double> (m_matrix));
   else
     retval = octave_base_matrix<NDArray>::diag (k);
 
@@ -325,11 +325,11 @@
 octave_value
 octave_matrix::diag (octave_idx_type m, octave_idx_type n) const
 {
-  if (matrix.ndims () != 2
-      || (matrix.rows () != 1 && matrix.columns () != 1))
+  if (m_matrix.ndims () != 2
+      || (m_matrix.rows () != 1 && m_matrix.columns () != 1))
     error ("diag: expecting vector argument");
 
-  Matrix mat (matrix);
+  Matrix mat (m_matrix);
 
   return mat.diag (m, n);
 }
@@ -339,11 +339,11 @@
 octave_value
 octave_matrix::reshape (const dim_vector& new_dims) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
-      return new octave_matrix (matrix.reshape (new_dims),
-                                octave::idx_vector (idx_cache->as_array ().reshape (new_dims),
-                                                    idx_cache->extent (0)));
+      return new octave_matrix (m_matrix.reshape (new_dims),
+                                octave::idx_vector (m_idx_cache->as_array ().reshape (new_dims),
+                                                    m_idx_cache->extent (0)));
     }
   else
     return octave_base_matrix<NDArray>::reshape (new_dims);
@@ -352,11 +352,11 @@
 octave_value
 octave_matrix::squeeze (void) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
-      return new octave_matrix (matrix.squeeze (),
-                                octave::idx_vector (idx_cache->as_array ().squeeze (),
-                                                    idx_cache->extent (0)));
+      return new octave_matrix (m_matrix.squeeze (),
+                                octave::idx_vector (m_idx_cache->as_array ().squeeze (),
+                                                    m_idx_cache->extent (0)));
     }
   else
     return octave_base_matrix<NDArray>::squeeze ();
@@ -365,11 +365,11 @@
 octave_value
 octave_matrix::sort (octave_idx_type dim, sortmode mode) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
       // This is a valid index matrix, so sort via integers because it's
       // generally more efficient.
-      return octave_lazy_index (*idx_cache).sort (dim, mode);
+      return octave_lazy_index (*m_idx_cache).sort (dim, mode);
     }
   else
     return octave_base_matrix<NDArray>::sort (dim, mode);
@@ -379,11 +379,11 @@
 octave_matrix::sort (Array<octave_idx_type>& sidx, octave_idx_type dim,
                      sortmode mode) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
       // This is a valid index matrix, so sort via integers because it's
       // generally more efficient.
-      return octave_lazy_index (*idx_cache).sort (sidx, dim, mode);
+      return octave_lazy_index (*m_idx_cache).sort (sidx, dim, mode);
     }
   else
     return octave_base_matrix<NDArray>::sort (sidx, dim, mode);
@@ -392,11 +392,11 @@
 sortmode
 octave_matrix::issorted (sortmode mode) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
       // This is a valid index matrix, so check via integers because it's
       // generally more efficient.
-      return idx_cache->as_array ().issorted (mode);
+      return m_idx_cache->as_array ().issorted (mode);
     }
   else
     return octave_base_matrix<NDArray>::issorted (mode);
@@ -404,11 +404,11 @@
 Array<octave_idx_type>
 octave_matrix::sort_rows_idx (sortmode mode) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
       // This is a valid index matrix, so sort via integers because it's
       // generally more efficient.
-      return octave_lazy_index (*idx_cache).sort_rows_idx (mode);
+      return octave_lazy_index (*m_idx_cache).sort_rows_idx (mode);
     }
   else
     return octave_base_matrix<NDArray>::sort_rows_idx (mode);
@@ -417,11 +417,11 @@
 sortmode
 octave_matrix::is_sorted_rows (sortmode mode) const
 {
-  if (idx_cache)
+  if (m_idx_cache)
     {
       // This is a valid index matrix, so check via integers because it's
       // generally more efficient.
-      return idx_cache->as_array ().is_sorted_rows (mode);
+      return m_idx_cache->as_array ().is_sorted_rows (mode);
     }
   else
     return octave_base_matrix<NDArray>::is_sorted_rows (mode);
@@ -442,7 +442,7 @@
     {
       octave_quit ();
 
-      double d = matrix(i);
+      double d = m_matrix(i);
 
       if (octave::math::isnan (d))
         octave::err_nan_to_character_conversion ();
@@ -545,7 +545,7 @@
       if (! is)
         error ("load: failed to load matrix constant");
 
-      matrix = tmp;
+      m_matrix = tmp;
     }
   else if (kw == "rows")
     {
@@ -562,10 +562,10 @@
           if (! is)
             error ("load: failed to load matrix constant");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
       else if (nr == 0 || nc == 0)
-        matrix = Matrix (nr, nc);
+        m_matrix = Matrix (nr, nc);
       else
         panic_impossible ();
     }
@@ -666,7 +666,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   else
     {
@@ -686,7 +686,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   return true;
 }
@@ -785,7 +785,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -830,7 +830,7 @@
                octave_H5P_DEFAULT, re) >= 0)
     {
       retval = true;
-      matrix = m;
+      m_matrix = m;
     }
 
   H5Sclose (space_id);
@@ -850,7 +850,7 @@
 octave_matrix::print_raw (std::ostream& os,
                           bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level ());
 }
 
@@ -863,7 +863,7 @@
 
   mwSize nel = numel ();
 
-  const double *pdata = matrix.data ();
+  const double *pdata = m_matrix.data ();
 
   for (mwIndex i = 0; i < nel; i++)
     pd[i] = pdata[i];
@@ -916,16 +916,16 @@
   switch (umap)
     {
     case umap_imag:
-      return NDArray (matrix.dims (), 0.0);
+      return NDArray (m_matrix.dims (), 0.0);
 
     case umap_real:
     case umap_conj:
-      return matrix;
+      return m_matrix;
 
     // Mappers handled specially.
 #define ARRAY_METHOD_MAPPER(UMAP, FCN)        \
     case umap_ ## UMAP:                       \
-      return octave_value (matrix.FCN ())
+      return octave_value (m_matrix.FCN ())
 
     ARRAY_METHOD_MAPPER (abs, abs);
     ARRAY_METHOD_MAPPER (isnan, isnan);
@@ -934,11 +934,11 @@
 
 #define ARRAY_MAPPER(UMAP, TYPE, FCN)                 \
     case umap_ ## UMAP:                               \
-      return octave_value (matrix.map<TYPE> (FCN))
+      return octave_value (m_matrix.map<TYPE> (FCN))
 
 #define RC_ARRAY_MAPPER(UMAP, TYPE, FCN)      \
     case umap_ ## UMAP:                       \
-      return do_rc_map (matrix, FCN)
+      return do_rc_map (m_matrix, FCN)
 
     RC_ARRAY_MAPPER (acos, Complex, octave::math::rc_acos);
     RC_ARRAY_MAPPER (acosh, Complex, octave::math::rc_acosh);
@@ -983,7 +983,7 @@
     // Special cases for Matlab compatibility.
     case umap_xtolower:
     case umap_xtoupper:
-      return matrix;
+      return m_matrix;
 
     case umap_xisalnum:
     case umap_xisalpha:
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-re-mat.h
--- a/libinterp/octave-value/ov-re-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-re-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -107,8 +107,8 @@
 
   octave::idx_vector index_vector (bool /* require_integers */ = false) const
   {
-    return idx_cache ? *idx_cache
-                     : set_idx_cache (octave::idx_vector (matrix));
+    return m_idx_cache ? *m_idx_cache
+                     : set_idx_cache (octave::idx_vector (m_matrix));
   }
 
   builtin_type_t builtin_type (void) const { return btyp_double; }
@@ -122,28 +122,28 @@
   bool isfloat (void) const { return true; }
 
   int8NDArray
-  int8_array_value (void) const { return int8NDArray (matrix); }
+  int8_array_value (void) const { return int8NDArray (m_matrix); }
 
   int16NDArray
-  int16_array_value (void) const { return int16NDArray (matrix); }
+  int16_array_value (void) const { return int16NDArray (m_matrix); }
 
   int32NDArray
-  int32_array_value (void) const { return int32NDArray (matrix); }
+  int32_array_value (void) const { return int32NDArray (m_matrix); }
 
   int64NDArray
-  int64_array_value (void) const { return int64NDArray (matrix); }
+  int64_array_value (void) const { return int64NDArray (m_matrix); }
 
   uint8NDArray
-  uint8_array_value (void) const { return uint8NDArray (matrix); }
+  uint8_array_value (void) const { return uint8NDArray (m_matrix); }
 
   uint16NDArray
-  uint16_array_value (void) const { return uint16NDArray (matrix); }
+  uint16_array_value (void) const { return uint16NDArray (m_matrix); }
 
   uint32NDArray
-  uint32_array_value (void) const { return uint32NDArray (matrix); }
+  uint32_array_value (void) const { return uint32NDArray (m_matrix); }
 
   uint64NDArray
-  uint64_array_value (void) const { return uint64NDArray (matrix); }
+  uint64_array_value (void) const { return uint64NDArray (m_matrix); }
 
   double double_value (bool = false) const;
 
@@ -172,9 +172,9 @@
 
   charNDArray char_array_value (bool = false) const;
 
-  NDArray array_value (bool = false) const { return matrix; }
+  NDArray array_value (bool = false) const { return m_matrix; }
 
-  FloatNDArray float_array_value (bool = false) const { return matrix; }
+  FloatNDArray float_array_value (bool = false) const { return m_matrix; }
 
   SparseMatrix sparse_matrix_value (bool = false) const;
 
@@ -238,7 +238,7 @@
   int write (octave::stream& os, int block_size,
              oct_data_conv::data_type output_type, int skip,
              octave::mach_info::float_format flt_fmt) const
-  { return os.write (matrix, block_size, output_type, skip, flt_fmt); }
+  { return os.write (m_matrix, block_size, output_type, skip, flt_fmt); }
 
   mxArray * as_mxArray (bool interleaved) const;
 
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-str-mat.cc
--- a/libinterp/octave-value/ov-str-mat.cc	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-str-mat.cc	Sun Jul 10 18:26:24 2022 -0700
@@ -105,14 +105,14 @@
       switch (len)
         {
         case 0:
-          retval = octave_value (matrix, type);
+          retval = octave_value (m_matrix, type);
           break;
 
         case 1:
           {
             octave::idx_vector i = idx (0).index_vector ();
 
-            retval = octave_value (charNDArray (matrix.index (i, resize_ok)),
+            retval = octave_value (charNDArray (m_matrix.index (i, resize_ok)),
                                    type);
           }
           break;
@@ -123,7 +123,7 @@
             k = 1;
             octave::idx_vector j = idx (1).index_vector ();
 
-            retval = octave_value (charNDArray (matrix.index (i, j, resize_ok)),
+            retval = octave_value (charNDArray (m_matrix.index (i, j, resize_ok)),
                                    type);
           }
           break;
@@ -135,7 +135,7 @@
             for (k = 0; k < len; k++)
               idx_vec(k) = idx(k).index_vector ();
 
-            retval = octave_value (charNDArray (matrix.index (idx_vec, resize_ok)), type);
+            retval = octave_value (charNDArray (m_matrix.index (idx_vec, resize_ok)), type);
           }
           break;
         }
@@ -153,7 +153,7 @@
 octave_value
 octave_char_matrix_str::resize (const dim_vector& dv, bool fill) const
 {
-  charNDArray retval (matrix);
+  charNDArray retval (m_matrix);
   if (fill)
     retval.resize (dv, 0);
   else
@@ -211,10 +211,10 @@
 {
   string_vector retval;
 
-  if (matrix.ndims () != 2)
+  if (m_matrix.ndims () != 2)
     error ("invalid conversion of charNDArray to string_vector");
 
-  charMatrix chm (matrix);
+  charMatrix chm (m_matrix);
 
   octave_idx_type n = chm.rows ();
 
@@ -229,10 +229,10 @@
 std::string
 octave_char_matrix_str::string_value (bool) const
 {
-  if (matrix.ndims () != 2)
+  if (m_matrix.ndims () != 2)
     error ("invalid conversion of charNDArray to string");
 
-  charMatrix chm (matrix);
+  charMatrix chm (m_matrix);
 
   if (chm.rows () > 1)
     warning_with_id ("Octave:charmat-truncated",
@@ -256,10 +256,10 @@
 {
   Array<std::string> retval;
 
-  if (matrix.ndims () != 2)
+  if (m_matrix.ndims () != 2)
     error ("cellstr: cannot convert multidimensional arrays");
 
-  const charMatrix chm (matrix);
+  const charMatrix chm (m_matrix);
   octave_idx_type nr = chm.rows ();
   retval.clear (nr, 1);
   for (octave_idx_type i = 0; i < nr; i++)
@@ -272,16 +272,16 @@
 octave_char_matrix_str::print_raw (std::ostream& os,
                                    bool pr_as_read_syntax) const
 {
-  octave_print_internal (os, matrix, pr_as_read_syntax,
+  octave_print_internal (os, m_matrix, pr_as_read_syntax,
                          current_print_indent_level (), true);
 }
 
 void
 octave_char_matrix_str::short_disp (std::ostream& os) const
 {
-  if (matrix.ndims () == 2 && numel () > 0)
+  if (m_matrix.ndims () == 2 && numel () > 0)
     {
-      charMatrix chm (matrix);
+      charMatrix chm (m_matrix);
       std::string tmp = chm.row_as_string (0);
 
       // FIXME: should this be configurable?
@@ -312,7 +312,7 @@
     }
 
   std::string tname = type_name ();
-  dim_vector dv = matrix.dims ();
+  dim_vector dv = m_matrix.dims ();
   std::string dimstr = dv.str ();
   return "[" + dimstr + " " + tname + "]";
 }
@@ -388,7 +388,7 @@
       charNDArray tmp(dv);
 
       if (tmp.isempty ())
-        matrix = tmp;
+        m_matrix = tmp;
       else
         {
           char *ftmp = tmp.fortran_vec ();
@@ -398,7 +398,7 @@
           if (! is.read (ftmp, dv.numel ()) || ! is)
             error ("load: failed to load string constant");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
     }
   else if (kw == "elements")
@@ -437,7 +437,7 @@
           chm.insert (tmp, i, 0);
         }
 
-      matrix = chm;
+      m_matrix = chm;
     }
   else if (kw == "length")
     {
@@ -459,7 +459,7 @@
           if (! is)
             error ("load: failed to load string constant");
 
-          matrix = tmp;
+          m_matrix = tmp;
         }
     }
   else
@@ -535,7 +535,7 @@
       if (! is)
         return false;
 
-      matrix = m;
+      m_matrix = m;
     }
   else
     {
@@ -559,7 +559,7 @@
             }
           chm.insert (btmp, i, 0);
         }
-      matrix = chm;
+      m_matrix = chm;
     }
   return true;
 }
@@ -636,7 +636,7 @@
   dim_vector dv;
   int empty = load_hdf5_empty (loc_id, name, dv);
   if (empty > 0)
-    matrix.resize (dv);
+    m_matrix.resize (dv);
   if (empty)
     return (empty > 0);
 
@@ -685,7 +685,7 @@
                    octave_H5P_DEFAULT, str) >= 0)
         {
           retval = true;
-          matrix = m;
+          m_matrix = m;
         }
 
       H5Tclose (type_hid);
@@ -723,7 +723,7 @@
                   return false;
                 }
 
-              matrix = charMatrix (s);
+              m_matrix = charMatrix (s);
 
               H5Tclose (st_id);
               H5Tclose (type_hid);
@@ -774,7 +774,7 @@
                   chm.insert (s + i*(slen+1), i, 0);
                 }
 
-              matrix = chm;
+              m_matrix = chm;
 
               H5Tclose (st_id);
               H5Tclose (type_hid);
diff -r 6308ce73bdca -r b3ca7f891750 libinterp/octave-value/ov-str-mat.h
--- a/libinterp/octave-value/ov-str-mat.h	Sun Jul 10 17:34:12 2022 +0200
+++ b/libinterp/octave-value/ov-str-mat.h	Sun Jul 10 18:26:24 2022 -0700
@@ -98,13 +98,13 @@
   { return do_index_op_internal (idx, resize_ok); }
 
   octave_value squeeze (void) const
-  { return octave_value (charNDArray (matrix.squeeze ())); }
+  { return octave_value (charNDArray (m_matrix.squeeze ())); }
 
   octave_value reshape (const dim_vector& new_dims) const
-  { return octave_value (charNDArray (matrix.reshape (new_dims))); }
+  { return octave_value (charNDArray (m_matrix.reshape (new_dims))); }
 
   octave_value permute (const Array<int>& vec, bool inv = false) const
-  { return octave_value (charNDArray (matrix.permute (vec, inv))); }
+  { return octave_value (charNDArray (m_matrix.permute (vec, inv))); }
 
   octave_value resize (const dim_vector& dv, bool fill = false) const;
 
@@ -114,7 +114,7 @@
   using octave_char_matrix::diag;
 
   octave_value diag (octave_idx_type k = 0) const
-  { return octave_value (matrix.diag (k)); }
+  { return octave_value (m_matrix.diag (k)); }
 
   bool is_string (void) const { return true; }
 
@@ -141,11 +141,11 @@
   Array<std::string> cellstr_value (void) const;
 
   octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
-  { return octave_value (matrix.sort (dim, mode)); }
+  { return octave_value (m_matrix.sort (dim, mode)); }
 
   octave_value sort (Array<octave_idx_type>& sidx, octave_idx_type dim = 0,
                      sortmode mode = ASCENDING) const
-  { return octave_value (matrix.sort (sidx, dim, mode)); }
+  { return octave_value (m_matrix.sort (sidx, dim, mode)); }
 
   bool print_as_scalar (void) const { return (rows () <= 1); }
 
@@ -172,7 +172,7 @@
   int write (octave::stream& os, int block_size,
              oct_data_conv::data_type output_type, int skip,
              octave::mach_info::float_format flt_fmt) const
-  { return os.write (matrix, block_size, output_type, skip, flt_fmt); }
+  { return os.write (m_matrix, block_size, output_type, skip, flt_fmt); }
 
 protected:
 
@@ -229,17 +229,17 @@
   { return new octave_char_matrix_sq_str (); }
 
   octave_value squeeze (void) const
-  { return octave_value (charNDArray (matrix.squeeze ()), '\''); }
+  { return octave_value (charNDArray (m_matrix.squeeze ()), '\''); }
 
   octave_value reshape (const dim_vector& new_dims) const
-  { return octave_value (charNDArray (matrix.reshape (new_dims)), '\''); }
+  { return octave_value (charNDArray (m_matrix.reshape (new_dims)), '\''); }
 
   octave_value permute (const Array<int>& vec, bool inv = false) const
-  { return octave_value (charNDArray (matrix.permute (vec, inv)), '\''); }
+  { return octave_value (charNDArray (m_matrix.permute (vec, inv)), '\''); }
 
   octave_value resize (const dim_vector& dv, bool = false) const
   {
-    charNDArray retval (matrix);
+    charNDArray retval (m_matrix);
     retval.resize (dv);
     return octave_value (retval, '\'');
   }
@@ -250,7 +250,7 @@
   using octave_char_matrix_str::diag;
 
   octave_value diag (octave_idx_type k = 0) const
-  { return octave_value (matrix.diag (k), '\''); }
+  { return octave_value (m_matrix.diag (k), '\''); }
 
   bool is_sq_string (void) const { return true; }
 
@@ -259,11 +259,11 @@
   { return do_index_op_internal (idx, resize_ok, '\''); }
 
   octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
-  { return octave_value (matrix.sort (dim, mode), '\''); }
+  { return octave_value (m_matrix.sort (dim, mode), '\''); }
 
   octave_value sort (Array<octave_idx_type>& sidx, octave_idx_type dim = 0,
                      sortmode mode = ASCENDING) const
-  { return octave_value (matrix.sort (sidx, dim, mode), '\''); }
+  { return octave_value (m_matrix.sort (sidx, dim, mode), '\''); }
 
 private: