diff libinterp/octave-value/ov-ch-mat.cc @ 31138:b3ca7f891750

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.
author Rik <rik@octave.org>
date Sun, 10 Jul 2022 18:26:24 -0700
parents 83f9f8bda883
children aac27ad79be6
line wrap: on
line diff
--- 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);