This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: RFA: Use "m_foo" rather than "foo_" for member variables


Richard Biener <richard.guenther@gmail.com> writes:
> On Sun, Sep 29, 2013 at 11:08 AM, Richard Sandiford
> <rdsandiford@googlemail.com> wrote:
>> Michael Matz <matz@suse.de> writes:
>>>Trever Saunders <tsaunders@mozilla.com> writes:
>>>> Richard Biener <richard.guenther@gmail.com> writes:
>>>> > Btw, I've come around multiple coding-styles in the past and I
>>>> > definitely would prefer m_mode / m_count to mark members vs. mode_ and
>>>> > count_. (and s_XXX for static members IIRC).
>>>>
>>>> I'd prefer m_/s_foo for members / static things too fwiw.
>>>
>>> Me as well.  It's still ugly, but not so unsymmetric as the trailing
>>> underscore.
>>
>> Well, I'm not sure how I came to be the one writing these patches,
>> but I suppose I prefer m_foo too.  So how about the attached?
>>
>> The first patch has changes to the coding conventions.  I added
>> some missing spaces while there.
>>
>> The second patch has the mechanical code changes.  The reason for
>> yesterday's mass adding of spaces was because the second patch would
>> have been pretty inconsistent otherwise.
>>
>> Tested on x86_64-linux-gnu.
>
> Ok.

Applied, thanks.  I was only looking for private and protected members,
so I ended up missing vec.  I installed the patch below as an obvious
follow-up.  Tested on x86_64-linux-gnu.

There are some other uses foo_, but many of them seem to date from before
the C++ switchover.

Richard


gcc/
	* vec.h (vec_prefix, vec): Prefix member names with "m_".
	* vec.c (vec_prefix::calculate_allocation): Update accordingly.

Index: gcc/vec.c
===================================================================
--- gcc/vec.c	2013-09-27 09:16:58.010299213 +0100
+++ gcc/vec.c	2013-09-30 18:09:02.892316820 +0100
@@ -183,8 +183,8 @@ vec_prefix::calculate_allocation (vec_pr
 
   if (pfx)
     {
-      alloc = pfx->alloc_;
-      num = pfx->num_;
+      alloc = pfx->m_alloc;
+      num = pfx->m_num;
     }
   else if (!reserve)
     /* If there's no vector, and we've not requested anything, then we
Index: gcc/vec.h
===================================================================
--- gcc/vec.h	2013-09-30 18:06:22.236575959 +0100
+++ gcc/vec.h	2013-09-30 18:06:22.305576705 +0100
@@ -235,8 +235,8 @@ struct vec_prefix
   friend struct va_heap;
   friend struct va_stack;
 
-  unsigned alloc_;
-  unsigned num_;
+  unsigned m_alloc;
+  unsigned m_num;
 };
 
 template<typename, typename, typename> struct vec;
@@ -285,7 +285,7 @@ va_heap::reserve (vec<T, va_heap, vl_emb
 		  MEM_STAT_DECL)
 {
   unsigned alloc
-    = vec_prefix::calculate_allocation (v ? &v->vecpfx_ : 0, reserve, exact);
+    = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
   if (!alloc)
     {
       release (v);
@@ -293,7 +293,7 @@ va_heap::reserve (vec<T, va_heap, vl_emb
     }
 
   if (GATHER_STATISTICS && v)
-    v->vecpfx_.release_overhead ();
+    v->m_vecpfx.release_overhead ();
 
   size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
   unsigned nelem = v ? v->length () : 0;
@@ -301,7 +301,7 @@ va_heap::reserve (vec<T, va_heap, vl_emb
   v->embedded_init (alloc, nelem);
 
   if (GATHER_STATISTICS)
-    v->vecpfx_.register_overhead (size FINAL_PASS_MEM_STAT);
+    v->m_vecpfx.register_overhead (size FINAL_PASS_MEM_STAT);
 }
 
 
@@ -315,7 +315,7 @@ va_heap::release (vec<T, va_heap, vl_emb
     return;
 
   if (GATHER_STATISTICS)
-    v->vecpfx_.release_overhead ();
+    v->m_vecpfx.release_overhead ();
   ::free (v);
   v = NULL;
 }
@@ -364,7 +364,7 @@ va_gc::reserve (vec<T, A, vl_embed> *&v,
 		MEM_STAT_DECL)
 {
   unsigned alloc
-    = vec_prefix::calculate_allocation (v ? &v->vecpfx_ : 0, reserve, exact);
+    = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
   if (!alloc)
     {
       ::ggc_free (v);
@@ -433,9 +433,9 @@ void unregister_stack_vec (unsigned);
 va_stack::alloc (vec<T, va_stack, vl_ptr> &v, unsigned nelems,
 		 vec<T, va_stack, vl_embed> *space)
 {
-  v.vec_ = space;
-  register_stack_vec (static_cast<void *> (v.vec_));
-  v.vec_->embedded_init (nelems, 0);
+  v.m_vec = space;
+  register_stack_vec (static_cast<void *> (v.m_vec));
+  v.m_vec->embedded_init (nelems, 0);
 }
 
 
@@ -462,16 +462,16 @@ va_stack::reserve (vec<T, va_stack, vl_e
     }
 
   /* Move VEC_ to the heap.  */
-  nelems += v->vecpfx_.num_;
+  nelems += v->m_vecpfx.m_num;
   vec<T, va_stack, vl_embed> *oldvec = v;
   v = NULL;
   va_heap::reserve (reinterpret_cast<vec<T, va_heap, vl_embed> *&>(v), nelems,
 		    exact PASS_MEM_STAT);
   if (v && oldvec)
     {
-      v->vecpfx_.num_ = oldvec->length ();
-      memcpy (v->vecdata_,
-	      oldvec->vecdata_,
+      v->m_vecpfx.m_num = oldvec->length ();
+      memcpy (v->m_vecdata,
+	      oldvec->m_vecdata,
 	      oldvec->length () * sizeof (T));
     }
 }
@@ -562,11 +562,11 @@ struct vnull
 struct GTY((user)) vec<T, A, vl_embed>
 {
 public:
-  unsigned allocated (void) const { return vecpfx_.alloc_; }
-  unsigned length (void) const { return vecpfx_.num_; }
-  bool is_empty (void) const { return vecpfx_.num_ == 0; }
-  T *address (void) { return vecdata_; }
-  const T *address (void) const { return vecdata_; }
+  unsigned allocated (void) const { return m_vecpfx.m_alloc; }
+  unsigned length (void) const { return m_vecpfx.m_num; }
+  bool is_empty (void) const { return m_vecpfx.m_num == 0; }
+  T *address (void) { return m_vecdata; }
+  const T *address (void) const { return m_vecdata; }
   const T &operator[] (unsigned) const;
   T &operator[] (unsigned);
   T &last (void);
@@ -601,8 +601,8 @@ struct GTY((user)) vec<T, A, vl_embed>
 
   /* FIXME - These fields should be private, but we need to cater to
 	     compilers that have stricter notions of PODness for types.  */
-  vec_prefix vecpfx_;
-  T vecdata_[1];
+  vec_prefix m_vecpfx;
+  T m_vecdata[1];
 };
 
 
@@ -816,16 +816,16 @@ vec_safe_splice (vec<T, A, vl_embed> *&d
 inline const T &
 vec<T, A, vl_embed>::operator[] (unsigned ix) const
 {
-  gcc_checking_assert (ix < vecpfx_.num_);
-  return vecdata_[ix];
+  gcc_checking_assert (ix < m_vecpfx.m_num);
+  return m_vecdata[ix];
 }
 
 template<typename T, typename A>
 inline T &
 vec<T, A, vl_embed>::operator[] (unsigned ix)
 {
-  gcc_checking_assert (ix < vecpfx_.num_);
-  return vecdata_[ix];
+  gcc_checking_assert (ix < m_vecpfx.m_num);
+  return m_vecdata[ix];
 }
 
 
@@ -835,8 +835,8 @@ vec<T, A, vl_embed>::operator[] (unsigne
 inline T &
 vec<T, A, vl_embed>::last (void)
 {
-  gcc_checking_assert (vecpfx_.num_ > 0);
-  return (*this)[vecpfx_.num_ - 1];
+  gcc_checking_assert (m_vecpfx.m_num > 0);
+  return (*this)[m_vecpfx.m_num - 1];
 }
 
 
@@ -850,7 +850,7 @@ vec<T, A, vl_embed>::last (void)
 inline bool
 vec<T, A, vl_embed>::space (unsigned nelems) const
 {
-  return vecpfx_.alloc_ - vecpfx_.num_ >= nelems;
+  return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems;
 }
 
 
@@ -865,9 +865,9 @@ vec<T, A, vl_embed>::space (unsigned nel
 inline bool
 vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const
 {
-  if (ix < vecpfx_.num_)
+  if (ix < m_vecpfx.m_num)
     {
-      *ptr = vecdata_[ix];
+      *ptr = m_vecdata[ix];
       return true;
     }
   else
@@ -891,9 +891,9 @@ vec<T, A, vl_embed>::iterate (unsigned i
 inline bool
 vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const
 {
-  if (ix < vecpfx_.num_)
+  if (ix < m_vecpfx.m_num)
     {
-      *ptr = CONST_CAST (T *, &vecdata_[ix]);
+      *ptr = CONST_CAST (T *, &m_vecdata[ix]);
       return true;
     }
   else
@@ -916,7 +916,7 @@ vec<T, A, vl_embed>::copy (ALONE_MEM_STA
     {
       vec_alloc (new_vec, len PASS_MEM_STAT);
       new_vec->embedded_init (len, len);
-      memcpy (new_vec->address (), vecdata_, sizeof (T) * len);
+      memcpy (new_vec->address (), m_vecdata, sizeof (T) * len);
     }
   return new_vec;
 }
@@ -934,7 +934,7 @@ vec<T, A, vl_embed>::splice (vec<T, A, v
     {
       gcc_checking_assert (space (len));
       memcpy (address () + length (), src.address (), len * sizeof (T));
-      vecpfx_.num_ += len;
+      m_vecpfx.m_num += len;
     }
 }
 
@@ -956,7 +956,7 @@ vec<T, A, vl_embed>::splice (vec<T, A, v
 vec<T, A, vl_embed>::quick_push (const T &obj)
 {
   gcc_checking_assert (space (1));
-  T *slot = &vecdata_[vecpfx_.num_++];
+  T *slot = &m_vecdata[m_vecpfx.m_num++];
   *slot = obj;
   return slot;
 }
@@ -969,7 +969,7 @@ vec<T, A, vl_embed>::quick_push (const T
 vec<T, A, vl_embed>::pop (void)
 {
   gcc_checking_assert (length () > 0);
-  return vecdata_[--vecpfx_.num_];
+  return m_vecdata[--m_vecpfx.m_num];
 }
 
 
@@ -981,7 +981,7 @@ vec<T, A, vl_embed>::pop (void)
 vec<T, A, vl_embed>::truncate (unsigned size)
 {
   gcc_checking_assert (length () >= size);
-  vecpfx_.num_ = size;
+  m_vecpfx.m_num = size;
 }
 
 
@@ -994,8 +994,8 @@ vec<T, A, vl_embed>::quick_insert (unsig
 {
   gcc_checking_assert (length () < allocated ());
   gcc_checking_assert (ix <= length ());
-  T *slot = &vecdata_[ix];
-  memmove (slot + 1, slot, (vecpfx_.num_++ - ix) * sizeof (T));
+  T *slot = &m_vecdata[ix];
+  memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
   *slot = obj;
 }
 
@@ -1009,8 +1009,8 @@ vec<T, A, vl_embed>::quick_insert (unsig
 vec<T, A, vl_embed>::ordered_remove (unsigned ix)
 {
   gcc_checking_assert (ix < length ());
-  T *slot = &vecdata_[ix];
-  memmove (slot, slot + 1, (--vecpfx_.num_ - ix) * sizeof (T));
+  T *slot = &m_vecdata[ix];
+  memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
 }
 
 
@@ -1022,7 +1022,7 @@ vec<T, A, vl_embed>::ordered_remove (uns
 vec<T, A, vl_embed>::unordered_remove (unsigned ix)
 {
   gcc_checking_assert (ix < length ());
-  vecdata_[ix] = vecdata_[--vecpfx_.num_];
+  m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num];
 }
 
 
@@ -1034,9 +1034,9 @@ vec<T, A, vl_embed>::unordered_remove (u
 vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
 {
   gcc_checking_assert (ix + len <= length ());
-  T *slot = &vecdata_[ix];
-  vecpfx_.num_ -= len;
-  memmove (slot, slot + len, (vecpfx_.num_ - ix) * sizeof (T));
+  T *slot = &m_vecdata[ix];
+  m_vecpfx.m_num -= len;
+  memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
 }
 
 
@@ -1100,7 +1100,7 @@ vec<T, A, vl_embed>::lower_bound (T obj,
 vec<T, A, vl_embed>::embedded_size (unsigned alloc)
 {
   typedef vec<T, A, vl_embed> vec_embedded;
-  return offsetof (vec_embedded, vecdata_) + alloc * sizeof (T);
+  return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T);
 }
 
 
@@ -1111,8 +1111,8 @@ vec<T, A, vl_embed>::embedded_size (unsi
 inline void
 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num)
 {
-  vecpfx_.alloc_ = alloc;
-  vecpfx_.num_ = num;
+  m_vecpfx.m_alloc = alloc;
+  m_vecpfx.m_num = num;
 }
 
 
@@ -1123,8 +1123,8 @@ vec<T, A, vl_embed>::embedded_init (unsi
 inline void
 vec<T, A, vl_embed>::quick_grow (unsigned len)
 {
-  gcc_checking_assert (length () <= len && len <= vecpfx_.alloc_);
-  vecpfx_.num_ = len;
+  gcc_checking_assert (length () <= len && len <= m_vecpfx.m_alloc);
+  m_vecpfx.m_num = len;
 }
 
 
@@ -1229,22 +1229,22 @@ struct vec<T, A, vl_ptr>
 
   /* Vector operations.  */
   bool exists (void) const
-  { return vec_ != NULL; }
+  { return m_vec != NULL; }
 
   bool is_empty (void) const
-  { return vec_ ? vec_->is_empty () : true; }
+  { return m_vec ? m_vec->is_empty () : true; }
 
   unsigned length (void) const
-  { return vec_ ? vec_->length () : 0; }
+  { return m_vec ? m_vec->length () : 0; }
 
   T *address (void)
-  { return vec_ ? vec_->vecdata_ : NULL; }
+  { return m_vec ? m_vec->m_vecdata : NULL; }
 
   const T *address (void) const
-  { return vec_ ? vec_->vecdata_ : NULL; }
+  { return m_vec ? m_vec->m_vecdata : NULL; }
 
   const T &operator[] (unsigned ix) const
-  { return (*vec_)[ix]; }
+  { return (*m_vec)[ix]; }
 
   bool operator!=(const vec &other) const
   { return !(*this == other); }
@@ -1253,13 +1253,13 @@ struct vec<T, A, vl_ptr>
   { return address () == other.address (); }
 
   T &operator[] (unsigned ix)
-  { return (*vec_)[ix]; }
+  { return (*m_vec)[ix]; }
 
   T &last (void)
-  { return vec_->last (); }
+  { return m_vec->last (); }
 
   bool space (int nelems) const
-  { return vec_ ? vec_->space (nelems) : nelems == 0; }
+  { return m_vec ? m_vec->space (nelems) : nelems == 0; }
 
   bool iterate (unsigned ix, T *p) const;
   bool iterate (unsigned ix, T **p) const;
@@ -1290,7 +1290,7 @@ struct vec<T, A, vl_ptr>
 
   /* FIXME - This field should be private, but we need to cater to
 	     compilers that have stricter notions of PODness for types.  */
-  vec<T, A, vl_embed> *vec_;
+  vec<T, A, vl_embed> *m_vec;
 };
 
 
@@ -1393,8 +1393,8 @@ #define vec_stack_alloc(T,V,N)						\
 inline bool
 vec<T, A, vl_ptr>::iterate (unsigned ix, T *ptr) const
 {
-  if (vec_)
-    return vec_->iterate (ix, ptr);
+  if (m_vec)
+    return m_vec->iterate (ix, ptr);
   else
     {
       *ptr = 0;
@@ -1416,8 +1416,8 @@ vec<T, A, vl_ptr>::iterate (unsigned ix,
 inline bool
 vec<T, A, vl_ptr>::iterate (unsigned ix, T **ptr) const
 {
-  if (vec_)
-    return vec_->iterate (ix, ptr);
+  if (m_vec)
+    return m_vec->iterate (ix, ptr);
   else
     {
       *ptr = 0;
@@ -1457,7 +1457,7 @@ vec<T, A, vl_ptr>::copy (ALONE_MEM_STAT_
 {
   vec<T, A, vl_ptr> new_vec = vNULL;
   if (length ())
-    new_vec.vec_ = vec_->copy ();
+    new_vec.m_vec = m_vec->copy ();
   return new_vec;
 }
 
@@ -1477,7 +1477,7 @@ vec<T, A, vl_ptr>::reserve (unsigned nel
 {
   bool extend = nelems ? !space (nelems) : false;
   if (extend)
-    A::reserve (vec_, nelems, exact PASS_MEM_STAT);
+    A::reserve (m_vec, nelems, exact PASS_MEM_STAT);
   return extend;
 }
 
@@ -1504,7 +1504,7 @@ vec<T, A, vl_ptr>::reserve_exact (unsign
 inline void
 vec<T, A, vl_ptr>::create (unsigned nelems MEM_STAT_DECL)
 {
-  vec_ = NULL;
+  m_vec = NULL;
   if (nelems > 0)
     reserve_exact (nelems PASS_MEM_STAT);
 }
@@ -1516,8 +1516,8 @@ vec<T, A, vl_ptr>::create (unsigned nele
 inline void
 vec<T, A, vl_ptr>::release (void)
 {
-  if (vec_)
-    A::release (vec_);
+  if (m_vec)
+    A::release (m_vec);
 }
 
 
@@ -1530,8 +1530,8 @@ vec<T, A, vl_ptr>::release (void)
 inline void
 vec<T, A, vl_ptr>::splice (vec<T, A, vl_ptr> &src)
 {
-  if (src.vec_)
-    vec_->splice (*(src.vec_));
+  if (src.m_vec)
+    m_vec->splice (*(src.m_vec));
 }
 
 
@@ -1560,7 +1560,7 @@ vec<T, A, vl_ptr>::safe_splice (vec<T, A
 inline T *
 vec<T, A, vl_ptr>::quick_push (const T &obj)
 {
-  return vec_->quick_push (obj);
+  return m_vec->quick_push (obj);
 }
 
 
@@ -1583,7 +1583,7 @@ vec<T, A, vl_ptr>::safe_push (const T &o
 inline T &
 vec<T, A, vl_ptr>::pop (void)
 {
-  return vec_->pop ();
+  return m_vec->pop ();
 }
 
 
@@ -1594,8 +1594,8 @@ vec<T, A, vl_ptr>::pop (void)
 inline void
 vec<T, A, vl_ptr>::truncate (unsigned size)
 {
-  if (vec_)
-    vec_->truncate (size);
+  if (m_vec)
+    m_vec->truncate (size);
   else
     gcc_checking_assert (size == 0);
 }
@@ -1612,7 +1612,7 @@ vec<T, A, vl_ptr>::safe_grow (unsigned l
   unsigned oldlen = length ();
   gcc_checking_assert (oldlen <= len);
   reserve_exact (len - oldlen PASS_MEM_STAT);
-  vec_->quick_grow (len);
+  m_vec->quick_grow (len);
 }
 
 
@@ -1637,8 +1637,8 @@ vec<T, A, vl_ptr>::safe_grow_cleared (un
 inline void
 vec<T, A, vl_ptr>::quick_grow (unsigned len)
 {
-  gcc_checking_assert (vec_);
-  vec_->quick_grow (len);
+  gcc_checking_assert (m_vec);
+  m_vec->quick_grow (len);
 }
 
 
@@ -1650,8 +1650,8 @@ vec<T, A, vl_ptr>::quick_grow (unsigned
 inline void
 vec<T, A, vl_ptr>::quick_grow_cleared (unsigned len)
 {
-  gcc_checking_assert (vec_);
-  vec_->quick_grow_cleared (len);
+  gcc_checking_assert (m_vec);
+  m_vec->quick_grow_cleared (len);
 }
 
 
@@ -1662,7 +1662,7 @@ vec<T, A, vl_ptr>::quick_grow_cleared (u
 inline void
 vec<T, A, vl_ptr>::quick_insert (unsigned ix, const T &obj)
 {
-  vec_->quick_insert (ix, obj);
+  m_vec->quick_insert (ix, obj);
 }
 
 
@@ -1686,7 +1686,7 @@ vec<T, A, vl_ptr>::safe_insert (unsigned
 inline void
 vec<T, A, vl_ptr>::ordered_remove (unsigned ix)
 {
-  vec_->ordered_remove (ix);
+  m_vec->ordered_remove (ix);
 }
 
 
@@ -1697,7 +1697,7 @@ vec<T, A, vl_ptr>::ordered_remove (unsig
 inline void
 vec<T, A, vl_ptr>::unordered_remove (unsigned ix)
 {
-  vec_->unordered_remove (ix);
+  m_vec->unordered_remove (ix);
 }
 
 
@@ -1708,7 +1708,7 @@ vec<T, A, vl_ptr>::unordered_remove (uns
 inline void
 vec<T, A, vl_ptr>::block_remove (unsigned ix, unsigned len)
 {
-  vec_->block_remove (ix, len);
+  m_vec->block_remove (ix, len);
 }
 
 
@@ -1719,8 +1719,8 @@ vec<T, A, vl_ptr>::block_remove (unsigne
 inline void
 vec<T, A, vl_ptr>::qsort (int (*cmp) (const void *, const void *))
 {
-  if (vec_)
-    vec_->qsort (cmp);
+  if (m_vec)
+    m_vec->qsort (cmp);
 }
 
 
@@ -1734,11 +1734,11 @@ vec<T, A, vl_ptr>::qsort (int (*cmp) (co
 vec<T, A, vl_ptr>::lower_bound (T obj, bool (*lessthan)(const T &, const T &))
     const
 {
-  return vec_ ? vec_->lower_bound (obj, lessthan) : 0;
+  return m_vec ? m_vec->lower_bound (obj, lessthan) : 0;
 }
 
 #if (GCC_VERSION >= 3000)
-# pragma GCC poison vec_ vecpfx_ vecdata_
+# pragma GCC poison m_vec m_vecpfx m_vecdata
 #endif
 
 #endif // GCC_VEC_H


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]