Code model: Fix coding style

Use the m_ convention for member variables and make inline setters
and getters one-liners for better readability.

Task-number: PYSIDE-323
Change-Id: I59583e299bd499f7c966d20e35acfa870c6affc1
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

2 files changed, 232 insertions, 276 deletions

diff --git a/ApiExtractor/parser/codemodel.cpp b/ApiExtractor/parser/codemodel.cpp
index 5c6cc0aea..dd5a6d0bd 100644
--- a/ApiExtractor/parser/codemodel.cpp
+++ b/ApiExtractor/parser/codemodel.cpp
@@ -35,7 +35,7 @@
 
 // ---------------------------------------------------------------------------
 
-CodeModel::CodeModel() : _M_globalNamespace(new _NamespaceModelItem(this))
+CodeModel::CodeModel() : m_globalNamespace(new _NamespaceModelItem(this))
 {
 }
 
@@ -45,22 +45,22 @@ CodeModel::~CodeModel()
 
 FileList CodeModel::files() const
 {
-    return _M_files.values();
+    return m_files.values();
 }
 
 NamespaceModelItem CodeModel::globalNamespace() const
 {
-    return _M_globalNamespace;
+    return m_globalNamespace;
 }
 
 void CodeModel::addFile(FileModelItem item)
 {
-    _M_files.insert(item->name(), item);
+    m_files.insert(item->name(), item);
 }
 
 FileModelItem CodeModel::findFile(const QString &name) const
 {
-    return _M_files.value(name);
+    return m_files.value(name);
 }
 
 CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelItem scope) const
@@ -247,23 +247,23 @@ QDebug operator<<(QDebug d, const TypeInfo &t)
 
 // ---------------------------------------------------------------------------
 _CodeModelItem::_CodeModelItem(CodeModel *model, int kind)
-        : _M_model(model),
-        _M_kind(kind),
-        _M_startLine(0),
-        _M_startColumn(0),
-        _M_endLine(0),
-        _M_endColumn(0)
+        : m_model(model),
+        m_kind(kind),
+        m_startLine(0),
+        m_startColumn(0),
+        m_endLine(0),
+        m_endColumn(0)
 {
 }
 
 _CodeModelItem::_CodeModelItem(CodeModel *model, const QString &name, int kind)
-    : _M_model(model),
-    _M_kind(kind),
-    _M_startLine(0),
-    _M_startColumn(0),
-    _M_endLine(0),
-    _M_endColumn(0),
-    _M_name(name)
+    : m_model(model),
+    m_kind(kind),
+    m_startLine(0),
+    m_startColumn(0),
+    m_endLine(0),
+    m_endColumn(0),
+    m_name(name)
 {
 }
 
@@ -273,7 +273,7 @@ _CodeModelItem::~_CodeModelItem()
 
 int _CodeModelItem::kind() const
 {
-    return _M_kind;
+    return m_kind;
 }
 
 QStringList _CodeModelItem::qualifiedName() const
@@ -288,32 +288,32 @@ QStringList _CodeModelItem::qualifiedName() const
 
 QString _CodeModelItem::name() const
 {
-    return _M_name;
+    return m_name;
 }
 
 void _CodeModelItem::setName(const QString &name)
 {
-    _M_name = name;
+    m_name = name;
 }
 
 QStringList _CodeModelItem::scope() const
 {
-    return _M_scope;
+    return m_scope;
 }
 
 void _CodeModelItem::setScope(const QStringList &scope)
 {
-    _M_scope = scope;
+    m_scope = scope;
 }
 
 QString _CodeModelItem::fileName() const
 {
-    return _M_fileName;
+    return m_fileName;
 }
 
 void _CodeModelItem::setFileName(const QString &fileName)
 {
-    _M_fileName = fileName;
+    m_fileName = fileName;
 }
 
 FileModelItem _CodeModelItem::file() const
@@ -323,26 +323,26 @@ FileModelItem _CodeModelItem::file() const
 
 void _CodeModelItem::getStartPosition(int *line, int *column)
 {
-    *line = _M_startLine;
-    *column = _M_startColumn;
+    *line = m_startLine;
+    *column = m_startColumn;
 }
 
 void _CodeModelItem::setStartPosition(int line, int column)
 {
-    _M_startLine = line;
-    _M_startColumn = column;
+    m_startLine = line;
+    m_startColumn = column;
 }
 
 void _CodeModelItem::getEndPosition(int *line, int *column)
 {
-    *line = _M_endLine;
-    *column = _M_endColumn;
+    *line = m_endLine;
+    *column = m_endColumn;
 }
 
 void _CodeModelItem::setEndPosition(int line, int column)
 {
-    _M_endLine = line;
-    _M_endColumn = column;
+    m_endLine = line;
+    m_endColumn = column;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -396,9 +396,9 @@ void _CodeModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatKind(d, kind());
      d << ", \"" << name() << '"';
-     if (!_M_scope.isEmpty()) {
+     if (!m_scope.isEmpty()) {
          d << ", scope=";
-         formatSequence(d, _M_scope.cbegin(), _M_scope.cend(), "::");
+         formatSequence(d, m_scope.cbegin(), m_scope.cend(), "::");
      }
 }
 
@@ -424,47 +424,47 @@ _ClassModelItem::~_ClassModelItem()
 
 QStringList _ClassModelItem::baseClasses() const
 {
-    return _M_baseClasses;
+    return m_baseClasses;
 }
 
 void _ClassModelItem::setBaseClasses(const QStringList &baseClasses)
 {
-    _M_baseClasses = baseClasses;
+    m_baseClasses = baseClasses;
 }
 
 TemplateParameterList _ClassModelItem::templateParameters() const
 {
-    return _M_templateParameters;
+    return m_templateParameters;
 }
 
 void _ClassModelItem::setTemplateParameters(const TemplateParameterList &templateParameters)
 {
-    _M_templateParameters = templateParameters;
+    m_templateParameters = templateParameters;
 }
 
 void _ClassModelItem::addBaseClass(const QString &baseClass)
 {
-    _M_baseClasses.append(baseClass);
+    m_baseClasses.append(baseClass);
 }
 
 bool _ClassModelItem::extendsClass(const QString &name) const
 {
-    return _M_baseClasses.contains(name);
+    return m_baseClasses.contains(name);
 }
 
 void _ClassModelItem::setClassType(CodeModel::ClassType type)
 {
-    _M_classType = type;
+    m_classType = type;
 }
 
 CodeModel::ClassType _ClassModelItem::classType() const
 {
-    return _M_classType;
+    return m_classType;
 }
 
 void _ClassModelItem::addPropertyDeclaration(const QString &propertyDeclaration)
 {
-    _M_propertyDeclarations << propertyDeclaration;
+    m_propertyDeclarations << propertyDeclaration;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -485,9 +485,9 @@ static void formatModelItemList(QDebug &d, const char *prefix, const List &l)
 void _ClassModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    if (!_M_baseClasses.isEmpty())
-        d << ", inherits=" << _M_baseClasses;
-    formatModelItemList(d, ", templateParameters=", _M_templateParameters);
+    if (!m_baseClasses.isEmpty())
+        d << ", inherits=" << m_baseClasses;
+    formatModelItemList(d, ", templateParameters=", m_templateParameters);
     formatScopeItemsDebug(d);
 }
 #endif // !QT_NO_DEBUG_STREAM
@@ -511,7 +511,7 @@ _ScopeModelItem::~_ScopeModelItem()
 
 ClassList _ScopeModelItem::classes() const
 {
-    ClassList result = _M_classes.values();
+    ClassList result = m_classes.values();
     qSort(result);
     ClassList::iterator it = std::unique(result.begin(), result.end());
     result.erase(it, result.end());
@@ -520,34 +520,34 @@ ClassList _ScopeModelItem::classes() const
 
 TypeDefList _ScopeModelItem::typeDefs() const
 {
-    return _M_typeDefs.values();
+    return m_typeDefs.values();
 }
 
 VariableList _ScopeModelItem::variables() const
 {
-    return _M_variables.values();
+    return m_variables.values();
 }
 
 FunctionList _ScopeModelItem::functions() const
 {
-    return _M_functions.values();
+    return m_functions.values();
 }
 
 void _ScopeModelItem::addEnumsDeclaration(const QString &enumsDeclaration)
 {
-    _M_enumsDeclarations << enumsDeclaration;
+    m_enumsDeclarations << enumsDeclaration;
 }
 
 FunctionDefinitionList _ScopeModelItem::functionDefinitions() const
 {
-    return _M_functionDefinitions.values();
+    return m_functionDefinitions.values();
 }
 
 EnumList _ScopeModelItem::enums() const
 {
     EnumList result;
-    foreach (const QString& name, _M_enumNames)
-        result.append(_M_enums.value(name));
+    foreach (const QString& name, m_enumNames)
+        result.append(m_enums.value(name));
     return result;
 }
 
@@ -556,35 +556,35 @@ void _ScopeModelItem::addClass(ClassModelItem item)
     QString name = item->name();
     int idx = name.indexOf(QLatin1Char('<'));
     if (idx > 0)
-        _M_classes.insert(name.left(idx), item);
-    _M_classes.insert(name, item);
+        m_classes.insert(name.left(idx), item);
+    m_classes.insert(name, item);
 }
 
 void _ScopeModelItem::addFunction(FunctionModelItem item)
 {
-    _M_functions.insert(item->name(), item);
+    m_functions.insert(item->name(), item);
 }
 
 void _ScopeModelItem::addFunctionDefinition(FunctionDefinitionModelItem item)
 {
-    _M_functionDefinitions.insert(item->name(), item);
+    m_functionDefinitions.insert(item->name(), item);
 }
 
 void _ScopeModelItem::addVariable(VariableModelItem item)
 {
-    _M_variables.insert(item->name(), item);
+    m_variables.insert(item->name(), item);
 }
 
 void _ScopeModelItem::addTypeDef(TypeDefModelItem item)
 {
-    _M_typeDefs.insert(item->name(), item);
+    m_typeDefs.insert(item->name(), item);
 }
 
 void _ScopeModelItem::addEnum(EnumModelItem item)
 {
-    _M_enumNames.removeOne(item->name());
-    _M_enums.insert(item->name(), item);
-    _M_enumNames.append(item->name());
+    m_enumNames.removeOne(item->name());
+    m_enums.insert(item->name(), item);
+    m_enumNames.append(item->name());
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -607,11 +607,11 @@ static void formatScopeHash(QDebug &d, const char *prefix, const Hash &h)
 
 void _ScopeModelItem::formatScopeItemsDebug(QDebug &d) const
 {
-    formatScopeHash(d, ", classes=", _M_classes);
-    formatScopeHash(d, ", enums=", _M_enums);
-    formatScopeHash(d, ", aliases=", _M_typeDefs);
-    formatScopeHash(d, ", functionDefs=", _M_functionDefinitions);
-    formatScopeHash(d, ", functions=", _M_functions);
+    formatScopeHash(d, ", classes=", m_classes);
+    formatScopeHash(d, ", enums=", m_enums);
+    formatScopeHash(d, ", aliases=", m_typeDefs);
+    formatScopeHash(d, ", functionDefs=", m_functionDefinitions);
+    formatScopeHash(d, ", functions=", m_functions);
 }
 
 void  _ScopeModelItem::formatDebug(QDebug &d) const
@@ -623,32 +623,32 @@ void  _ScopeModelItem::formatDebug(QDebug &d) const
 
 ClassModelItem _ScopeModelItem::findClass(const QString &name) const
 {
-    return _M_classes.value(name);
+    return m_classes.value(name);
 }
 
 VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
 {
-    return _M_variables.value(name);
+    return m_variables.value(name);
 }
 
 TypeDefModelItem _ScopeModelItem::findTypeDef(const QString &name) const
 {
-    return _M_typeDefs.value(name);
+    return m_typeDefs.value(name);
 }
 
 EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
 {
-    return _M_enums.value(name);
+    return m_enums.value(name);
 }
 
 FunctionList _ScopeModelItem::findFunctions(const QString &name) const
 {
-    return _M_functions.values(name);
+    return m_functions.values(name);
 }
 
 FunctionDefinitionList _ScopeModelItem::findFunctionDefinitions(const QString &name) const
 {
-    return _M_functionDefinitions.values(name);
+    return m_functionDefinitions.values(name);
 }
 
 // ---------------------------------------------------------------------------
@@ -658,16 +658,16 @@ _NamespaceModelItem::~_NamespaceModelItem()
 
 NamespaceList _NamespaceModelItem::namespaces() const
 {
-    return _M_namespaces.values();
+    return m_namespaces.values();
 }
 void _NamespaceModelItem::addNamespace(NamespaceModelItem item)
 {
-    _M_namespaces.insert(item->name(), item);
+    m_namespaces.insert(item->name(), item);
 }
 
 NamespaceModelItem _NamespaceModelItem::findNamespace(const QString &name) const
 {
-    return _M_namespaces.value(name);
+    return m_namespaces.value(name);
 }
 
 _FileModelItem::~_FileModelItem()
@@ -678,7 +678,7 @@ _FileModelItem::~_FileModelItem()
 void _NamespaceModelItem::formatDebug(QDebug &d) const
 {
     _ScopeModelItem::formatDebug(d);
-    formatScopeHash(d, ", namespaces=", _M_namespaces);
+    formatScopeHash(d, ", namespaces=", m_namespaces);
 }
 #endif // !QT_NO_DEBUG_STREAM
 
@@ -689,31 +689,31 @@ _ArgumentModelItem::~_ArgumentModelItem()
 
 TypeInfo _ArgumentModelItem::type() const
 {
-    return _M_type;
+    return m_type;
 }
 
 void _ArgumentModelItem::setType(const TypeInfo &type)
 {
-    _M_type = type;
+    m_type = type;
 }
 
 bool _ArgumentModelItem::defaultValue() const
 {
-    return _M_defaultValue;
+    return m_defaultValue;
 }
 
 void _ArgumentModelItem::setDefaultValue(bool defaultValue)
 {
-    _M_defaultValue = defaultValue;
+    m_defaultValue = defaultValue;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 void _ArgumentModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    d << ", type=" << _M_type;
-    if (_M_defaultValue)
-        d << ", defaultValue=\"" << _M_defaultValueExpression << '"';
+    d << ", type=" << m_type;
+    if (m_defaultValue)
+        d << ", defaultValue=\"" << m_defaultValueExpression << '"';
 }
 #endif // !QT_NO_DEBUG_STREAM
 // ---------------------------------------------------------------------------
@@ -750,83 +750,83 @@ bool _FunctionModelItem::isSimilar(FunctionModelItem other) const
 
 ArgumentList _FunctionModelItem::arguments() const
 {
-    return _M_arguments;
+    return m_arguments;
 }
 
 void _FunctionModelItem::addArgument(ArgumentModelItem item)
 {
-    _M_arguments.append(item);
+    m_arguments.append(item);
 }
 
 CodeModel::FunctionType _FunctionModelItem::functionType() const
 {
-    return _M_functionType;
+    return m_functionType;
 }
 
 void _FunctionModelItem::setFunctionType(CodeModel::FunctionType functionType)
 {
-    _M_functionType = functionType;
+    m_functionType = functionType;
 }
 
 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;
 }
 
 _FunctionDefinitionModelItem::~_FunctionDefinitionModelItem()
@@ -837,17 +837,17 @@ _FunctionDefinitionModelItem::~_FunctionDefinitionModelItem()
 void _FunctionModelItem::formatDebug(QDebug &d) const
 {
     _MemberModelItem::formatDebug(d);
-    d << ", type=" << _M_functionType;
-    if (_M_isInline)
+    d << ", type=" << m_functionType;
+    if (m_isInline)
         d << " [inline]";
-    if (_M_isAbstract)
+    if (m_isAbstract)
         d << " [abstract]";
-    if (_M_isExplicit)
+    if (m_isExplicit)
         d << " [explicit]";
-    if (_M_isInvokable)
+    if (m_isInvokable)
         d << " [invokable]";
-    formatModelItemList(d, ", arguments=", _M_arguments);
-    if (_M_isVariadics)
+    formatModelItemList(d, ", arguments=", m_arguments);
+    if (m_isVariadics)
         d << ",...";
 }
 #endif // !QT_NO_DEBUG_STREAM
@@ -855,26 +855,26 @@ void _FunctionModelItem::formatDebug(QDebug &d) const
 // ---------------------------------------------------------------------------
 TypeInfo _TypeDefModelItem::type() const
 {
-    return _M_type;
+    return m_type;
 }
 
 void _TypeDefModelItem::setType(const TypeInfo &type)
 {
-    _M_type = type;
+    m_type = type;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 void _TypeDefModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    d << ", type=" << _M_type;
+    d << ", type=" << m_type;
 }
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
 CodeModel::AccessPolicy _EnumModelItem::accessPolicy() const
 {
-    return _M_accessPolicy;
+    return m_accessPolicy;
 }
 
 _EnumModelItem::~_EnumModelItem()
@@ -883,36 +883,36 @@ _EnumModelItem::~_EnumModelItem()
 
 void _EnumModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 {
-    _M_accessPolicy = accessPolicy;
+    m_accessPolicy = accessPolicy;
 }
 
 EnumeratorList _EnumModelItem::enumerators() const
 {
-    return _M_enumerators;
+    return m_enumerators;
 }
 
 void _EnumModelItem::addEnumerator(EnumeratorModelItem item)
 {
-    _M_enumerators.append(item);
+    m_enumerators.append(item);
 }
 
 bool _EnumModelItem::isAnonymous() const
 {
-    return _M_anonymous;
+    return m_anonymous;
 }
 
 void _EnumModelItem::setAnonymous(bool anonymous)
 {
-    _M_anonymous = anonymous;
+    m_anonymous = anonymous;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 void _EnumModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    if (_M_anonymous)
+    if (m_anonymous)
          d << " (anonymous)";
-    formatModelItemList(d, ", enumerators=", _M_enumerators);
+    formatModelItemList(d, ", enumerators=", m_enumerators);
 }
 #endif // !QT_NO_DEBUG_STREAM
 
@@ -923,20 +923,20 @@ _EnumeratorModelItem::~_EnumeratorModelItem()
 
 QString _EnumeratorModelItem::value() const
 {
-    return _M_value;
+    return m_value;
 }
 
 void _EnumeratorModelItem::setValue(const QString &value)
 {
-    _M_value = value;
+    m_value = value;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 void _EnumeratorModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    if (!_M_value.isEmpty())
-        d << ", value=\"" << _M_value << '"';
+    if (!m_value.isEmpty())
+        d << ", value=\"" << m_value << '"';
 }
 #endif // !QT_NO_DEBUG_STREAM
 
@@ -947,30 +947,30 @@ _TemplateParameterModelItem::~_TemplateParameterModelItem()
 
 TypeInfo _TemplateParameterModelItem::type() const
 {
-    return _M_type;
+    return m_type;
 }
 
 void _TemplateParameterModelItem::setType(const TypeInfo &type)
 {
-    _M_type = type;
+    m_type = type;
 }
 
 bool _TemplateParameterModelItem::defaultValue() const
 {
-    return _M_defaultValue;
+    return m_defaultValue;
 }
 
 void _TemplateParameterModelItem::setDefaultValue(bool defaultValue)
 {
-    _M_defaultValue = defaultValue;
+    m_defaultValue = defaultValue;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 void _TemplateParameterModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    d << ", type=" << _M_type;
-    if (_M_defaultValue)
+    d << ", type=" << m_type;
+    if (m_defaultValue)
         d << " [defaultValue]";
 }
 #endif // !QT_NO_DEBUG_STREAM
@@ -978,17 +978,17 @@ void _TemplateParameterModelItem::formatDebug(QDebug &d) const
 // ---------------------------------------------------------------------------
 TypeInfo _MemberModelItem::type() const
 {
-    return _M_type;
+    return m_type;
 }
 
 void _MemberModelItem::setType(const TypeInfo &type)
 {
-    _M_type = type;
+    m_type = type;
 }
 
 CodeModel::AccessPolicy _MemberModelItem::accessPolicy() const
 {
-    return _M_accessPolicy;
+    return m_accessPolicy;
 }
 
 _MemberModelItem::~_MemberModelItem()
@@ -997,94 +997,94 @@ _MemberModelItem::~_MemberModelItem()
 
 void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 {
-    _M_accessPolicy = accessPolicy;
+    m_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::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;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 void _MemberModelItem::formatDebug(QDebug &d) const
 {
     _CodeModelItem::formatDebug(d);
-    d << ", type=" << _M_type;
+    d << ", type=" << m_type;
 }
 #endif // !QT_NO_DEBUG_STREAM
 
diff --git a/ApiExtractor/parser/codemodel.h b/ApiExtractor/parser/codemodel.h
index 2d5875927..15a001652 100644
--- a/ApiExtractor/parser/codemodel.h
+++ b/ApiExtractor/parser/codemodel.h
@@ -78,8 +78,8 @@ public:
     CodeModelItem findItem(const QStringList &qualifiedName, CodeModelItem scope) const;
 
 private:
-    QHash<QString, FileModelItem> _M_files;
-    NamespaceModelItem _M_globalNamespace;
+    QHash<QString, FileModelItem> m_files;
+    NamespaceModelItem m_globalNamespace;
 
 private:
     CodeModel(const CodeModel &other);
@@ -263,10 +263,7 @@ public:
     void getEndPosition(int *line, int *column);
     void setEndPosition(int line, int column);
 
-    inline CodeModel *model() const
-    {
-        return _M_model;
-    }
+    inline CodeModel *model() const { return m_model; }
 
 #ifndef QT_NO_DEBUG_STREAM
     static void formatKind(QDebug &d, int k);
@@ -278,15 +275,15 @@ protected:
     explicit _CodeModelItem(CodeModel *model, const QString &name, int kind);
 
 private:
-    CodeModel *_M_model;
-    int _M_kind;
-    int _M_startLine;
-    int _M_startColumn;
-    int _M_endLine;
-    int _M_endColumn;
-    QString _M_name;
-    QString _M_fileName;
-    QStringList _M_scope;
+    CodeModel *m_model;
+    int m_kind;
+    int m_startLine;
+    int m_startColumn;
+    int m_endLine;
+    int m_endColumn;
+    QString m_name;
+    QString m_fileName;
+    QStringList m_scope;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -322,35 +319,14 @@ public:
     VariableModelItem findVariable(const QString &name) const;
 
     void addEnumsDeclaration(const QString &enumsDeclaration);
-    QStringList enumsDeclarations() const
-    {
-        return _M_enumsDeclarations;
-    }
+    QStringList enumsDeclarations() const { return m_enumsDeclarations; }
 
-    inline QHash<QString, ClassModelItem> classMap() const
-    {
-        return _M_classes;
-    }
-    inline QHash<QString, EnumModelItem> enumMap() const
-    {
-        return _M_enums;
-    }
-    inline QHash<QString, TypeDefModelItem> typeDefMap() const
-    {
-        return _M_typeDefs;
-    }
-    inline QHash<QString, VariableModelItem> variableMap() const
-    {
-        return _M_variables;
-    }
-    inline QMultiHash<QString, FunctionDefinitionModelItem> functionDefinitionMap() const
-    {
-        return _M_functionDefinitions;
-    }
-    inline QMultiHash<QString, FunctionModelItem> functionMap() const
-    {
-        return _M_functions;
-    }
+    inline QHash<QString, ClassModelItem> classMap() const { return m_classes; }
+    inline QHash<QString, EnumModelItem> enumMap() const { return m_enums; }
+    inline QHash<QString, TypeDefModelItem> typeDefMap() const { return m_typeDefs; }
+    inline QHash<QString, VariableModelItem> variableMap() const { return m_variables; }
+    inline QMultiHash<QString, FunctionDefinitionModelItem> functionDefinitionMap() const { return m_functionDefinitions; }
+    inline QMultiHash<QString, FunctionModelItem> functionMap() const { return m_functions; }
 
     FunctionModelItem declaredFunction(FunctionModelItem item);
 
@@ -369,16 +345,16 @@ protected:
 #endif
 
 private:
-    QHash<QString, ClassModelItem> _M_classes;
-    QHash<QString, EnumModelItem> _M_enums;
-    QHash<QString, TypeDefModelItem> _M_typeDefs;
-    QHash<QString, VariableModelItem> _M_variables;
-    QMultiHash<QString, FunctionDefinitionModelItem> _M_functionDefinitions;
-    QMultiHash<QString, FunctionModelItem> _M_functions;
+    QHash<QString, ClassModelItem> m_classes;
+    QHash<QString, EnumModelItem> m_enums;
+    QHash<QString, TypeDefModelItem> m_typeDefs;
+    QHash<QString, VariableModelItem> m_variables;
+    QMultiHash<QString, FunctionDefinitionModelItem> m_functionDefinitions;
+    QMultiHash<QString, FunctionModelItem> m_functions;
 
 private:
-    QStringList _M_enumNames;
-    QStringList _M_enumsDeclarations;
+    QStringList m_enumNames;
+    QStringList m_enumsDeclarations;
 };
 
 class _ClassModelItem: public _ScopeModelItem
@@ -387,9 +363,9 @@ public:
     DECLARE_MODEL_NODE(Class)
 
     explicit _ClassModelItem(CodeModel *model, int kind = __node_kind)
-        : _ScopeModelItem(model, kind), _M_classType(CodeModel::Class) {}
+        : _ScopeModelItem(model, kind), m_classType(CodeModel::Class) {}
     explicit _ClassModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _ScopeModelItem(model, name, kind), _M_classType(CodeModel::Class) {}
+        : _ScopeModelItem(model, name, kind), m_classType(CodeModel::Class) {}
     ~_ClassModelItem();
 
     QStringList baseClasses() const;
@@ -406,21 +382,18 @@ public:
     CodeModel::ClassType classType() const;
 
     void addPropertyDeclaration(const QString &propertyDeclaration);
-    QStringList propertyDeclarations() const
-    {
-        return _M_propertyDeclarations;
-    }
+    QStringList propertyDeclarations() const { return m_propertyDeclarations; }
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const Q_DECL_OVERRIDE;
 #endif
 
 private:
-    QStringList _M_baseClasses;
-    TemplateParameterList _M_templateParameters;
-    CodeModel::ClassType _M_classType;
+    QStringList m_baseClasses;
+    TemplateParameterList m_templateParameters;
+    CodeModel::ClassType m_classType;
 
-    QStringList _M_propertyDeclarations;
+    QStringList m_propertyDeclarations;
 };
 
 class _NamespaceModelItem: public _ScopeModelItem
@@ -440,17 +413,14 @@ public:
 
     NamespaceModelItem findNamespace(const QString &name) const;
 
-    inline QHash<QString, NamespaceModelItem> namespaceMap() const
-    {
-        return _M_namespaces;
-    };
+    inline QHash<QString, NamespaceModelItem> namespaceMap() const { return m_namespaces; };
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const Q_DECL_OVERRIDE;
 #endif
 
 private:
-    QHash<QString, NamespaceModelItem> _M_namespaces;
+    QHash<QString, NamespaceModelItem> m_namespaces;
 };
 
 class _FileModelItem: public _NamespaceModelItem
@@ -471,9 +441,9 @@ public:
     DECLARE_MODEL_NODE(Argument)
 
     explicit _ArgumentModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), _M_defaultValue(false) {}
+        : _CodeModelItem(model, kind), m_defaultValue(false) {}
     explicit _ArgumentModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), _M_defaultValue(false) {}
+        : _CodeModelItem(model, name, kind), m_defaultValue(false) {}
     ~_ArgumentModelItem();
 
     TypeInfo type() const;
@@ -482,24 +452,17 @@ public:
     bool defaultValue() const;
     void setDefaultValue(bool defaultValue);
 
-    QString defaultValueExpression() const
-    {
-        return _M_defaultValueExpression;
-    }
-
-    void setDefaultValueExpression(const QString &expr)
-    {
-        _M_defaultValueExpression = expr;
-    }
+    QString defaultValueExpression() const { return m_defaultValueExpression; }
+    void setDefaultValueExpression(const QString &expr) { m_defaultValueExpression = expr; }
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const Q_DECL_OVERRIDE;
 #endif
 
 private:
-    TypeInfo _M_type;
-    QString _M_defaultValueExpression;
-    bool _M_defaultValue;
+    TypeInfo m_type;
+    QString m_defaultValueExpression;
+    bool m_defaultValue;
 };
 
 class _MemberModelItem: public _CodeModelItem
@@ -508,9 +471,9 @@ public:
     DECLARE_MODEL_NODE(Member)
 
     explicit _MemberModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), _M_accessPolicy(CodeModel::Public), _M_flags(0) {}
+        : _CodeModelItem(model, kind), m_accessPolicy(CodeModel::Public), m_flags(0) {}
     explicit _MemberModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), _M_accessPolicy(CodeModel::Public), _M_flags(0) {}
+        : _CodeModelItem(model, name, kind), m_accessPolicy(CodeModel::Public), m_flags(0) {}
     ~_MemberModelItem();
 
     bool isConstant() const;
@@ -540,15 +503,8 @@ public:
     CodeModel::AccessPolicy accessPolicy() const;
     void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 
-    TemplateParameterList templateParameters() const
-    {
-        return _M_templateParameters;
-    }
-
-    void setTemplateParameters(const TemplateParameterList &templateParameters)
-    {
-        _M_templateParameters = templateParameters;
-    }
+    TemplateParameterList templateParameters() const { return m_templateParameters; }
+    void setTemplateParameters(const TemplateParameterList &templateParameters) { m_templateParameters = templateParameters; }
 
     TypeInfo type() const;
     void setType(const TypeInfo &type);
@@ -558,21 +514,21 @@ public:
 #endif
 
 private:
-    TemplateParameterList _M_templateParameters;
-    TypeInfo _M_type;
-    CodeModel::AccessPolicy _M_accessPolicy;
+    TemplateParameterList m_templateParameters;
+    TypeInfo m_type;
+    CodeModel::AccessPolicy m_accessPolicy;
     union {
         struct {
-            uint _M_isConstant: 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 m_isConstant: 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 _M_flags;
+        uint m_flags;
     };
 
 };
@@ -583,9 +539,9 @@ public:
     DECLARE_MODEL_NODE(Function)
 
     explicit _FunctionModelItem(CodeModel *model, int kind = __node_kind)
-        : _MemberModelItem(model, kind), _M_functionType(CodeModel::Normal), _M_flags(0) {}
+        : _MemberModelItem(model, kind), m_functionType(CodeModel::Normal), m_flags(0) {}
     explicit _FunctionModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _MemberModelItem(model, name, kind), _M_functionType(CodeModel::Normal), _M_flags(0) {}
+        : _MemberModelItem(model, name, kind), m_functionType(CodeModel::Normal), m_flags(0) {}
     ~_FunctionModelItem();
 
     ArgumentList arguments() const;
@@ -620,18 +576,18 @@ public:
 #endif
 
 private:
-    ArgumentList _M_arguments;
-    CodeModel::FunctionType _M_functionType;
+    ArgumentList m_arguments;
+    CodeModel::FunctionType m_functionType;
     union {
         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 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 _M_flags;
+        uint m_flags;
     };
 };
 
@@ -676,7 +632,7 @@ public:
 #endif
 
 private:
-    TypeInfo _M_type;
+    TypeInfo m_type;
 };
 
 class _EnumModelItem: public _CodeModelItem
@@ -685,9 +641,9 @@ public:
     DECLARE_MODEL_NODE(Enum)
 
     explicit _EnumModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), _M_accessPolicy(CodeModel::Public), _M_anonymous(false)  {}
+        : _CodeModelItem(model, kind), m_accessPolicy(CodeModel::Public), m_anonymous(false)  {}
     explicit _EnumModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), _M_accessPolicy(CodeModel::Public), _M_anonymous(false) {}
+        : _CodeModelItem(model, name, kind), m_accessPolicy(CodeModel::Public), m_anonymous(false) {}
     ~_EnumModelItem();
 
     CodeModel::AccessPolicy accessPolicy() const;
@@ -703,9 +659,9 @@ public:
 #endif
 
 private:
-    CodeModel::AccessPolicy _M_accessPolicy;
-    EnumeratorList _M_enumerators;
-    bool _M_anonymous;
+    CodeModel::AccessPolicy m_accessPolicy;
+    EnumeratorList m_enumerators;
+    bool m_anonymous;
 };
 
 class _EnumeratorModelItem: public _CodeModelItem
@@ -727,7 +683,7 @@ public:
 #endif
 
 private:
-    QString _M_value;
+    QString m_value;
 };
 
 class _TemplateParameterModelItem: public _CodeModelItem
@@ -736,9 +692,9 @@ public:
     DECLARE_MODEL_NODE(TemplateParameter)
 
     explicit _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind)
-        : _CodeModelItem(model, kind), _M_defaultValue(false) {}
+        : _CodeModelItem(model, kind), m_defaultValue(false) {}
     explicit _TemplateParameterModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
-        : _CodeModelItem(model, name, kind), _M_defaultValue(false) {}
+        : _CodeModelItem(model, name, kind), m_defaultValue(false) {}
     ~_TemplateParameterModelItem();
 
     TypeInfo type() const;
@@ -752,8 +708,8 @@ public:
 #endif
 
 private:
-    TypeInfo _M_type;
-    bool _M_defaultValue;
+    TypeInfo m_type;
+    bool m_defaultValue;
 };
 
 #endif // CODEMODEL_H