CPlusPlus: Make (sub-)languague selection more generic

Change-Id: I4e2df6992b446adec662ab07671acd41715e41fd
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@digia.com>

1 files changed, 63 insertions, 82 deletions

diff --git a/src/libs/3rdparty/cplusplus/Parser.cpp b/src/libs/3rdparty/cplusplus/Parser.cpp
index bf79803854..c4b4072e83 100644
--- a/src/libs/3rdparty/cplusplus/Parser.cpp
+++ b/src/libs/3rdparty/cplusplus/Parser.cpp
@@ -169,13 +169,11 @@ inline bool isRightAssociative(int tokenKind)
 
 Parser::Parser(TranslationUnit *unit)
     : _translationUnit(unit),
-      _control(_translationUnit->control()),
-      _pool(_translationUnit->memoryPool()),
+      _control(unit->control()),
+      _pool(unit->memoryPool()),
+      _languageFeatures(unit->languageFeatures()),
       _tokenIndex(1),
       _templateArguments(0),
-      _qtMocRunEnabled(false),
-      _cxx0xEnabled(false),
-      _objCEnabled(false),
       _inFunctionBody(false),
       _inObjCImplementationContext(false),
       _inExpressionStatement(false),
@@ -186,24 +184,6 @@ Parser::Parser(TranslationUnit *unit)
 Parser::~Parser()
 { }
 
-bool Parser::qtMocRunEnabled() const
-{ return _qtMocRunEnabled; }
-
-void Parser::setQtMocRunEnabled(bool onoff)
-{ _qtMocRunEnabled = onoff; }
-
-bool Parser::cxx0xEnabled() const
-{ return _cxx0xEnabled; }
-
-void Parser::setCxxOxEnabled(bool onoff)
-{ _cxx0xEnabled = onoff; }
-
-bool Parser::objCEnabled() const
-{ return _objCEnabled; }
-
-void Parser::setObjCEnabled(bool onoff)
-{ _objCEnabled = onoff; }
-
 bool Parser::switchTemplateArguments(bool templateArguments)
 {
     bool previousTemplateArguments = _templateArguments;
@@ -336,7 +316,7 @@ bool Parser::skipUntilStatement()
             case T_AT_TRY:
             case T_AT_SYNCHRONIZED:
             case T_AT_THROW:
-                if (objCEnabled())
+                if (_languageFeatures.objCEnabled)
                     return true;
 
             default:
@@ -640,17 +620,17 @@ bool Parser::parseDeclaration(DeclarationAST *&node)
         break;
 
     case T_INLINE:
-        if (_cxx0xEnabled && LA(2) == T_NAMESPACE)
+        if (_languageFeatures.cxx11Enabled && LA(2) == T_NAMESPACE)
             return parseNamespace(node);
         return parseSimpleDeclaration(node);
 
     case T_STATIC_ASSERT:
-        if (_cxx0xEnabled)
+        if (_languageFeatures.cxx11Enabled)
             return parseStaticAssertDeclaration(node);
         return parseSimpleDeclaration(node);
 
     default: {
-        if (_objCEnabled && LA() == T___ATTRIBUTE__) {
+        if (_languageFeatures.objCEnabled && LA() == T___ATTRIBUTE__) {
             const unsigned start = cursor();
             SpecifierListAST *attributes = 0, **attr = &attributes;
             while (parseAttributeSpecifier(*attr))
@@ -753,11 +733,11 @@ bool Parser::parseStaticAssertDeclaration(DeclarationAST *&node)
 bool Parser::parseNamespace(DeclarationAST *&node)
 {
     DEBUG_THIS_RULE();
-    if (LA() != T_NAMESPACE && !(_cxx0xEnabled && LA() == T_INLINE && LA(2) == T_NAMESPACE))
+    if (LA() != T_NAMESPACE && !(_languageFeatures.cxx11Enabled && LA() == T_INLINE && LA(2) == T_NAMESPACE))
         return false;
 
     unsigned inline_token = 0;
-    if (cxx0xEnabled() && LA() == T_INLINE)
+    if (_languageFeatures.cxx11Enabled && LA() == T_INLINE)
         inline_token = consumeToken();
 
     unsigned namespace_token = consumeToken();
@@ -826,7 +806,7 @@ bool Parser::parseUsing(DeclarationAST *&node)
     if (LA(2) == T_NAMESPACE)
         return parseUsingDirective(node);
 
-    if (_cxx0xEnabled && LA(2) == T_IDENTIFIER && parseAliasDeclaration(node))
+    if (_languageFeatures.cxx11Enabled && LA(2) == T_IDENTIFIER && parseAliasDeclaration(node))
         return true;
 
     UsingAST *ast = new (_pool) UsingAST;
@@ -953,12 +933,13 @@ bool Parser::parseTemplateArgumentList(ExpressionListAST *&node)
 
     ExpressionListAST **template_argument_ptr = &node;
     ExpressionAST *template_argument = 0;
+    const bool cxx11Enabled = _languageFeatures.cxx11Enabled;
     if (parseTemplateArgument(template_argument)) {
         *template_argument_ptr = new (_pool) ExpressionListAST;
         (*template_argument_ptr)->value = template_argument;
         template_argument_ptr = &(*template_argument_ptr)->next;
 
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+        if (cxx11Enabled && LA() == T_DOT_DOT_DOT)
             consumeToken(); // ### store this token in the AST
 
         while (LA() == T_COMMA) {
@@ -969,7 +950,7 @@ bool Parser::parseTemplateArgumentList(ExpressionListAST *&node)
                 (*template_argument_ptr)->value = template_argument;
                 template_argument_ptr = &(*template_argument_ptr)->next;
 
-                if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+                if (cxx11Enabled && LA() == T_DOT_DOT_DOT)
                     consumeToken(); // ### store this token in the AST
             }
         }
@@ -1230,7 +1211,7 @@ bool Parser::parseRefQualifier(unsigned &ref_qualifier)
 {
     DEBUG_THIS_RULE();
 
-    if (!_cxx0xEnabled)
+    if (!_languageFeatures.cxx11Enabled)
         return false;
 
     if (LA() == T_AMPER || LA() == T_AMPER_AMPER) {
@@ -1248,7 +1229,7 @@ bool Parser::parseOverrideFinalQualifiers(SpecifierListAST *&node)
 {
     DEBUG_THIS_RULE();
 
-    if (!_cxx0xEnabled)
+    if (!_languageFeatures.cxx11Enabled)
         return false;
 
     unsigned start = cursor();
@@ -1278,7 +1259,7 @@ bool Parser::parseOverrideFinalQualifiers(SpecifierListAST *&node)
 bool Parser::parsePtrOperator(PtrOperatorListAST *&node)
 {
     DEBUG_THIS_RULE();
-    if (LA() == T_AMPER || (_cxx0xEnabled && LA() == T_AMPER_AMPER)) {
+    if (LA() == T_AMPER || (_languageFeatures.cxx11Enabled && LA() == T_AMPER_AMPER)) {
         ReferenceAST *ast = new (_pool) ReferenceAST;
         ast->reference_token = consumeToken();
         node = new (_pool) PtrOperatorListAST(ast);
@@ -1319,7 +1300,7 @@ bool Parser::parseTemplateArgument(ExpressionAST *&node)
     if (parseTypeId(node)) {
         int index = 1;
 
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
             index = 2;
 
         if (LA(index) == T_COMMA || maybeSplitGreaterGreaterToken(index) || LA(index) == T_GREATER)
@@ -1413,7 +1394,7 @@ bool Parser::parseCoreDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_sp
         ptr_operators_tail = &(*ptr_operators_tail)->next;
 
     if (LA() == T_COLON_COLON || LA() == T_IDENTIFIER || LA() == T_TILDE || LA() == T_OPERATOR
-        || (_cxx0xEnabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_COLON_COLON || LA(2) == T_IDENTIFIER))) {
+        || (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_COLON_COLON || LA(2) == T_IDENTIFIER))) {
 
         unsigned dot_dot_dot_token = 0;
 
@@ -1543,7 +1524,7 @@ bool Parser::parseDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_specif
             parseRefQualifier(ast->ref_qualifier_token);
             parseExceptionSpecification(ast->exception_specification);
 
-            if (_cxx0xEnabled && ! node->ptr_operator_list && LA() == T_ARROW) {
+            if (_languageFeatures.cxx11Enabled && ! node->ptr_operator_list && LA() == T_ARROW) {
                 // only allow if there is 1 type spec, which has to be 'auto'
                 bool hasAuto = false;
                 for (SpecifierListAST *iter = decl_specifier_list; !hasAuto && iter; iter = iter->next) {
@@ -1690,12 +1671,12 @@ bool Parser::parseEnumSpecifier(SpecifierListAST *&node)
         EnumSpecifierAST *ast = new (_pool) EnumSpecifierAST;
 
         ast->enum_token = consumeToken();
-        if (_cxx0xEnabled && (LA() == T_CLASS || LA() == T_STRUCT))
+        if (_languageFeatures.cxx11Enabled && (LA() == T_CLASS || LA() == T_STRUCT))
             ast->key_token = consumeToken();
 
         parseName(ast->name);
 
-        if (_cxx0xEnabled && LA() == T_COLON) {
+        if (_languageFeatures.cxx11Enabled && LA() == T_COLON) {
             ast->colon_token = consumeToken();
             parseTypeSpecifier(ast->type_specifier_list);
         }
@@ -1722,7 +1703,7 @@ bool Parser::parseEnumSpecifier(SpecifierListAST *&node)
                     match(T_COMMA, &comma_token);
             }
             match(T_RBRACE, &ast->rbrace_token);
-        } else if (!_cxx0xEnabled) {
+        } else if (!_languageFeatures.cxx11Enabled) {
             return false;
         }
 
@@ -1776,7 +1757,7 @@ bool Parser::parseTypenameTypeParameter(DeclarationAST *&node)
     if (LA() == T_CLASS || LA() == T_TYPENAME) {
         TypenameTypeParameterAST *ast = new (_pool) TypenameTypeParameterAST;
         ast->classkey_token = consumeToken();
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
             ast->dot_dot_dot_token = consumeToken();
         parseName(ast->name);
         if (LA() == T_EQUAL) {
@@ -1802,7 +1783,7 @@ bool Parser::parseTemplateTypeParameter(DeclarationAST *&node)
             ast->greater_token = consumeToken();
         if (LA() == T_CLASS)
             ast->class_token = consumeToken();
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
             ast->dot_dot_dot_token = consumeToken();
 
         // parse optional name
@@ -1943,7 +1924,7 @@ bool Parser::parseParameterDeclaration(ParameterDeclarationAST *&node)
         parseDeclaratorOrAbstractDeclarator(ast->declarator, decl_specifier_seq);
         if (LA() == T_EQUAL) {
             ast->equal_token = consumeToken();
-            if (!_cxx0xEnabled)
+            if (!_languageFeatures.cxx11Enabled)
                 parseLogicalOrExpression(ast->expression);
             else
                 parseInitializerClause0x(ast->expression);
@@ -2036,7 +2017,7 @@ bool Parser::parseClassSpecifier(SpecifierListAST *&node)
 
             parseBaseClause(base_clause_list);
 
-            if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+            if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
                 dot_dot_dot_token = consumeToken();
 
             if (LA() != T_LBRACE) {
@@ -2455,7 +2436,7 @@ bool Parser::parseMemberSpecification(DeclarationAST *&node, ClassSpecifierAST *
         return parseQtInterfaces(node);
 
     case T_STATIC_ASSERT:
-        if (_cxx0xEnabled)
+        if (_languageFeatures.cxx11Enabled)
             return parseStaticAssertDeclaration(node);
         // fall-through
 
@@ -2475,7 +2456,7 @@ bool Parser::parseCtorInitializer(CtorInitializerAST *&node)
 
         parseMemInitializerList(ast->member_initializer_list);
 
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
             ast->dot_dot_dot_token = consumeToken();
 
         node = ast;
@@ -2525,7 +2506,7 @@ bool Parser::parseExceptionSpecification(ExceptionSpecificationAST *&node)
             ast->rparen_token = consumeToken();
         node = ast;
         return true;
-    } else if (_cxx0xEnabled && LA() == T_NOEXCEPT) {
+    } else if (_languageFeatures.cxx11Enabled && LA() == T_NOEXCEPT) {
         NoExceptSpecificationAST *ast = new (_pool) NoExceptSpecificationAST;
         ast->noexcept_token = consumeToken();
         if (LA() == T_LPAREN) {
@@ -2595,7 +2576,7 @@ bool Parser::parseInitDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_sp
         }
         rewind(colon_token);
     } else if (isFunctionDeclarator && declaringClass && node->core_declarator && LA() == T_EQUAL && LA(3) == T_SEMICOLON) { // = 0, = delete, = default
-        if (!_cxx0xEnabled || LA(2) == T_NUMERIC_LITERAL) {
+        if (!_languageFeatures.cxx11Enabled || LA(2) == T_NUMERIC_LITERAL) {
             parseInitializer(node->initializer, &node->equal_token);
         } else {
             node->equal_token = consumeToken();
@@ -2607,7 +2588,7 @@ bool Parser::parseInitDeclarator(DeclaratorAST *&node, SpecifierListAST *decl_sp
             id_expr->name = simple_name;
             simple_name->identifier_token = consumeToken();
         }
-    } else if (node->core_declarator && (LA() == T_EQUAL || (_cxx0xEnabled && !isFunctionDeclarator && LA() == T_LBRACE) || (! declaringClass && LA() == T_LPAREN))) {
+    } else if (node->core_declarator && (LA() == T_EQUAL || (_languageFeatures.cxx11Enabled && !isFunctionDeclarator && LA() == T_LBRACE) || (! declaringClass && LA() == T_LPAREN))) {
         parseInitializer(node->initializer, &node->equal_token);
     }
     return true;
@@ -2648,7 +2629,7 @@ bool Parser::parseInitializer0x(ExpressionAST *&node, unsigned *equals_token)
 {
     DEBUG_THIS_RULE();
 
-    if ((_cxx0xEnabled && LA() == T_LBRACE) || LA() == T_EQUAL) {
+    if ((_languageFeatures.cxx11Enabled && LA() == T_LBRACE) || LA() == T_EQUAL) {
         if (LA() == T_EQUAL)
             *equals_token = cursor();
 
@@ -2695,7 +2676,7 @@ bool Parser::parseInitializerList0x(ExpressionListAST *&node)
         (*expression_list_ptr)->value = expression;
         expression_list_ptr = &(*expression_list_ptr)->next;
 
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_COMMA || LA(2) == T_RBRACE || LA(2) == T_RPAREN))
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_COMMA || LA(2) == T_RBRACE || LA(2) == T_RPAREN))
             consumeToken(); // ### create an argument pack
 
         while (LA() == T_COMMA && LA(2) != T_RBRACE) {
@@ -2705,7 +2686,7 @@ bool Parser::parseInitializerList0x(ExpressionListAST *&node)
                 *expression_list_ptr = new (_pool) ExpressionListAST;
                 (*expression_list_ptr)->value = expression;
 
-                if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_COMMA || LA(2) == T_RBRACE || LA(2) == T_RPAREN))
+                if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_COMMA || LA(2) == T_RBRACE || LA(2) == T_RPAREN))
                     consumeToken(); // ### create an argument pack
 
                 expression_list_ptr = &(*expression_list_ptr)->next;
@@ -2747,12 +2728,12 @@ bool Parser::parseMemInitializerList(MemInitializerListAST *&node)
             if (LA() == T_LBRACE)
                 break;
 
-            else if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT && LA(2) == T_LBRACE)
+            else if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT && LA(2) == T_LBRACE)
                 break;
 
             else if (LA() == T_COMMA
                      || (LA() == T_IDENTIFIER
-                         && (LA(2) == T_LPAREN || LA(2) == T_COLON_COLON || (_cxx0xEnabled && LA(2) == T_LBRACE)))) {
+                         && (LA(2) == T_LPAREN || LA(2) == T_COLON_COLON || (_languageFeatures.cxx11Enabled && LA(2) == T_LBRACE)))) {
                 if (LA() != T_COMMA)
                     error(cursor(), "expected `,'");
                 else
@@ -2766,7 +2747,7 @@ bool Parser::parseMemInitializerList(MemInitializerListAST *&node)
             } else break;
         }
 
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT) {
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT) {
             if (LA(2) != T_LBRACE)
                 error(cursor(), "expected `{'");
 
@@ -2792,10 +2773,10 @@ bool Parser::parseMemInitializer(MemInitializerListAST *&node)
 
     if (LA() == T_LPAREN) {
         parseExpressionListParen(ast->expression);
-    } else if (_cxx0xEnabled && LA() == T_LBRACE) {
+    } else if (_languageFeatures.cxx11Enabled && LA() == T_LBRACE) {
         parseBracedInitList0x(ast->expression);
     } else {
-        if (!_cxx0xEnabled)
+        if (!_languageFeatures.cxx11Enabled)
             error(cursor(), "expected '('");
         else
             error(cursor(), "expected '(' or '{'");
@@ -2817,7 +2798,7 @@ bool Parser::parseTypeIdList(ExpressionListAST *&node)
         (*expression_list_ptr)->value = typeId;
         expression_list_ptr = &(*expression_list_ptr)->next;
 
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
             consumeToken(); // ### store this token
 
         while (LA() == T_COMMA) {
@@ -2828,7 +2809,7 @@ bool Parser::parseTypeIdList(ExpressionListAST *&node)
                 (*expression_list_ptr)->value = typeId;
                 expression_list_ptr = &(*expression_list_ptr)->next;
 
-                if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+                if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
                     consumeToken(); // ### store this token
             }
         }
@@ -2842,7 +2823,7 @@ bool Parser::parseExpressionList(ExpressionListAST *&node)
 {
     DEBUG_THIS_RULE();
 
-    if (_cxx0xEnabled)
+    if (_languageFeatures.cxx11Enabled)
         return parseInitializerList0x(node);
 
     ExpressionListAST **expression_list_ptr = &node;
@@ -2914,7 +2895,7 @@ bool Parser::parseInitializerList(ExpressionListAST *&node)
         }
     }
 
-    if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT)
+    if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT)
         consumeToken(); // ### store this token
 
     return true;
@@ -3112,13 +3093,13 @@ bool Parser::parseStatement(StatementAST *&node)
     }
 
     case T_AT_TRY:
-        return objCEnabled() && parseObjCTryStatement(node);
+        return _languageFeatures.objCEnabled && parseObjCTryStatement(node);
 
     case T_AT_SYNCHRONIZED:
-        return objCEnabled() && parseObjCSynchronizedStatement(node);
+        return _languageFeatures.objCEnabled && parseObjCSynchronizedStatement(node);
 
     case T_AT_THROW:
-        return objCEnabled() && parseObjCThrowStatement(node);
+        return _languageFeatures.objCEnabled && parseObjCThrowStatement(node);
 
     case T_Q_D:
     case T_Q_Q: {
@@ -3202,7 +3183,7 @@ bool Parser::parseReturnStatement(StatementAST *&node)
     if (LA() == T_RETURN) {
         ReturnStatementAST *ast = new (_pool) ReturnStatementAST;
         ast->return_token = consumeToken();
-        if (_cxx0xEnabled && LA() == T_LBRACE)
+        if (_languageFeatures.cxx11Enabled && LA() == T_LBRACE)
             parseBracedInitList0x(ast->expression);
         else
             parseExpression(ast->expression);
@@ -3249,7 +3230,7 @@ bool Parser::parseExpressionOrDeclarationStatement(StatementAST *&node)
             || LA() == T_TYPENAME
             || LA() == T_ENUM
             || lookAtClassKey()
-            || (LA() == T_STATIC_ASSERT && _cxx0xEnabled)) {
+            || (LA() == T_STATIC_ASSERT && _languageFeatures.cxx11Enabled)) {
         return parseDeclarationStatement(node);
     }
 
@@ -3442,7 +3423,7 @@ bool Parser::parseForStatement(StatementAST *&node)
     unsigned startOfTypeSpecifier = cursor();
     bool blocked = blockErrors(true);
 
-    if (objCEnabled()) {
+    if (_languageFeatures.objCEnabled) {
         ObjCFastEnumerationAST *ast = new (_pool) ObjCFastEnumerationAST;
         ast->for_token = for_token;
         ast->lparen_token = lparen_token;
@@ -3482,7 +3463,7 @@ bool Parser::parseForStatement(StatementAST *&node)
         rewind(startOfTypeSpecifier);
     }
 
-    if (cxx0xEnabled()) {
+    if (_languageFeatures.cxx11Enabled) {
         RangeBasedForStatementAST *ast = new (_pool) RangeBasedForStatementAST;
         ast->for_token = for_token;
         ast->lparen_token = lparen_token;
@@ -3665,7 +3646,7 @@ bool Parser::parseBlockDeclaration(DeclarationAST *&node)
         return parseNamespaceAliasDefinition(node);
 
     case T_STATIC_ASSERT:
-        if (_cxx0xEnabled)
+        if (_languageFeatures.cxx11Enabled)
             return parseStaticAssertDeclaration(node);
         // fall-through
 
@@ -3746,7 +3727,7 @@ bool Parser::lookAtStorageClassSpecifier() const
     case T_TYPEDEF:
         return true;
     case T_CONSTEXPR:
-        if (_cxx0xEnabled)
+        if (_languageFeatures.cxx11Enabled)
             return true;
         // fall-through
     default:
@@ -3944,7 +3925,7 @@ bool Parser::parseSimpleDeclaration(DeclarationAST *&node, ClassSpecifierAST *de
             unsigned startOfTypeSpecifier = cursor();
             if (! parseElaboratedTypeSpecifier(*decl_specifier_seq_ptr)
                     || LA() == T_LBRACE
-                    || (_cxx0xEnabled && LA() == T_COLON)) {
+                    || (_languageFeatures.cxx11Enabled && LA() == T_COLON)) {
                 rewind(startOfTypeSpecifier);
                 if (! parseEnumSpecifier(*decl_specifier_seq_ptr)) {
                     error(startOfTypeSpecifier,
@@ -4301,7 +4282,7 @@ bool Parser::parsePrimaryExpression(ExpressionAST *&node)
         return parseStringLiteral(node);
 
     case T_NULLPTR:
-        if (_cxx0xEnabled)
+        if (_languageFeatures.cxx11Enabled)
             return parsePointerLiteral(node);
         // fall-through
 
@@ -4341,12 +4322,12 @@ bool Parser::parsePrimaryExpression(ExpressionAST *&node)
     case T_LBRACKET: {
         const unsigned lbracket_token = cursor();
 
-        if (_cxx0xEnabled) {
+        if (_languageFeatures.cxx11Enabled) {
             if (parseLambdaExpression(node))
                 return true;
         }
 
-        if (_objCEnabled) {
+        if (_languageFeatures.objCEnabled) {
             rewind(lbracket_token);
             return parseObjCExpression(node);
         }
@@ -4828,7 +4809,7 @@ bool Parser::parseTypenameCallExpression(ExpressionAST *&node)
         unsigned typename_token = consumeToken();
         NameAST *name = 0;
         if (parseName(name)
-                && (LA() == T_LPAREN || (_cxx0xEnabled && LA() == T_LBRACE))) {
+                && (LA() == T_LPAREN || (_languageFeatures.cxx11Enabled && LA() == T_LBRACE))) {
             TypenameCallExpressionAST *ast = new (_pool) TypenameCallExpressionAST;
             ast->typename_token = typename_token;
             ast->name = name;
@@ -4889,7 +4870,7 @@ bool Parser::parseCorePostfixExpression(ExpressionAST *&node)
         bool blocked = blockErrors(true);
         if (lookAtBuiltinTypeSpecifier() &&
                 parseSimpleTypeSpecifier(type_specifier) &&
-                (LA() == T_LPAREN || (_cxx0xEnabled && LA() == T_LBRACE))) {
+                (LA() == T_LPAREN || (_languageFeatures.cxx11Enabled && LA() == T_LBRACE))) {
             ExpressionAST *expr = 0;
             if (LA() == T_LPAREN) {
                 parseExpressionListParen(expr);
@@ -4951,7 +4932,7 @@ bool Parser::parsePostfixExpression(ExpressionAST *&node)
                 match(T_RBRACKET, &ast->rbracket_token);
                 ast->base_expression = node;
                 node = ast;
-            } else if (_cxx0xEnabled && LA() == T_LBRACE && node->asIdExpression()) {
+            } else if (_languageFeatures.cxx11Enabled && LA() == T_LBRACE && node->asIdExpression()) {
                 // this is slightly inconsistent: simple-type-specifier '(' expression-list ')'
                 // gets parsed as a CallAST while simple-type-specifier brace-init-list
                 // is a TypenameCallExpressionAST
@@ -5020,7 +5001,7 @@ bool Parser::parseUnaryExpression(ExpressionAST *&node)
         ast->sizeof_token = consumeToken();
 
         // sizeof...(Args)
-        if (_cxx0xEnabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_IDENTIFIER || (LA(2) == T_LPAREN && LA(3) == T_IDENTIFIER
+        if (_languageFeatures.cxx11Enabled && LA() == T_DOT_DOT_DOT && (LA(2) == T_IDENTIFIER || (LA(2) == T_LPAREN && LA(3) == T_IDENTIFIER
                                                                                  && LA(4) == T_RPAREN)))
             ast->dot_dot_dot_token = consumeToken();
 
@@ -5046,7 +5027,7 @@ bool Parser::parseUnaryExpression(ExpressionAST *&node)
     }
 
     case T_ALIGNOF: {
-        if (!_cxx0xEnabled)
+        if (!_languageFeatures.cxx11Enabled)
             break;
 
         AlignofExpressionAST *ast = new (_pool) AlignofExpressionAST;
@@ -5211,7 +5192,7 @@ bool Parser::parseNewInitializer(ExpressionAST *&node)
     DEBUG_THIS_RULE();
     if (LA() == T_LPAREN)
         return parseExpressionListParen(node);
-    else if (_cxx0xEnabled && LA() == T_LBRACE)
+    else if (_languageFeatures.cxx11Enabled && LA() == T_LBRACE)
         return parseBracedInitList0x(node);
     return false;
 }
@@ -5436,7 +5417,7 @@ void Parser::parseExpressionWithOperatorPrecedence(ExpressionAST *&lhs, int minP
         if (operPrecedence <= Prec::Conditional && isCPlusPlus) {
             // in C++ you can put a throw in the right-most expression of a conditional expression,
             // or an assignment, so some special handling:
-            if (_cxx0xEnabled) {
+            if (_languageFeatures.cxx11Enabled) {
                 if (!parseInitializerClause0x(rhs))
                     return;
             } else {