generator: remove anonymous structs (#121)

jbowler · mrbean-bremen · commit b39d565a581c · 2023-11-01T12:58:42.000+01:00
This is a minimal change to give the three anonymous structs used
in the generator names so that the code conforms to the existing
C++ standards.
diff --git a/generator/parser/codemodel.cpp b/generator/parser/codemodel.cpp
@@ -683,63 +683,63 @@ void _FunctionModelItem::setException(const QString &exception)
 
 bool _FunctionModelItem::isVariadics() const
 {
-  return _M_isVariadics;
+  return _M.isVariadics;
 }
 
 void _FunctionModelItem::setVariadics(bool isVariadics)
 {
-  _M_isVariadics = isVariadics;
+  _M.isVariadics = isVariadics;
 }
 
 bool _FunctionModelItem::isVirtual() const
 {
-  return _M_isVirtual;
+  return _M.isVirtual;
 }
 
 void _FunctionModelItem::setVirtual(bool isVirtual)
 {
-  _M_isVirtual = isVirtual;
+  _M.isVirtual = isVirtual;
 }
 
 bool _FunctionModelItem::isInline() const
 {
-  return _M_isInline;
+  return _M.isInline;
 }
 
 void _FunctionModelItem::setInline(bool isInline)
 {
-  _M_isInline = isInline;
+  _M.isInline = isInline;
 }
 
 bool _FunctionModelItem::isExplicit() const
 {
-  return _M_isExplicit;
+  return _M.isExplicit;
 }
 
 void _FunctionModelItem::setExplicit(bool isExplicit)
 {
-  _M_isExplicit = isExplicit;
+  _M.isExplicit = isExplicit;
 }
 
 bool _FunctionModelItem::isAbstract() const
 {
-  return _M_isAbstract;
+  return _M.isAbstract;
 }
 
 void _FunctionModelItem::setAbstract(bool isAbstract)
 {
-  _M_isAbstract = isAbstract;
+  _M.isAbstract = isAbstract;
 }
 
 // Qt
 bool _FunctionModelItem::isInvokable() const
 {
-    return _M_isInvokable;
+    return _M.isInvokable;
 }
 
 void _FunctionModelItem::setInvokable(bool isInvokable)
 {
-    _M_isInvokable = isInvokable;
+    _M.isInvokable = isInvokable;
 }
 
 // ---------------------------------------------------------------------------
@@ -907,92 +907,92 @@ void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 
 bool _MemberModelItem::isStatic() const
 {
-  return _M_isStatic;
+  return _M.isStatic;
 }
 
 void _MemberModelItem::setStatic(bool isStatic)
 {
-  _M_isStatic = isStatic;
+  _M.isStatic = isStatic;
 }
 
 bool _MemberModelItem::isConstant() const
 {
-  return _M_isConstant;
+  return _M.isConstant;
 }
 
 void _MemberModelItem::setConstant(bool isConstant)
 {
-  _M_isConstant = isConstant;
+  _M.isConstant = isConstant;
 }
 
 bool _MemberModelItem::isConstexpr() const
 {
-  return _M_isConstexpr;
+  return _M.isConstexpr;
 }
 
 void _MemberModelItem::setConstexpr(bool isConstexpr)
 {
-  _M_isConstexpr = isConstexpr;
+  _M.isConstexpr = isConstexpr;
 }
 
 bool _MemberModelItem::isVolatile() const
 {
-  return _M_isVolatile;
+  return _M.isVolatile;
 }
 
 void _MemberModelItem::setVolatile(bool isVolatile)
 {
-  _M_isVolatile = isVolatile;
+  _M.isVolatile = isVolatile;
 }
 
 bool _MemberModelItem::isAuto() const
 {
-  return _M_isAuto;
+  return _M.isAuto;
 }
 
 void _MemberModelItem::setAuto(bool isAuto)
 {
-  _M_isAuto = isAuto;
+  _M.isAuto = isAuto;
 }
 
 bool _MemberModelItem::isFriend() const
 {
-  return _M_isFriend;
+  return _M.isFriend;
 }
 
 void _MemberModelItem::setFriend(bool isFriend)
 {
-  _M_isFriend = isFriend;
+  _M.isFriend = isFriend;
 }
 
 bool _MemberModelItem::isRegister() const
 {
-  return _M_isRegister;
+  return _M.isRegister;
 }
 
 void _MemberModelItem::setRegister(bool isRegister)
 {
-  _M_isRegister = isRegister;
+  _M.isRegister = isRegister;
 }
 
 bool _MemberModelItem::isExtern() const
 {
-  return _M_isExtern;
+  return _M.isExtern;
 }
 
 void _MemberModelItem::setExtern(bool isExtern)
 {
-  _M_isExtern = isExtern;
+  _M.isExtern = isExtern;
 }
 
 bool _MemberModelItem::isMutable() const
 {
-  return _M_isMutable;
+  return _M.isMutable;
 }
 
 void _MemberModelItem::setMutable(bool isMutable)
 {
-  _M_isMutable = isMutable;
+  _M.isMutable = isMutable;
 }
 
 // kate: space-indent on; indent-width 2; replace-tabs on;
diff --git a/generator/parser/codemodel.h b/generator/parser/codemodel.h
@@ -517,16 +517,16 @@ class _MemberModelItem: public _CodeModelItem
   {
     struct
     {
-      uint _M_isConstant: 1;
-      uint _M_isConstexpr: 1;
-      uint _M_isVolatile: 1;
-      uint _M_isStatic: 1;
-      uint _M_isAuto: 1;
-      uint _M_isFriend: 1;
-      uint _M_isRegister: 1;
-      uint _M_isExtern: 1;
-      uint _M_isMutable: 1;
-    };
+      uint isConstant: 1;
+      uint isConstexpr: 1;
+      uint isVolatile: 1;
+      uint isStatic: 1;
+      uint isAuto: 1;
+      uint isFriend: 1;
+      uint isRegister: 1;
+      uint isExtern: 1;
+      uint isMutable: 1;
+    } _M;
     uint _M_flags;
   };
 
@@ -586,13 +586,13 @@ class _FunctionModelItem: public _MemberModelItem
   {
     struct
     {
-      uint _M_isVirtual: 1;
-      uint _M_isInline: 1;
-      uint _M_isAbstract: 1;
-      uint _M_isExplicit: 1;
-      uint _M_isVariadics: 1;
-      uint _M_isInvokable : 1; // Qt
-    };
+      uint isVirtual: 1;
+      uint isInline: 1;
+      uint isAbstract: 1;
+      uint isExplicit: 1;
+      uint isVariadics: 1;
+      uint isInvokable : 1; // Qt
+    } _M;
     uint _M_flags;
   };
 
diff --git a/generator/parser/rpp/pp-engine-bits.h b/generator/parser/rpp/pp-engine-bits.h
@@ -577,7 +577,7 @@ InputIterator pp::handle_define (InputIterator _first, InputIterator _last)
 
   if (_first != _last && *_first == '(')
     {
-      macro.function_like = true;
+      macro.is.function_like = true;
       macro.formals.reserve (5);
 
       _first = skip_blanks (++_first, _last); // skip '('
@@ -589,7 +589,7 @@ InputIterator pp::handle_define (InputIterator _first, InputIterator _last)
 
       if (*_first == '.')
         {
-          macro.variadics = true;
+          macro.is.variadics = true;
           while (*_first == '.')
             ++_first;
         }
@@ -606,7 +606,7 @@ InputIterator pp::handle_define (InputIterator _first, InputIterator _last)
 
           if (*_first == '.')
             {
-              macro.variadics = true;
+              macro.is.variadics = true;
               while (*_first == '.')
                 ++_first;
             }
diff --git a/generator/parser/rpp/pp-environment.h b/generator/parser/rpp/pp-environment.h
@@ -89,7 +89,7 @@ class pp_environment
   inline void unbind (pp_fast_string const *_name)
   {
     if (pp_macro *m = resolve (_name))
-      m->hidden = true;
+      m->is.hidden = true;
   }
 
   inline void unbind (char const *_s, std::size_t _size)
@@ -103,7 +103,7 @@ class pp_environment
     std::size_t h = hash_code (*_name) % _M_hash_size;
     pp_macro *it = _M_base [h];
 
-    while (it && it->name && it->hash_code == h && (*it->name != *_name || it->hidden))
+    while (it && it->name && it->hash_code == h && (*it->name != *_name || it->is.hidden))
       it = it->next;
 
     return it;
diff --git a/generator/parser/rpp/pp-macro-expander.h b/generator/parser/rpp/pp-macro-expander.h
@@ -250,7 +250,7 @@ class pp_macro_expander
             static bool hide_next = false; // ### remove me
 
             pp_macro *macro = env.resolve (name_buffer, name_size);
-            if (! macro || macro->hidden || hide_next)
+            if (! macro || macro->is.hidden || hide_next)
               {
                 hide_next = ! strcmp (name_buffer, "defined");
 
@@ -278,13 +278,13 @@ class pp_macro_expander
                 continue;
               }
 
-            if (! macro->function_like)
+            if (! macro->is.function_like)
               {
                 pp_macro *m = 0;
 
                 if (macro->definition)
                   {
-                    macro->hidden = true;
+                    macro->is.hidden = true;
 
                     std::string tmp;
                     tmp.reserve (256);
@@ -316,7 +316,7 @@ class pp_macro_expander
                           std::copy (tmp.begin (), tmp.end (), _result);
                       }
 
-                    macro->hidden = false;
+                    macro->is.hidden = false;
                   }
 
                 if (! m)
@@ -370,15 +370,15 @@ class pp_macro_expander
               _first = arg_it;
 
 #if 0 // ### enable me
-              assert ((macro->variadics && macro->formals.size () >= actuals.size ())
+              assert ((macro->is.variadics && macro->formals.size () >= actuals.size ())
                           || macro->formals.size() == actuals.size());
 #endif
 
               pp_frame frame (macro, &actuals);
               pp_macro_expander expand_macro (env, &frame);
-              macro->hidden = true;
+              macro->is.hidden = true;
               expand_macro (macro->definition->begin (), macro->definition->end (), _result);
-              macro->hidden = false;
+              macro->is.hidden = false;
               generated_lines += expand_macro.lines;
           }
         else
@@ -394,7 +394,7 @@ class pp_macro_expander
   {
     InputIterator arg_end = skip_argument (_first, _last);
 
-    while (_macro->variadics && _first != arg_end && arg_end != _last && *arg_end == ','
+    while (_macro->is.variadics && _first != arg_end && arg_end != _last && *arg_end == ','
         && (_actuals.size () + 1) == _macro->formals.size ())
       {
         arg_end = skip_argument (++arg_end, _last);
diff --git a/generator/parser/rpp/pp-macro.h b/generator/parser/rpp/pp-macro.h
@@ -62,7 +62,7 @@ struct pp_macro
       int unsigned hidden: 1;
       int unsigned function_like: 1;
       int unsigned variadics: 1;
-    };
+    } is;
   };
 
   int lines;
diff --git a/generator/parser/rpp/preprocessor.cpp b/generator/parser/rpp/preprocessor.cpp
@@ -143,7 +143,7 @@ QList<Preprocessor::MacroItem> Preprocessor::macros() const
             item.parameters += QString::fromLatin1(m->formals[i]->begin(),
                     m->formals[i]->size());
         }
-        item.isFunctionLike = m->function_like;
+        item.isFunctionLike = m->is.function_like;
 
 #ifdef PP_WITH_MACRO_POSITION
         item.fileName = QString::fromLatin1(m->file->begin(), m->file->size());

Original file line number	Diff line number	Diff line change
`@@ -683,63 +683,63 @@ void _FunctionModelItem::setException(const QString &exception)`
`683`	`683`
`684`	`684`	`bool _FunctionModelItem::isVariadics() const`
`685`	`685`	`{`
`686`		`- return _M_isVariadics;`
	`686`	`+ return _M.isVariadics;`
`687`	`687`	`}`
`688`	`688`
`689`	`689`	`void _FunctionModelItem::setVariadics(bool isVariadics)`
`690`	`690`	`{`
`691`		`- _M_isVariadics = isVariadics;`
	`691`	`+ _M.isVariadics = isVariadics;`
`692`	`692`	`}`
`693`	`693`
`694`	`694`	`bool _FunctionModelItem::isVirtual() const`
`695`	`695`	`{`
`696`		`- return _M_isVirtual;`
	`696`	`+ return _M.isVirtual;`
`697`	`697`	`}`
`698`	`698`
`699`	`699`	`void _FunctionModelItem::setVirtual(bool isVirtual)`
`700`	`700`	`{`
`701`		`- _M_isVirtual = isVirtual;`
	`701`	`+ _M.isVirtual = isVirtual;`
`702`	`702`	`}`
`703`	`703`
`704`	`704`	`bool _FunctionModelItem::isInline() const`
`705`	`705`	`{`
`706`		`- return _M_isInline;`
	`706`	`+ return _M.isInline;`
`707`	`707`	`}`
`708`	`708`
`709`	`709`	`void _FunctionModelItem::setInline(bool isInline)`
`710`	`710`	`{`
`711`		`- _M_isInline = isInline;`
	`711`	`+ _M.isInline = isInline;`
`712`	`712`	`}`
`713`	`713`
`714`	`714`	`bool _FunctionModelItem::isExplicit() const`
`715`	`715`	`{`
`716`		`- return _M_isExplicit;`
	`716`	`+ return _M.isExplicit;`
`717`	`717`	`}`
`718`	`718`
`719`	`719`	`void _FunctionModelItem::setExplicit(bool isExplicit)`
`720`	`720`	`{`
`721`		`- _M_isExplicit = isExplicit;`
	`721`	`+ _M.isExplicit = isExplicit;`
`722`	`722`	`}`
`723`	`723`
`724`	`724`	`bool _FunctionModelItem::isAbstract() const`
`725`	`725`	`{`
`726`		`- return _M_isAbstract;`
	`726`	`+ return _M.isAbstract;`
`727`	`727`	`}`
`728`	`728`
`729`	`729`	`void _FunctionModelItem::setAbstract(bool isAbstract)`
`730`	`730`	`{`
`731`		`- _M_isAbstract = isAbstract;`
	`731`	`+ _M.isAbstract = isAbstract;`
`732`	`732`	`}`
`733`	`733`
`734`	`734`	`// Qt`
`735`	`735`	`bool _FunctionModelItem::isInvokable() const`
`736`	`736`	`{`
`737`		`- return _M_isInvokable;`
	`737`	`+ return _M.isInvokable;`
`738`	`738`	`}`
`739`	`739`
`740`	`740`	`void _FunctionModelItem::setInvokable(bool isInvokable)`
`741`	`741`	`{`
`742`		`- _M_isInvokable = isInvokable;`
	`742`	`+ _M.isInvokable = isInvokable;`
`743`	`743`	`}`
`744`	`744`
`745`	`745`	`// ---------------------------------------------------------------------------`
`@@ -907,92 +907,92 @@ void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)`
`907`	`907`
`908`	`908`	`bool _MemberModelItem::isStatic() const`
`909`	`909`	`{`
`910`		`- return _M_isStatic;`
	`910`	`+ return _M.isStatic;`
`911`	`911`	`}`
`912`	`912`
`913`	`913`	`void _MemberModelItem::setStatic(bool isStatic)`
`914`	`914`	`{`
`915`		`- _M_isStatic = isStatic;`
	`915`	`+ _M.isStatic = isStatic;`
`916`	`916`	`}`
`917`	`917`
`918`	`918`	`bool _MemberModelItem::isConstant() const`
`919`	`919`	`{`
`920`		`- return _M_isConstant;`
	`920`	`+ return _M.isConstant;`
`921`	`921`	`}`
`922`	`922`
`923`	`923`	`void _MemberModelItem::setConstant(bool isConstant)`
`924`	`924`	`{`
`925`		`- _M_isConstant = isConstant;`
	`925`	`+ _M.isConstant = isConstant;`
`926`	`926`	`}`
`927`	`927`
`928`	`928`	`bool _MemberModelItem::isConstexpr() const`
`929`	`929`	`{`
`930`		`- return _M_isConstexpr;`
	`930`	`+ return _M.isConstexpr;`
`931`	`931`	`}`
`932`	`932`
`933`	`933`	`void _MemberModelItem::setConstexpr(bool isConstexpr)`
`934`	`934`	`{`
`935`		`- _M_isConstexpr = isConstexpr;`
	`935`	`+ _M.isConstexpr = isConstexpr;`
`936`	`936`	`}`
`937`	`937`
`938`	`938`	`bool _MemberModelItem::isVolatile() const`
`939`	`939`	`{`
`940`		`- return _M_isVolatile;`
	`940`	`+ return _M.isVolatile;`
`941`	`941`	`}`
`942`	`942`
`943`	`943`	`void _MemberModelItem::setVolatile(bool isVolatile)`
`944`	`944`	`{`
`945`		`- _M_isVolatile = isVolatile;`
	`945`	`+ _M.isVolatile = isVolatile;`
`946`	`946`	`}`
`947`	`947`
`948`	`948`	`bool _MemberModelItem::isAuto() const`
`949`	`949`	`{`
`950`		`- return _M_isAuto;`
	`950`	`+ return _M.isAuto;`
`951`	`951`	`}`
`952`	`952`
`953`	`953`	`void _MemberModelItem::setAuto(bool isAuto)`
`954`	`954`	`{`
`955`		`- _M_isAuto = isAuto;`
	`955`	`+ _M.isAuto = isAuto;`
`956`	`956`	`}`
`957`	`957`
`958`	`958`	`bool _MemberModelItem::isFriend() const`
`959`	`959`	`{`
`960`		`- return _M_isFriend;`
	`960`	`+ return _M.isFriend;`
`961`	`961`	`}`
`962`	`962`
`963`	`963`	`void _MemberModelItem::setFriend(bool isFriend)`
`964`	`964`	`{`
`965`		`- _M_isFriend = isFriend;`
	`965`	`+ _M.isFriend = isFriend;`
`966`	`966`	`}`
`967`	`967`
`968`	`968`	`bool _MemberModelItem::isRegister() const`
`969`	`969`	`{`
`970`		`- return _M_isRegister;`
	`970`	`+ return _M.isRegister;`
`971`	`971`	`}`
`972`	`972`
`973`	`973`	`void _MemberModelItem::setRegister(bool isRegister)`
`974`	`974`	`{`
`975`		`- _M_isRegister = isRegister;`
	`975`	`+ _M.isRegister = isRegister;`
`976`	`976`	`}`
`977`	`977`
`978`	`978`	`bool _MemberModelItem::isExtern() const`
`979`	`979`	`{`
`980`		`- return _M_isExtern;`
	`980`	`+ return _M.isExtern;`
`981`	`981`	`}`
`982`	`982`
`983`	`983`	`void _MemberModelItem::setExtern(bool isExtern)`
`984`	`984`	`{`
`985`		`- _M_isExtern = isExtern;`
	`985`	`+ _M.isExtern = isExtern;`
`986`	`986`	`}`
`987`	`987`
`988`	`988`	`bool _MemberModelItem::isMutable() const`
`989`	`989`	`{`
`990`		`- return _M_isMutable;`
	`990`	`+ return _M.isMutable;`
`991`	`991`	`}`
`992`	`992`
`993`	`993`	`void _MemberModelItem::setMutable(bool isMutable)`
`994`	`994`	`{`
`995`		`- _M_isMutable = isMutable;`
	`995`	`+ _M.isMutable = isMutable;`
`996`	`996`	`}`
`997`	`997`
`998`	`998`	`// kate: space-indent on; indent-width 2; replace-tabs on;`
Original file line number	Diff line number	Diff line change
`@@ -577,7 +577,7 @@ InputIterator pp::handle_define (InputIterator _first, InputIterator _last)`
`577`	`577`
`578`	`578`	`if (_first != _last && *_first == '(')`
`579`	`579`	`{`
`580`		`- macro.function_like = true;`
	`580`	`+ macro.is.function_like = true;`
`581`	`581`	`macro.formals.reserve (5);`
`582`	`582`
`583`	`583`	`_first = skip_blanks (++_first, _last); // skip '('`
`@@ -589,7 +589,7 @@ InputIterator pp::handle_define (InputIterator _first, InputIterator _last)`
`589`	`589`
`590`	`590`	`if (*_first == '.')`
`591`	`591`	`{`
`592`		`- macro.variadics = true;`
	`592`	`+ macro.is.variadics = true;`
`593`	`593`	`while (*_first == '.')`
`594`	`594`	`++_first;`
`595`	`595`	`}`
`@@ -606,7 +606,7 @@ InputIterator pp::handle_define (InputIterator _first, InputIterator _last)`
`606`	`606`
`607`	`607`	`if (*_first == '.')`
`608`	`608`	`{`
`609`		`- macro.variadics = true;`
	`609`	`+ macro.is.variadics = true;`
`610`	`610`	`while (*_first == '.')`
`611`	`611`	`++_first;`
`612`	`612`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ class pp_environment`
`89`	`89`	`inline void unbind (pp_fast_string const *_name)`
`90`	`90`	`{`
`91`	`91`	`if (pp_macro *m = resolve (_name))`
`92`		`- m->hidden = true;`
	`92`	`+ m->is.hidden = true;`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`inline void unbind (char const *_s, std::size_t _size)`
`@@ -103,7 +103,7 @@ class pp_environment`
`103`	`103`	`std::size_t h = hash_code (*_name) % _M_hash_size;`
`104`	`104`	`pp_macro *it = _M_base [h];`
`105`	`105`
`106`		`- while (it && it->name && it->hash_code == h && (it->name != _name \|\| it->hidden))`
	`106`	`+ while (it && it->name && it->hash_code == h && (it->name != _name \|\| it->is.hidden))`
`107`	`107`	`it = it->next;`
`108`	`108`
`109`	`109`	`return it;`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ class pp_macro_expander`
`250`	`250`	`static bool hide_next = false; // ### remove me`
`251`	`251`
`252`	`252`	`pp_macro *macro = env.resolve (name_buffer, name_size);`
`253`		`- if (! macro \|\| macro->hidden \|\| hide_next)`
	`253`	`+ if (! macro \|\| macro->is.hidden \|\| hide_next)`
`254`	`254`	`{`
`255`	`255`	`hide_next = ! strcmp (name_buffer, "defined");`
`256`	`256`
`@@ -278,13 +278,13 @@ class pp_macro_expander`
`278`	`278`	`continue;`
`279`	`279`	`}`
`280`	`280`
`281`		`- if (! macro->function_like)`
	`281`	`+ if (! macro->is.function_like)`
`282`	`282`	`{`
`283`	`283`	`pp_macro *m = 0;`
`284`	`284`
`285`	`285`	`if (macro->definition)`
`286`	`286`	`{`
`287`		`- macro->hidden = true;`
	`287`	`+ macro->is.hidden = true;`
`288`	`288`
`289`	`289`	`std::string tmp;`
`290`	`290`	`tmp.reserve (256);`
`@@ -316,7 +316,7 @@ class pp_macro_expander`
`316`	`316`	`std::copy (tmp.begin (), tmp.end (), _result);`
`317`	`317`	`}`
`318`	`318`
`319`		`- macro->hidden = false;`
	`319`	`+ macro->is.hidden = false;`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`if (! m)`
`@@ -370,15 +370,15 @@ class pp_macro_expander`
`370`	`370`	`_first = arg_it;`
`371`	`371`
`372`	`372`	`#if 0 // ### enable me`
`373`		`- assert ((macro->variadics && macro->formals.size () >= actuals.size ())`
	`373`	`+ assert ((macro->is.variadics && macro->formals.size () >= actuals.size ())`
`374`	`374`	`\|\| macro->formals.size() == actuals.size());`
`375`	`375`	`#endif`
`376`	`376`
`377`	`377`	`pp_frame frame (macro, &actuals);`
`378`	`378`	`pp_macro_expander expand_macro (env, &frame);`
`379`		`- macro->hidden = true;`
	`379`	`+ macro->is.hidden = true;`
`380`	`380`	`expand_macro (macro->definition->begin (), macro->definition->end (), _result);`
`381`		`- macro->hidden = false;`
	`381`	`+ macro->is.hidden = false;`
`382`	`382`	`generated_lines += expand_macro.lines;`
`383`	`383`	`}`
`384`	`384`	`else`
`@@ -394,7 +394,7 @@ class pp_macro_expander`
`394`	`394`	`{`
`395`	`395`	`InputIterator arg_end = skip_argument (_first, _last);`
`396`	`396`
`397`		`- while (_macro->variadics && _first != arg_end && arg_end != _last && *arg_end == ','`
	`397`	`+ while (_macro->is.variadics && _first != arg_end && arg_end != _last && *arg_end == ','`
`398`	`398`	`&& (_actuals.size () + 1) == _macro->formals.size ())`
`399`	`399`	`{`
`400`	`400`	`arg_end = skip_argument (++arg_end, _last);`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ QList<Preprocessor::MacroItem> Preprocessor::macros() const`
`143`	`143`	`item.parameters += QString::fromLatin1(m->formals[i]->begin(),`
`144`	`144`	`m->formals[i]->size());`
`145`	`145`	`}`
`146`		`- item.isFunctionLike = m->function_like;`
	`146`	`+ item.isFunctionLike = m->is.function_like;`
`147`	`147`
`148`	`148`	`#ifdef PP_WITH_MACRO_POSITION`
`149`	`149`	`item.fileName = QString::fromLatin1(m->file->begin(), m->file->size());`