Mercurial > octave

changeset 24848:2d68dc548561

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use m_ prefix for member variables in unary op parser classes * pt-unop.h, pt-unop.cc: Use m_ prefix for member variable names.
author John W. Eaton <jwe@octave.org>
date Wed, 07 Mar 2018 17:34:52 -0500
parents fa4e852dae1e
children 96c74e33d17a
files libinterp/parse-tree/pt-unop.cc libinterp/parse-tree/pt-unop.h
diffstat 2 files changed, 13 insertions(+), 13 deletions(-) [+]
line wrap: on
line diff
--- a/libinterp/parse-tree/pt-unop.cc	Wed Mar 07 16:42:08 2018 -0500
+++ b/libinterp/parse-tree/pt-unop.cc	Wed Mar 07 17:34:52 2018 -0500
@@ -34,7 +34,7 @@
   std::string
   tree_unary_expression::oper (void) const
   {
-    return octave_value::unary_op_as_string (etype);
+    return octave_value::unary_op_as_string (m_etype);
   }
 
   // Prefix expressions.
@@ -43,8 +43,8 @@
   tree_prefix_expression::dup (symbol_scope& scope) const
   {
     tree_prefix_expression *new_pe
-      = new tree_prefix_expression (op ? op->dup (scope) : nullptr,
-                                    line (), column (), etype);
+      = new tree_prefix_expression (m_op ? m_op->dup (scope) : nullptr,
+                                    line (), column (), m_etype);
 
     new_pe->copy_base (*this);
 
@@ -57,8 +57,8 @@
   tree_postfix_expression::dup (symbol_scope& scope) const
   {
     tree_postfix_expression *new_pe
-      = new tree_postfix_expression (op ? op->dup (scope) : nullptr,
-                                     line (), column (), etype);
+      = new tree_postfix_expression (m_op ? m_op->dup (scope) : nullptr,
+                                     line (), column (), m_etype);
 
     new_pe->copy_base (*this);
 
--- a/libinterp/parse-tree/pt-unop.h	Wed Mar 07 16:42:08 2018 -0500
+++ b/libinterp/parse-tree/pt-unop.h	Wed Mar 07 17:34:52 2018 -0500
@@ -46,12 +46,12 @@
     tree_unary_expression (int l = -1, int c = -1,
                            octave_value::unary_op t
                            = octave_value::unknown_unary_op)
-      : tree_expression (l, c), op (nullptr), etype (t)  { }
+      : tree_expression (l, c), m_op (nullptr), m_etype (t)  { }
 
     tree_unary_expression (tree_expression *e, int l = -1, int c = -1,
                            octave_value::unary_op t
                            = octave_value::unknown_unary_op)
-      : tree_expression (l, c), op (e), etype (t) { }
+      : tree_expression (l, c), m_op (e), m_etype (t) { }
 
   public:
 
@@ -61,25 +61,25 @@
 
     tree_unary_expression& operator = (const tree_unary_expression&) = delete;
 
-    ~tree_unary_expression (void) { delete op; }
+    ~tree_unary_expression (void) { delete m_op; }
 
     bool is_unary_expression (void) const { return true; }
 
-    bool has_magic_end (void) const { return (op && op->has_magic_end ()); }
+    bool has_magic_end (void) const { return (m_op && m_op->has_magic_end ()); }
 
-    tree_expression * operand (void) { return op; }
+    tree_expression * operand (void) { return m_op; }
 
     std::string oper (void) const;
 
-    octave_value::unary_op op_type (void) const { return etype; }
+    octave_value::unary_op op_type (void) const { return m_etype; }
 
   protected:
 
     // The operand for the expression.
-    tree_expression *op;
+    tree_expression *m_op;
 
     // The type of the expression.
-    octave_value::unary_op etype;
+    octave_value::unary_op m_etype;
   };
 
   // Prefix expressions.