| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /* $ANTLR 2.7.7 (20130409): "CPP_parser.g" -> "CPPParser.cpp"$ */ |
| #include "CPPParser.hpp" |
| #include <antlr/NoViableAltException.hpp> |
| #include <antlr/SemanticException.hpp> |
| #include <antlr/ASTFactory.hpp> |
| #line 102 "CPP_parser.g" |
| |
| // File generated from CPP_parser.g |
| // Version 3.1 November 2005 |
| // This file is best viewed in courier font with tabs set to 4 spaces |
| // |
| // The statements in this block appear only in CPPParser.cpp and not in |
| // CPPLexer.cpp |
| |
| // These constants used in the previous version (3.0 July 2004) have now been |
| // replaced by the following, |
| // ID_VAR_NAME is now CPPSymbol::otVariable |
| // ID_FUN_NAME is now CPPSymbol::otFunction |
| // ID_INPUT_PARAMETER is now not used |
| // ID_CLASS_DEF is now CPPSymbol::otClass |
| // ID_SYSTEM_FUNCTION is now not used |
| // ID_CONST_DECL is now not used |
| // ID_TYPEDEF_VAR is now CPPSymbol::otTypedef |
| |
| int statementTrace = |
| 2; // Used to control selected (level) tracing (see support.cpp) |
| // 1 Shows which external and member statements selected |
| // 2 Shows above plus all declarations/definitions |
| // 3 reserved for future use |
| // 4 and above available for user |
| |
| void CPPParser::init() { |
| antlrTrace(false); // This is a dynamic trace facility for use with |
| // -traceParser etc. |
| // It requires modification in LLkParser.cpp and LLkParser.hpp |
| // otherwise it should be commented out (see MyReadMe.txt) |
| // true shows antlr trace (or can be set and reset during parsing) |
| // false stops showing antlr trace |
| // Provided the parser is always generated with -traceParser this |
| // facility allows trace output to be turned on or off by changing |
| // the setting here from false to true or vice versa and then |
| // recompiling and linking CPPParser only thus avoiding the need |
| // to use antlr.Tool to re-generate the lexer and parser again |
| // with (or without) -traceParser. |
| // Antlr trace can also be turned on and off dynamically using |
| // antlrTrace_on or antlrTrace_off statements inserted into the |
| // source code being parsed (See below). |
| |
| // Creates a dictionary to hold symbols with 4001 buckets, 200 scopes and |
| // 800,000 characters |
| // These can be changed to suit the size of program(s) being parsed |
| symbols = new CPPDictionary(4001, 200, 800000); |
| |
| // Set template parameter scope - Not used at present |
| templateParameterScope = |
| symbols->getCurrentScopeIndex(); // Set template parameter scope to 0 |
| |
| symbols->saveScope(); // Advance currentScope from 0 to 1 |
| // Set "external" scope for all types |
| externalScope = |
| symbols->getCurrentScopeIndex(); // Set "external" scope to 1 for types |
| |
| // Declare predefined scope "std" in external scope |
| CPPSymbol* a = new CPPSymbol("std", CPPSymbol::otTypedef); |
| symbols->define("std", a); |
| |
| symbols->saveScope(); // Advance currentScope from 1 to 2 (and higher) for |
| // all other symbols |
| // treated as locals |
| |
| // Global flags to allow for nested declarations |
| _td = false; // For typedef |
| _fd = false; // For friend |
| _sc = scInvalid; // For StorageClass |
| _tq = tqInvalid; // For TypeQualifier |
| _ts = tsInvalid; // For TypeSpecifier |
| _fs = fsInvalid; // For FunctionSpecifier |
| |
| functionDefinition = 0; |
| qualifierPrefix[0] = '\0'; |
| enclosingClass = (char*)""; |
| assign_stmt_RHS_found = 0; |
| in_parameter_list = false; |
| K_and_R = false; // used to distinguish old K & R parameter definitions |
| in_return = false; |
| is_address = false; |
| is_pointer = false; |
| } |
| |
| #line 85 "CPPParser.cpp" |
| CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenBuffer& tokenBuf, int k) |
| : ANTLR_USE_NAMESPACE(antlr) LLkParser(tokenBuf, k) {} |
| |
| CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenBuffer& tokenBuf) |
| : ANTLR_USE_NAMESPACE(antlr) LLkParser(tokenBuf, 2) {} |
| |
| CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenStream& lexer, int k) |
| : ANTLR_USE_NAMESPACE(antlr) LLkParser(lexer, k) {} |
| |
| CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenStream& lexer) |
| : ANTLR_USE_NAMESPACE(antlr) LLkParser(lexer, 2) {} |
| |
| CPPParser::CPPParser(const ANTLR_USE_NAMESPACE(antlr) |
| ParserSharedInputState& state) |
| : ANTLR_USE_NAMESPACE(antlr) LLkParser(state, 2) {} |
| |
| void CPPParser::translation_unit() { |
| try { // for error handling |
| if (inputState->guessing == 0) { |
| #line 376 "CPP_parser.g" |
| enterExternalScope(); |
| #line 117 "CPPParser.cpp" |
| } |
| { // ( ... )+ |
| int _cnt3 = 0; |
| for (;;) { |
| if ((_tokenSet_0.member(LA(1)))) { |
| external_declaration(); |
| } else { |
| if (_cnt3 >= 1) { |
| goto _loop3; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt3++; |
| } |
| _loop3:; |
| } // ( ... )+ |
| match(ANTLR_USE_NAMESPACE(antlr) Token::EOF_TYPE); |
| if (inputState->guessing == 0) { |
| #line 378 "CPP_parser.g" |
| exitExternalScope(); |
| #line 137 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_1); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::external_declaration() { |
| #line 381 "CPP_parser.g" |
| char* s; |
| K_and_R = false; |
| FunctionSpecifier fs = fsInvalid; // inline,virtual,explicit |
| |
| #line 156 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_namespace: { |
| if (inputState->guessing == 0) { |
| #line 539 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d external_declaration Namespace definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 168 "CPPParser.cpp" |
| } |
| match(LITERAL_namespace); |
| namespace_definition(); |
| break; |
| } |
| case SEMICOLON: { |
| if (inputState->guessing == 0) { |
| #line 551 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d external_declaration Semicolon\n", LT(1)->getLine()); |
| } |
| |
| #line 181 "CPPParser.cpp" |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 554 "CPP_parser.g" |
| end_of_stmt(); |
| #line 187 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_antlrTrace_on: { |
| match(LITERAL_antlrTrace_on); |
| if (inputState->guessing == 0) { |
| #line 558 "CPP_parser.g" |
| antlrTrace(true); |
| #line 197 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_antlrTrace_off: { |
| match(LITERAL_antlrTrace_off); |
| if (inputState->guessing == 0) { |
| #line 561 "CPP_parser.g" |
| antlrTrace(false); |
| #line 207 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: |
| bool synPredMatched7 = false; |
| if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) { |
| int _m7 = mark(); |
| synPredMatched7 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_template); |
| match(LESSTHAN); |
| match(GREATERTHAN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched7 = false; |
| } |
| rewind(_m7); |
| inputState->guessing--; |
| } |
| if (synPredMatched7) { |
| if (inputState->guessing == 0) { |
| #line 390 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration template " |
| "explicit-specialisation\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 236 "CPPParser.cpp" |
| } |
| match(LITERAL_template); |
| match(LESSTHAN); |
| match(GREATERTHAN); |
| external_declaration(); |
| } else { |
| bool synPredMatched9 = false; |
| if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) { |
| int _m9 = mark(); |
| synPredMatched9 = true; |
| inputState->guessing++; |
| try { |
| { match(LITERAL_typedef); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched9 = false; |
| } |
| rewind(_m9); |
| inputState->guessing--; |
| } |
| if (synPredMatched9) { |
| { |
| bool synPredMatched12 = false; |
| if (((LA(1) == LITERAL_typedef) && |
| ((LA(2) >= LITERAL_struct && LA(2) <= LITERAL_class)))) { |
| int _m12 = mark(); |
| synPredMatched12 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_typedef); |
| class_specifier(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched12 = false; |
| } |
| rewind(_m12); |
| inputState->guessing--; |
| } |
| if (synPredMatched12) { |
| if (inputState->guessing == 0) { |
| #line 399 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d external_declaration Typedef class type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 285 "CPPParser.cpp" |
| } |
| match(LITERAL_typedef); |
| class_decl_or_def(fs); |
| if (inputState->guessing == 0) { |
| #line 402 "CPP_parser.g" |
| _td = true; |
| #line 292 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 402 "CPP_parser.g" |
| end_of_stmt(); |
| #line 336 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched15 = false; |
| if (((LA(1) == LITERAL_typedef) && (LA(2) == LITERAL_enum))) { |
| int _m15 = mark(); |
| synPredMatched15 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_typedef); |
| match(LITERAL_enum); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched15 = false; |
| } |
| rewind(_m15); |
| inputState->guessing--; |
| } |
| if (synPredMatched15) { |
| if (inputState->guessing == 0) { |
| #line 405 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d external_declaration Typedef enum type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 363 "CPPParser.cpp" |
| } |
| match(LITERAL_typedef); |
| enum_specifier(); |
| if (inputState->guessing == 0) { |
| #line 408 "CPP_parser.g" |
| _td = true; |
| #line 370 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 408 "CPP_parser.g" |
| end_of_stmt(); |
| #line 414 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched18 = false; |
| if (((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2))))) { |
| int _m18 = mark(); |
| synPredMatched18 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched18 = false; |
| } |
| rewind(_m18); |
| inputState->guessing--; |
| } |
| if (synPredMatched18) { |
| if (inputState->guessing == 0) { |
| #line 411 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Typedef function type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 442 "CPPParser.cpp" |
| } |
| declaration(); |
| } else if ((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2)))) { |
| if (inputState->guessing == 0) { |
| #line 416 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Typedef variable type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 452 "CPPParser.cpp" |
| } |
| declaration(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } else { |
| bool synPredMatched22 = false; |
| if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) { |
| int _m22 = mark(); |
| synPredMatched22 = true; |
| inputState->guessing++; |
| try { |
| { |
| template_head(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop21; |
| } |
| } |
| _loop21:; |
| } // ( ... )* |
| class_specifier(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched22 = false; |
| } |
| rewind(_m22); |
| inputState->guessing--; |
| } |
| if (synPredMatched22) { |
| if (inputState->guessing == 0) { |
| #line 424 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Templated class decl or def\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 498 "CPPParser.cpp" |
| } |
| template_head(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop24; |
| } |
| } |
| _loop24:; |
| } // ( ... )* |
| class_decl_or_def(fs); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 427 "CPP_parser.g" |
| end_of_stmt(); |
| #line 556 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched28 = false; |
| if (((LA(1) == LITERAL_enum) && (_tokenSet_5.member(LA(2))))) { |
| int _m28 = mark(); |
| synPredMatched28 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_enum); |
| { |
| switch (LA(1)) { |
| case ID: { |
| match(ID); |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched28 = false; |
| } |
| rewind(_m28); |
| inputState->guessing--; |
| } |
| if (synPredMatched28) { |
| if (inputState->guessing == 0) { |
| #line 431 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d external_declaration Enum definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 600 "CPPParser.cpp" |
| } |
| enum_specifier(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 434 "CPP_parser.g" |
| end_of_stmt(); |
| #line 645 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched32 = false; |
| if (((_tokenSet_6.member(LA(1))) && |
| (_tokenSet_7.member(LA(2))))) { |
| int _m32 = mark(); |
| synPredMatched32 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case LITERAL_template: { |
| template_head(); |
| break; |
| } |
| case ID: |
| case LITERAL_inline: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case TILDE: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| dtor_head(1); |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched32 = false; |
| } |
| rewind(_m32); |
| inputState->guessing--; |
| } |
| if (synPredMatched32) { |
| if (inputState->guessing == 0) { |
| #line 438 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Destructor definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 695 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_template: { |
| template_head(); |
| break; |
| } |
| case ID: |
| case LITERAL_inline: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case TILDE: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| dtor_head(1); |
| dtor_body(); |
| } else { |
| bool synPredMatched36 = false; |
| if (((_tokenSet_8.member(LA(1))) && |
| (_tokenSet_9.member(LA(2))))) { |
| int _m36 = mark(); |
| synPredMatched36 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| if ((true) && (true)) { |
| ctor_decl_spec(); |
| } else { |
| } |
| } |
| if (!(qualifiedItemIsOneOf(qiCtor))) { |
| throw ANTLR_USE_NAMESPACE(antlr) SemanticException( |
| "qualifiedItemIsOneOf(qiCtor)"); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched36 = false; |
| } |
| rewind(_m36); |
| inputState->guessing--; |
| } |
| if (synPredMatched36) { |
| if (inputState->guessing == 0) { |
| #line 451 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Constructor " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 755 "CPPParser.cpp" |
| } |
| ctor_definition(); |
| } else { |
| bool synPredMatched39 = false; |
| if (((_tokenSet_10.member(LA(1))) && |
| (_tokenSet_11.member(LA(2))))) { |
| int _m39 = mark(); |
| synPredMatched39 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), |
| getFilename()); |
| } |
| } |
| } |
| scope_override(); |
| conversion_function_decl_or_def(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched39 = false; |
| } |
| rewind(_m39); |
| inputState->guessing--; |
| } |
| if (synPredMatched39) { |
| if (inputState->guessing == 0) { |
| #line 458 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Operator function\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 802 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| s = scope_override(); |
| conversion_function_decl_or_def(); |
| } else { |
| bool synPredMatched42 = false; |
| if (((_tokenSet_12.member(LA(1))) && |
| (_tokenSet_13.member(LA(2))))) { |
| int _m42 = mark(); |
| synPredMatched42 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched42 = false; |
| } |
| rewind(_m42); |
| inputState->guessing--; |
| } |
| if (synPredMatched42) { |
| if (inputState->guessing == 0) { |
| #line 465 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Function " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 851 "CPPParser.cpp" |
| } |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 468 "CPP_parser.g" |
| end_of_stmt(); |
| #line 859 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched44 = false; |
| if (((_tokenSet_14.member(LA(1))) && |
| (_tokenSet_15.member(LA(2))))) { |
| int _m44 = mark(); |
| synPredMatched44 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(1); |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched44 = false; |
| } |
| rewind(_m44); |
| inputState->guessing--; |
| } |
| if (synPredMatched44) { |
| if (inputState->guessing == 0) { |
| #line 472 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Function " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 887 "CPPParser.cpp" |
| } |
| function_definition(); |
| } else { |
| bool synPredMatched46 = false; |
| if (((_tokenSet_14.member(LA(1))) && |
| (_tokenSet_15.member(LA(2))))) { |
| int _m46 = mark(); |
| synPredMatched46 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(1); |
| declaration(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched46 = false; |
| } |
| rewind(_m46); |
| inputState->guessing--; |
| } |
| if (synPredMatched46) { |
| if (inputState->guessing == 0) { |
| #line 479 "CPP_parser.g" |
| K_and_R = true; |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration K & R function " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 917 "CPPParser.cpp" |
| } |
| function_definition(); |
| } else { |
| bool synPredMatched48 = false; |
| if (((_tokenSet_14.member(LA(1))) && |
| (_tokenSet_15.member(LA(2))))) { |
| int _m48 = mark(); |
| synPredMatched48 = true; |
| inputState->guessing++; |
| try { |
| { |
| function_declarator(1); |
| declaration(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched48 = false; |
| } |
| rewind(_m48); |
| inputState->guessing--; |
| } |
| if (synPredMatched48) { |
| if (inputState->guessing == 0) { |
| #line 487 "CPP_parser.g" |
| K_and_R = true; |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration K & R " |
| "function definition without return " |
| "type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 946 "CPPParser.cpp" |
| } |
| function_definition(); |
| } else { |
| bool synPredMatched53 = false; |
| if (((_tokenSet_16.member(LA(1))) && |
| (_tokenSet_17.member(LA(2))))) { |
| int _m53 = mark(); |
| synPredMatched53 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case LITERAL_friend: { |
| match(LITERAL_friend); |
| break; |
| } |
| case LITERAL_inline: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop52; |
| } |
| } |
| _loop52:; |
| } // ( ... )* |
| class_specifier(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched53 = false; |
| } |
| rewind(_m53); |
| inputState->guessing--; |
| } |
| if (synPredMatched53) { |
| if (inputState->guessing == 0) { |
| #line 495 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration Class decl " |
| "or def\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 1009 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_friend: { |
| match(LITERAL_friend); |
| break; |
| } |
| case LITERAL_inline: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), |
| getFilename()); |
| } |
| } |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop56; |
| } |
| } |
| _loop56:; |
| } // ( ... )* |
| class_decl_or_def(fs); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), |
| getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 498 "CPP_parser.g" |
| end_of_stmt(); |
| #line 1090 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LITERAL_template) && |
| (LA(2) == LESSTHAN)) { |
| if (inputState->guessing == 0) { |
| #line 501 "CPP_parser.g" |
| beginTemplateDeclaration(); |
| #line 1097 "CPPParser.cpp" |
| } |
| template_head(); |
| { |
| bool synPredMatched61 = false; |
| if (((_tokenSet_12.member(LA(1))) && |
| (_tokenSet_18.member(LA(2))))) { |
| int _m61 = mark(); |
| synPredMatched61 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 505 "CPP_parser.g" |
| end_of_stmt(); |
| #line 1151 "CPPParser.cpp" |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched61 = false; |
| } |
| rewind(_m61); |
| inputState->guessing--; |
| } |
| if (synPredMatched61) { |
| if (inputState->guessing == 0) { |
| #line 506 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration " |
| "Templated class forward " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 1167 "CPPParser.cpp" |
| } |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 509 "CPP_parser.g" |
| end_of_stmt(); |
| #line 1212 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched64 = false; |
| if (((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2))))) { |
| int _m64 = mark(); |
| synPredMatched64 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched64 = false; |
| } |
| rewind(_m64); |
| inputState->guessing--; |
| } |
| if (synPredMatched64) { |
| if (inputState->guessing == 0) { |
| #line 513 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration " |
| "Templated function " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 1240 "CPPParser.cpp" |
| } |
| declaration(); |
| } else { |
| bool synPredMatched66 = false; |
| if (((_tokenSet_14.member(LA(1))) && |
| (_tokenSet_15.member(LA(2))))) { |
| int _m66 = mark(); |
| synPredMatched66 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(1); |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE( |
| antlr) RecognitionException& pe) { |
| synPredMatched66 = false; |
| } |
| rewind(_m66); |
| inputState->guessing--; |
| } |
| if (synPredMatched66) { |
| if (inputState->guessing == 0) { |
| #line 520 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration_10c " |
| "Templated function " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 1269 "CPPParser.cpp" |
| } |
| function_definition(); |
| } else { |
| bool synPredMatched68 = false; |
| if (((_tokenSet_8.member(LA(1))) && |
| (_tokenSet_9.member(LA(2))))) { |
| int _m68 = mark(); |
| synPredMatched68 = true; |
| inputState->guessing++; |
| try { |
| { |
| ctor_decl_spec(); |
| if (!(qualifiedItemIsOneOf( |
| qiCtor))) { |
| throw ANTLR_USE_NAMESPACE( |
| antlr) |
| SemanticException( |
| "qualifiedItemIsOneOf" |
| "(qiCtor)"); |
| } |
| } |
| } catch ( |
| ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched68 = false; |
| } |
| rewind(_m68); |
| inputState->guessing--; |
| } |
| if (synPredMatched68) { |
| if (inputState->guessing == 0) { |
| #line 531 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration " |
| "Templated constructor " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 1298 "CPPParser.cpp" |
| } |
| ctor_definition(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 536 "CPP_parser.g" |
| endTemplateDeclaration(); |
| #line 1310 "CPPParser.cpp" |
| } |
| } else if ((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2)))) { |
| if (inputState->guessing == 0) { |
| #line 545 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d external_declaration " |
| "Declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 1319 "CPPParser.cpp" |
| } |
| declaration(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), |
| getFilename()); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_19); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| CPPParser::TypeSpecifier CPPParser::class_specifier() { |
| #line 1016 "CPP_parser.g" |
| CPPParser::TypeSpecifier ts = tsInvalid; |
| #line 1342 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_class: { |
| match(LITERAL_class); |
| if (inputState->guessing == 0) { |
| #line 1018 "CPP_parser.g" |
| ts = tsCLASS; |
| #line 1353 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_struct: { |
| match(LITERAL_struct); |
| if (inputState->guessing == 0) { |
| #line 1019 "CPP_parser.g" |
| ts = tsSTRUCT; |
| #line 1363 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_union: { |
| match(LITERAL_union); |
| if (inputState->guessing == 0) { |
| #line 1020 "CPP_parser.g" |
| ts = tsUNION; |
| #line 1373 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_12); |
| } else { |
| throw; |
| } |
| } |
| return ts; |
| } |
| |
| void CPPParser::class_decl_or_def(FunctionSpecifier fs) { |
| #line 1042 "CPP_parser.g" |
| char* saveClass; |
| char* id; |
| TypeSpecifier ts = tsInvalid; // Available for use |
| |
| #line 1403 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_class: { |
| match(LITERAL_class); |
| if (inputState->guessing == 0) { |
| #line 1048 "CPP_parser.g" |
| ts = tsCLASS; |
| #line 1414 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_struct: { |
| match(LITERAL_struct); |
| if (inputState->guessing == 0) { |
| #line 1049 "CPP_parser.g" |
| ts = tsSTRUCT; |
| #line 1424 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_union: { |
| match(LITERAL_union); |
| if (inputState->guessing == 0) { |
| #line 1050 "CPP_parser.g" |
| ts = tsUNION; |
| #line 1434 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| class_prefix(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == LITERAL_GFIGNORE)) { |
| match(LITERAL_GFIGNORE); |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1053 "CPP_parser.g" |
| #line 1454 "CPPParser.cpp" |
| } |
| } else { |
| goto _loop208; |
| } |
| } |
| _loop208:; |
| } // ( ... )* |
| { |
| switch (LA(1)) { |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case SCOPE: { |
| id = qualified_id(); |
| { |
| switch (LA(1)) { |
| case SEMICOLON: |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| if (inputState->guessing == 0) { |
| #line 1058 "CPP_parser.g" |
| classForwardDeclaration(ts, fs, id); |
| #line 1503 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LCURLY: |
| case COLON: { |
| if (inputState->guessing == 0) { |
| #line 1060 "CPP_parser.g" |
| saveClass = enclosingClass; |
| enclosingClass = symbols->strdup(id); |
| |
| #line 1515 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case COLON: { |
| base_clause(); |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LCURLY); |
| if (inputState->guessing == 0) { |
| #line 1065 "CPP_parser.g" |
| beginClassDefinition(ts, id); |
| #line 1538 "CPPParser.cpp" |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_20.member(LA(1)))) { |
| member_declaration(); |
| } else { |
| goto _loop215; |
| } |
| } |
| _loop215:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 1067 "CPP_parser.g" |
| endClassDefinition(); |
| #line 1555 "CPPParser.cpp" |
| } |
| match(RCURLY); |
| if (inputState->guessing == 0) { |
| #line 1069 "CPP_parser.g" |
| enclosingClass = saveClass; |
| #line 1561 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LCURLY: { |
| match(LCURLY); |
| if (inputState->guessing == 0) { |
| #line 1073 "CPP_parser.g" |
| saveClass = enclosingClass; |
| enclosingClass = (char*)"__anonymous"; |
| #line 1579 "CPPParser.cpp" |
| } |
| if (inputState->guessing == 0) { |
| #line 1074 "CPP_parser.g" |
| beginClassDefinition(ts, "anonymous"); |
| #line 1584 "CPPParser.cpp" |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_20.member(LA(1)))) { |
| member_declaration(); |
| } else { |
| goto _loop217; |
| } |
| } |
| _loop217:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 1076 "CPP_parser.g" |
| endClassDefinition(); |
| #line 1601 "CPPParser.cpp" |
| } |
| match(RCURLY); |
| if (inputState->guessing == 0) { |
| #line 1078 "CPP_parser.g" |
| enclosingClass = saveClass; |
| #line 1607 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_21); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::init_declarator_list() { |
| try { // for error handling |
| init_declarator(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| init_declarator(); |
| } else { |
| goto _loop242; |
| } |
| } |
| _loop242:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_22); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::enum_specifier() { |
| #line 1108 "CPP_parser.g" |
| char* id; |
| #line 1659 "CPPParser.cpp" |
| |
| try { // for error handling |
| match(LITERAL_enum); |
| { |
| switch (LA(1)) { |
| case LCURLY: { |
| match(LCURLY); |
| enumerator_list(); |
| match(RCURLY); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case SCOPE: { |
| id = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1116 "CPP_parser.g" |
| beginEnumDefinition(id); |
| #line 1683 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LCURLY: { |
| match(LCURLY); |
| enumerator_list(); |
| match(RCURLY); |
| break; |
| } |
| case SEMICOLON: |
| case ID: |
| case COLON: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1118 "CPP_parser.g" |
| endEnumDefinition(); |
| #line 1730 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_23); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::declaration_specifiers() { |
| ANTLR_USE_NAMESPACE(antlr) |
| RefToken gfArr = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| ANTLR_USE_NAMESPACE(antlr) |
| RefToken gfArrList = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| ANTLR_USE_NAMESPACE(antlr) |
| RefToken gfArrElem = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 885 "CPP_parser.g" |
| // Locals |
| bool td = false; // For typedef |
| bool fd = false; // For friend |
| StorageClass sc = scInvalid; // auto,register,static,extern,mutable |
| TypeQualifier tq = |
| tqInvalid; // const,volatile // aka cv_qualifier See type_qualifier |
| TypeSpecifier ts = tsInvalid; // char,int,double, etc., class,struct,union |
| FunctionSpecifier fs = fsInvalid; // inline,virtual,explicit |
| |
| #line 1764 "CPPParser.cpp" |
| |
| try { // for error handling |
| if (inputState->guessing == 0) { |
| #line 895 "CPP_parser.g" |
| |
| // Global flags to allow for nested declarations |
| _td = false; // For typedef |
| _fd = false; // For friend |
| _sc = scInvalid; // For StorageClass // |
| // auto,register,static,extern,mutable |
| _tq = tqInvalid; // For TypeQualifier // aka cv_qualifier See |
| // type_qualifier |
| _ts = tsInvalid; // For TypeSpecifier |
| _fs = fsInvalid; // For FunctionSpecifier // inline,virtual,explicit |
| |
| #line 1779 "CPPParser.cpp" |
| } |
| { |
| { // ( ... )* |
| for (;;) { |
| switch (LA(1)) { |
| case LITERAL_typedef: { |
| match(LITERAL_typedef); |
| if (inputState->guessing == 0) { |
| #line 906 "CPP_parser.g" |
| td = true; |
| #line 1791 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_friend: { |
| match(LITERAL_friend); |
| if (inputState->guessing == 0) { |
| #line 907 "CPP_parser.g" |
| fd = true; |
| #line 1801 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_extern: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: { |
| sc = storage_class_specifier(); |
| break; |
| } |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: { |
| tq = type_qualifier(); |
| break; |
| } |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: { |
| ts = class_specifier(); |
| break; |
| } |
| case LITERAL_enum: { |
| match(LITERAL_enum); |
| break; |
| } |
| case LITERAL_inline: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: { |
| fs = function_specifier(); |
| break; |
| } |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: { |
| { |
| switch (LA(1)) { |
| case LITERAL__stdcall: { |
| match(LITERAL__stdcall); |
| break; |
| } |
| case LITERAL___stdcall: { |
| match(LITERAL___stdcall); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL_GFEXCLUDE: { |
| match(LITERAL_GFEXCLUDE); |
| if (inputState->guessing == 0) { |
| #line 914 "CPP_parser.g" |
| tq |= tqGFEXCLUDE; |
| _tq |= tqGFEXCLUDE; |
| #line 1872 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_GFINCLUDE: { |
| match(LITERAL_GFINCLUDE); |
| if (inputState->guessing == 0) { |
| #line 915 "CPP_parser.g" |
| tq |= tqGFINCLUDE; |
| _tq |= tqGFINCLUDE; |
| #line 1882 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_GFID: { |
| match(LITERAL_GFID); |
| if (inputState->guessing == 0) { |
| #line 916 "CPP_parser.g" |
| tq |= tqGFID; |
| _tq |= tqGFID; |
| #line 1892 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_GFUNREAD: { |
| match(LITERAL_GFUNREAD); |
| if (inputState->guessing == 0) { |
| #line 917 "CPP_parser.g" |
| tq |= tqGFUNREAD; |
| _tq |= tqGFUNREAD; |
| #line 1902 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_GFARRAYSIZE: { |
| match(LITERAL_GFARRAYSIZE); |
| match(LPAREN); |
| gfArr = LT(1); |
| match(ID); |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 918 "CPP_parser.g" |
| gfArraySize(gfArr->getText().data()); |
| #line 1916 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_GFARRAYSIZES: { |
| match(LITERAL_GFARRAYSIZES); |
| match(LPAREN); |
| gfArrList = LT(1); |
| match(StringLiteral); |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 919 "CPP_parser.g" |
| gfArraySize(gfArrList->getText().data()); |
| #line 1930 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_GFARRAYELEMSIZE: { |
| match(LITERAL_GFARRAYELEMSIZE); |
| match(LPAREN); |
| gfArrElem = LT(1); |
| match(ID); |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 920 "CPP_parser.g" |
| gfArrayElemSize(gfArrElem->getText().data()); |
| #line 1944 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { goto _loop174; } |
| } |
| } |
| _loop174:; |
| } // ( ... )* |
| ts = type_specifier(); |
| } |
| if (inputState->guessing == 0) { |
| #line 924 "CPP_parser.g" |
| declarationSpecifier(td, fd, sc, tq, ts, fs); |
| #line 1961 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_24); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::function_declarator(int definition) { |
| try { // for error handling |
| bool synPredMatched298 = false; |
| if (((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2))))) { |
| int _m298 = mark(); |
| synPredMatched298 = true; |
| inputState->guessing++; |
| try { |
| { ptr_operator(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched298 = false; |
| } |
| rewind(_m298); |
| inputState->guessing--; |
| } |
| if (synPredMatched298) { |
| ptr_operator(); |
| function_declarator(definition); |
| } else if ((_tokenSet_27.member(LA(1))) && (_tokenSet_28.member(LA(2)))) { |
| function_direct_declarator(definition); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_29); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::declaration() { |
| try { // for error handling |
| bool synPredMatched159 = false; |
| if (((LA(1) == LITERAL_extern) && (LA(2) == StringLiteral))) { |
| int _m159 = mark(); |
| synPredMatched159 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_extern); |
| match(StringLiteral); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched159 = false; |
| } |
| rewind(_m159); |
| inputState->guessing--; |
| } |
| if (synPredMatched159) { |
| linkage_specification(); |
| } else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { |
| if (inputState->guessing == 0) { |
| #line 853 "CPP_parser.g" |
| beginDeclaration(); |
| #line 2044 "CPPParser.cpp" |
| } |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 854 "CPP_parser.g" |
| end_of_stmt(); |
| #line 2089 "CPPParser.cpp" |
| } |
| if (inputState->guessing == 0) { |
| #line 855 "CPP_parser.g" |
| endDeclaration(); |
| #line 2094 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LITERAL_using)) { |
| using_statement(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::template_head() { |
| try { // for error handling |
| match(LITERAL_template); |
| match(LESSTHAN); |
| template_parameter_list(); |
| match(GREATERTHAN); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_31); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| CPPParser::FunctionSpecifier CPPParser::function_specifier() { |
| #line 937 "CPP_parser.g" |
| CPPParser::FunctionSpecifier fs = fsInvalid; |
| #line 2136 "CPPParser.cpp" |
| |
| try { // for error handling |
| switch (LA(1)) { |
| case LITERAL_inline: |
| case LITERAL__inline: |
| case LITERAL___inline: { |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case LITERAL__inline: { |
| match(LITERAL__inline); |
| break; |
| } |
| case LITERAL___inline: { |
| match(LITERAL___inline); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 938 "CPP_parser.g" |
| fs = fsINLINE; |
| #line 2170 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_virtual: { |
| match(LITERAL_virtual); |
| if (inputState->guessing == 0) { |
| #line 939 "CPP_parser.g" |
| fs = fsVIRTUAL; |
| #line 2180 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_explicit: { |
| match(LITERAL_explicit); |
| if (inputState->guessing == 0) { |
| #line 940 "CPP_parser.g" |
| fs = fsEXPLICIT; |
| #line 2190 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_14); |
| } else { |
| throw; |
| } |
| } |
| return fs; |
| } |
| |
| void CPPParser::dtor_head(int definition) { |
| try { // for error handling |
| dtor_decl_spec(); |
| dtor_declarator(definition); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_32); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::dtor_body() { |
| try { // for error handling |
| compound_statement(); |
| if (inputState->guessing == 0) { |
| #line 1476 "CPP_parser.g" |
| endDestructorDefinition(); |
| #line 2236 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ctor_decl_spec() { |
| try { // for error handling |
| { // ( ... )* |
| for (;;) { |
| switch (LA(1)) { |
| case LITERAL_inline: |
| case LITERAL__inline: |
| case LITERAL___inline: { |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case LITERAL__inline: { |
| match(LITERAL__inline); |
| break; |
| } |
| case LITERAL___inline: { |
| match(LITERAL___inline); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL_explicit: { |
| match(LITERAL_explicit); |
| break; |
| } |
| default: { goto _loop311; } |
| } |
| } |
| _loop311:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_33); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ctor_definition() { |
| try { // for error handling |
| ctor_head(); |
| ctor_body(); |
| if (inputState->guessing == 0) { |
| #line 1385 "CPP_parser.g" |
| endConstructorDefinition(); |
| #line 2316 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| char* CPPParser::scope_override() { |
| #line 2226 "CPP_parser.g" |
| char* s = NULL; |
| #line 2332 "CPPParser.cpp" |
| ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 2226 "CPP_parser.g" |
| |
| static char sitem[CPPParser_MaxQualifiedItemSize + 1]; |
| sitem[0] = '\0'; |
| |
| #line 2339 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case SCOPE: { |
| match(SCOPE); |
| if (inputState->guessing == 0) { |
| #line 2232 "CPP_parser.g" |
| strcat(sitem, "::"); |
| #line 2350 "CPPParser.cpp" |
| } |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) == ID) && (LA(2) == LESSTHAN || LA(2) == SCOPE)) && |
| (scopedItem())) { |
| id = LT(1); |
| match(ID); |
| { |
| switch (LA(1)) { |
| case LESSTHAN: { |
| match(LESSTHAN); |
| template_argument_list(); |
| match(GREATERTHAN); |
| break; |
| } |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SCOPE); |
| { |
| switch (LA(1)) { |
| case LITERAL_template: { |
| match(LITERAL_template); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 2238 "CPP_parser.g" |
| |
| CPPSymbol* cs = (CPPSymbol*)symbols->lookup((id->getText()).data()); |
| strcat(sitem, (id->getText()).data()); |
| strcat(sitem, "::"); |
| |
| #line 2425 "CPPParser.cpp" |
| } |
| } else { |
| goto _loop587; |
| } |
| } |
| _loop587:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 2244 "CPP_parser.g" |
| s = sitem; |
| #line 2438 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_34); |
| } else { |
| throw; |
| } |
| } |
| return s; |
| } |
| |
| void CPPParser::conversion_function_decl_or_def() { |
| #line 1302 "CPP_parser.g" |
| CPPParser::TypeQualifier tq; |
| #line 2455 "CPPParser.cpp" |
| |
| try { // for error handling |
| match(OPERATOR); |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case STAR: { |
| match(STAR); |
| break; |
| } |
| case AMPERSAND: { |
| match(AMPERSAND); |
| break; |
| } |
| case LESSTHAN: |
| case LPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case LESSTHAN: { |
| match(LESSTHAN); |
| template_parameter_list(); |
| match(GREATERTHAN); |
| break; |
| } |
| case LPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop293; |
| } |
| } |
| _loop293:; |
| } // ( ... )* |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case SEMICOLON: |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case LCURLY: { |
| compound_statement(); |
| break; |
| } |
| case SEMICOLON: { |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1311 "CPP_parser.g" |
| end_of_stmt(); |
| #line 2645 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::function_definition() { |
| try { // for error handling |
| if (inputState->guessing == 0) { |
| #line 822 "CPP_parser.g" |
| |
| beginFunctionDefinition(); |
| |
| #line 2674 "CPPParser.cpp" |
| } |
| { |
| if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) && |
| ((!(LA(1) == SCOPE || LA(1) == ID) || |
| qualifiedItemIsOneOf(qiType | qiCtor)))) { |
| declaration_specifiers(); |
| function_declarator(1); |
| { |
| if ((_tokenSet_35.member(LA(1))) && (_tokenSet_36.member(LA(2)))) { |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_2.member(LA(1)))) { |
| declaration(); |
| } else { |
| goto _loop153; |
| } |
| } |
| _loop153:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 831 "CPP_parser.g" |
| in_parameter_list = false; |
| #line 2697 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LCURLY) && (_tokenSet_37.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| compound_statement(); |
| } else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_39.member(LA(2)))) { |
| function_declarator(1); |
| { |
| if ((_tokenSet_35.member(LA(1))) && (_tokenSet_36.member(LA(2)))) { |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_2.member(LA(1)))) { |
| declaration(); |
| } else { |
| goto _loop156; |
| } |
| } |
| _loop156:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 840 "CPP_parser.g" |
| in_parameter_list = false; |
| #line 2728 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LCURLY) && (_tokenSet_37.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| compound_statement(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 844 "CPP_parser.g" |
| endFunctionDefinition(); |
| #line 2748 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::namespace_definition() { |
| ANTLR_USE_NAMESPACE(antlr) RefToken ns = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case ID: { |
| ns = LT(1); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 568 "CPP_parser.g" |
| declaratorID((ns->getText()).data(), qiNamespace); |
| #line 2774 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LCURLY); |
| if (inputState->guessing == 0) { |
| #line 570 "CPP_parser.g" |
| enterNewLocalScope(); |
| #line 2792 "CPPParser.cpp" |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_0.member(LA(1)))) { |
| external_declaration(); |
| } else { |
| goto _loop72; |
| } |
| } |
| _loop72:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 572 "CPP_parser.g" |
| exitNamespaceScope(); |
| exitLocalScope(); |
| #line 2809 "CPPParser.cpp" |
| } |
| match(RCURLY); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_19); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::namespace_alias_definition() { |
| ANTLR_USE_NAMESPACE(antlr) |
| RefToken ns2 = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 577 "CPP_parser.g" |
| char* qid; |
| #line 2827 "CPPParser.cpp" |
| |
| try { // for error handling |
| match(LITERAL_namespace); |
| ns2 = LT(1); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 581 "CPP_parser.g" |
| declaratorID((ns2->getText()).data(), qiNamespace); |
| #line 2836 "CPPParser.cpp" |
| } |
| match(ASSIGNEQUAL); |
| qid = qualified_id(); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 582 "CPP_parser.g" |
| end_of_stmt(); |
| #line 2844 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| char* CPPParser::qualified_id() { |
| #line 1143 "CPP_parser.g" |
| char* q = NULL; |
| #line 2860 "CPPParser.cpp" |
| ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 1143 "CPP_parser.g" |
| |
| char* so = NULL; |
| static char qitem[CPPParser_MaxQualifiedItemSize + 1]; |
| |
| #line 2867 "CPPParser.cpp" |
| |
| try { // for error handling |
| so = scope_override(); |
| if (inputState->guessing == 0) { |
| #line 1150 "CPP_parser.g" |
| strcpy(qitem, so); |
| #line 2874 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ID: { |
| id = LT(1); |
| match(ID); |
| { |
| switch (LA(1)) { |
| case LESSTHAN: { |
| match(LESSTHAN); |
| template_argument_list(); |
| match(GREATERTHAN); |
| break; |
| } |
| case GREATERTHAN: |
| case SEMICOLON: |
| case ID: |
| case LCURLY: |
| case ASSIGNEQUAL: |
| case COLON: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case RPAREN: |
| case COMMA: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case LSQUARE: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1155 "CPP_parser.g" |
| strcat(qitem, (id->getText()).data()); |
| #line 2934 "CPPParser.cpp" |
| } |
| break; |
| } |
| case OPERATOR: { |
| match(OPERATOR); |
| optor(); |
| if (inputState->guessing == 0) { |
| #line 1158 "CPP_parser.g" |
| strcat(qitem, "operator"); |
| strcat(qitem, "NYI"); |
| #line 2945 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_this: { |
| match(LITERAL_this); |
| break; |
| } |
| case LITERAL_true: |
| case LITERAL_false: { |
| { |
| switch (LA(1)) { |
| case LITERAL_true: { |
| match(LITERAL_true); |
| break; |
| } |
| case LITERAL_false: { |
| match(LITERAL_false); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1164 "CPP_parser.g" |
| q = qitem; |
| #line 2986 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_41); |
| } else { |
| throw; |
| } |
| } |
| return q; |
| } |
| |
| void CPPParser::member_declaration() { |
| #line 585 "CPP_parser.g" |
| char* q; |
| FunctionSpecifier fs = fsInvalid; // inline,virtual,explicit |
| |
| #line 3005 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_public: |
| case LITERAL_protected: |
| case LITERAL_private: { |
| if (inputState->guessing == 0) { |
| #line 799 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d member_declaration Access specifier\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3019 "CPPParser.cpp" |
| } |
| access_specifier(); |
| match(COLON); |
| break; |
| } |
| case SEMICOLON: { |
| if (inputState->guessing == 0) { |
| #line 805 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d member_declaration Semicolon\n", LT(1)->getLine()); |
| } |
| |
| #line 3032 "CPPParser.cpp" |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 808 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3038 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_antlrTrace_on: { |
| match(LITERAL_antlrTrace_on); |
| if (inputState->guessing == 0) { |
| #line 812 "CPP_parser.g" |
| antlrTrace(true); |
| #line 3048 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_antlrTrace_off: { |
| match(LITERAL_antlrTrace_off); |
| if (inputState->guessing == 0) { |
| #line 815 "CPP_parser.g" |
| antlrTrace(false); |
| #line 3058 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: |
| bool synPredMatched77 = false; |
| if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) { |
| int _m77 = mark(); |
| synPredMatched77 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_template); |
| match(LESSTHAN); |
| match(GREATERTHAN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched77 = false; |
| } |
| rewind(_m77); |
| inputState->guessing--; |
| } |
| if (synPredMatched77) { |
| if (inputState->guessing == 0) { |
| #line 593 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Template explicit-specialisation\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3087 "CPPParser.cpp" |
| } |
| match(LITERAL_template); |
| match(LESSTHAN); |
| match(GREATERTHAN); |
| member_declaration(); |
| } else { |
| bool synPredMatched79 = false; |
| if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) { |
| int _m79 = mark(); |
| synPredMatched79 = true; |
| inputState->guessing++; |
| try { |
| { match(LITERAL_typedef); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched79 = false; |
| } |
| rewind(_m79); |
| inputState->guessing--; |
| } |
| if (synPredMatched79) { |
| { |
| bool synPredMatched82 = false; |
| if (((LA(1) == LITERAL_typedef) && |
| ((LA(2) >= LITERAL_struct && LA(2) <= LITERAL_class)))) { |
| int _m82 = mark(); |
| synPredMatched82 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_typedef); |
| class_specifier(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched82 = false; |
| } |
| rewind(_m82); |
| inputState->guessing--; |
| } |
| if (synPredMatched82) { |
| if (inputState->guessing == 0) { |
| #line 602 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d member_declaration Typedef class type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3136 "CPPParser.cpp" |
| } |
| match(LITERAL_typedef); |
| class_decl_or_def(fs); |
| if (inputState->guessing == 0) { |
| #line 605 "CPP_parser.g" |
| _td = true; |
| #line 3143 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 605 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3187 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched85 = false; |
| if (((LA(1) == LITERAL_typedef) && (LA(2) == LITERAL_enum))) { |
| int _m85 = mark(); |
| synPredMatched85 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_typedef); |
| match(LITERAL_enum); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched85 = false; |
| } |
| rewind(_m85); |
| inputState->guessing--; |
| } |
| if (synPredMatched85) { |
| if (inputState->guessing == 0) { |
| #line 608 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d member_declaration Typedef enum type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3214 "CPPParser.cpp" |
| } |
| match(LITERAL_typedef); |
| enum_specifier(); |
| if (inputState->guessing == 0) { |
| #line 611 "CPP_parser.g" |
| _td = true; |
| #line 3221 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 611 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3265 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched88 = false; |
| if (((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2))))) { |
| int _m88 = mark(); |
| synPredMatched88 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched88 = false; |
| } |
| rewind(_m88); |
| inputState->guessing--; |
| } |
| if (synPredMatched88) { |
| if (inputState->guessing == 0) { |
| #line 614 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Typedef function type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3293 "CPPParser.cpp" |
| } |
| declaration(); |
| } else if ((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2)))) { |
| if (inputState->guessing == 0) { |
| #line 619 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Typedef variable type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3303 "CPPParser.cpp" |
| } |
| declaration(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } else { |
| bool synPredMatched92 = false; |
| if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) { |
| int _m92 = mark(); |
| synPredMatched92 = true; |
| inputState->guessing++; |
| try { |
| { |
| template_head(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop91; |
| } |
| } |
| _loop91:; |
| } // ( ... )* |
| class_specifier(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched92 = false; |
| } |
| rewind(_m92); |
| inputState->guessing--; |
| } |
| if (synPredMatched92) { |
| if (inputState->guessing == 0) { |
| #line 627 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Templated class decl or def\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3349 "CPPParser.cpp" |
| } |
| template_head(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop94; |
| } |
| } |
| _loop94:; |
| } // ( ... )* |
| class_decl_or_def(fs); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 630 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3407 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched98 = false; |
| if (((LA(1) == LITERAL_enum) && (_tokenSet_5.member(LA(2))))) { |
| int _m98 = mark(); |
| synPredMatched98 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LITERAL_enum); |
| { |
| switch (LA(1)) { |
| case ID: { |
| match(ID); |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched98 = false; |
| } |
| rewind(_m98); |
| inputState->guessing--; |
| } |
| if (synPredMatched98) { |
| if (inputState->guessing == 0) { |
| #line 634 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d member_declaration Enum definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3451 "CPPParser.cpp" |
| } |
| enum_specifier(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case COLON: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| member_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 637 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3497 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched101 = false; |
| if (((_tokenSet_8.member(LA(1))) && |
| (_tokenSet_9.member(LA(2))))) { |
| int _m101 = mark(); |
| synPredMatched101 = true; |
| inputState->guessing++; |
| try { |
| { |
| ctor_decl_spec(); |
| if (!(qualifiedItemIsOneOf(qiCtor))) { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| SemanticException("qualifiedItemIsOneOf(qiCtor)"); |
| } |
| ctor_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched101 = false; |
| } |
| rewind(_m101); |
| inputState->guessing--; |
| } |
| if (synPredMatched101) { |
| if (inputState->guessing == 0) { |
| #line 644 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf("%d member_declaration Constructor declarator\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3527 "CPPParser.cpp" |
| } |
| ctor_decl_spec(); |
| ctor_declarator(0); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 647 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3535 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched104 = false; |
| if (((_tokenSet_8.member(LA(1))) && |
| (_tokenSet_9.member(LA(2))))) { |
| int _m104 = mark(); |
| synPredMatched104 = true; |
| inputState->guessing++; |
| try { |
| { |
| ctor_decl_spec(); |
| if (!(qualifiedItemIsOneOf(qiCtor))) { |
| throw ANTLR_USE_NAMESPACE(antlr) SemanticException( |
| "qualifiedItemIsOneOf(qiCtor)"); |
| } |
| ctor_declarator(1); |
| { |
| switch (LA(1)) { |
| case COLON: { |
| match(COLON); |
| break; |
| } |
| case LCURLY: { |
| match(LCURLY); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched104 = false; |
| } |
| rewind(_m104); |
| inputState->guessing--; |
| } |
| if (synPredMatched104) { |
| if (inputState->guessing == 0) { |
| #line 661 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Constructor definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3582 "CPPParser.cpp" |
| } |
| ctor_definition(); |
| } else { |
| bool synPredMatched106 = false; |
| if (((_tokenSet_42.member(LA(1))) && |
| (_tokenSet_7.member(LA(2))))) { |
| int _m106 = mark(); |
| synPredMatched106 = true; |
| inputState->guessing++; |
| try { |
| { |
| dtor_head(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched106 = false; |
| } |
| rewind(_m106); |
| inputState->guessing--; |
| } |
| if (synPredMatched106) { |
| if (inputState->guessing == 0) { |
| #line 670 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Destructor " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3610 "CPPParser.cpp" |
| } |
| dtor_head(0); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 673 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3617 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched108 = false; |
| if (((_tokenSet_42.member(LA(1))) && |
| (_tokenSet_7.member(LA(2))))) { |
| int _m108 = mark(); |
| synPredMatched108 = true; |
| inputState->guessing++; |
| try { |
| { |
| dtor_head(1); |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched108 = false; |
| } |
| rewind(_m108); |
| inputState->guessing--; |
| } |
| if (synPredMatched108) { |
| if (inputState->guessing == 0) { |
| #line 679 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Destructor " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3644 "CPPParser.cpp" |
| } |
| dtor_head(1); |
| dtor_body(); |
| } else { |
| bool synPredMatched110 = false; |
| if (((_tokenSet_12.member(LA(1))) && |
| (_tokenSet_13.member(LA(2))))) { |
| int _m110 = mark(); |
| synPredMatched110 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched110 = false; |
| } |
| rewind(_m110); |
| inputState->guessing--; |
| } |
| if (synPredMatched110) { |
| if (inputState->guessing == 0) { |
| #line 686 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Function " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3674 "CPPParser.cpp" |
| } |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 689 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3682 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched112 = false; |
| if (((_tokenSet_14.member(LA(1))) && |
| (_tokenSet_15.member(LA(2))))) { |
| int _m112 = mark(); |
| synPredMatched112 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(1); |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched112 = false; |
| } |
| rewind(_m112); |
| inputState->guessing--; |
| } |
| if (synPredMatched112) { |
| if (inputState->guessing == 0) { |
| #line 693 "CPP_parser.g" |
| beginFieldDeclaration(); |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Function " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3711 "CPPParser.cpp" |
| } |
| function_definition(); |
| } else { |
| bool synPredMatched115 = false; |
| if (((LA(1) == LITERAL_inline || |
| LA(1) == OPERATOR) && |
| (_tokenSet_43.member(LA(2))))) { |
| int _m115 = mark(); |
| synPredMatched115 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case OPERATOR: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| conversion_function_decl_or_def(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched115 = false; |
| } |
| rewind(_m115); |
| inputState->guessing--; |
| } |
| if (synPredMatched115) { |
| if (inputState->guessing == 0) { |
| #line 701 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Operator " |
| "function\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3755 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case OPERATOR: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), |
| getFilename()); |
| } |
| } |
| } |
| conversion_function_decl_or_def(); |
| } else { |
| bool synPredMatched118 = false; |
| if (((_tokenSet_44.member(LA(1))) && |
| (_tokenSet_45.member(LA(2))))) { |
| int _m118 = mark(); |
| synPredMatched118 = true; |
| inputState->guessing++; |
| try { |
| { |
| qualified_id(); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched118 = false; |
| } |
| rewind(_m118); |
| inputState->guessing--; |
| } |
| if (synPredMatched118) { |
| if (inputState->guessing == 0) { |
| #line 710 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Qualified " |
| "ID\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3800 "CPPParser.cpp" |
| } |
| q = qualified_id(); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 713 "CPP_parser.g" |
| end_of_stmt(); |
| #line 3807 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched121 = false; |
| if (((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2))))) { |
| int _m121 = mark(); |
| synPredMatched121 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched121 = false; |
| } |
| rewind(_m121); |
| inputState->guessing--; |
| } |
| if (synPredMatched121) { |
| if (inputState->guessing == 0) { |
| #line 718 "CPP_parser.g" |
| beginFieldDeclaration(); |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration " |
| "Declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3873 "CPPParser.cpp" |
| } |
| declaration(); |
| } else { |
| bool synPredMatched126 = false; |
| if (((_tokenSet_16.member(LA(1))) && |
| (_tokenSet_17.member(LA(2))))) { |
| int _m126 = mark(); |
| synPredMatched126 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case LITERAL_friend: { |
| match(LITERAL_friend); |
| break; |
| } |
| case LITERAL_inline: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop125; |
| } |
| } |
| _loop125:; |
| } // ( ... )* |
| class_specifier(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched126 = false; |
| } |
| rewind(_m126); |
| inputState->guessing--; |
| } |
| if (synPredMatched126) { |
| if (inputState->guessing == 0) { |
| #line 726 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration Class " |
| "decl or def\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 3936 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_friend: { |
| match(LITERAL_friend); |
| break; |
| } |
| case LITERAL_inline: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop129; |
| } |
| } |
| _loop129:; |
| } // ( ... )* |
| class_decl_or_def(fs); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 729 "CPP_parser.g" |
| end_of_stmt(); |
| #line 4017 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched134 = false; |
| if (((_tokenSet_46.member(LA(1))) && |
| (_tokenSet_47.member(LA(2))))) { |
| int _m134 = mark(); |
| synPredMatched134 = true; |
| inputState->guessing++; |
| try { |
| { |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member( |
| LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop133; |
| } |
| } |
| _loop133:; |
| } // ( ... )* |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched134 = false; |
| } |
| rewind(_m134); |
| inputState->guessing--; |
| } |
| if (synPredMatched134) { |
| if (inputState->guessing == 0) { |
| #line 733 "CPP_parser.g" |
| beginFieldDeclaration(); |
| fprintf(stderr, |
| "%d warning Function " |
| "declaration found without " |
| "return type\n", |
| LT(1)->getLine()); |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration " |
| "Function declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4058 "CPPParser.cpp" |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_4.member(LA(1)))) { |
| fs = function_specifier(); |
| } else { |
| goto _loop136; |
| } |
| } |
| _loop136:; |
| } // ( ... )* |
| function_declarator(0); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 738 "CPP_parser.g" |
| end_of_stmt(); |
| #line 4077 "CPPParser.cpp" |
| } |
| } else if ((_tokenSet_38.member(LA(1))) && |
| (_tokenSet_39.member(LA(2)))) { |
| if (inputState->guessing == 0) { |
| #line 742 "CPP_parser.g" |
| |
| fprintf(stderr, |
| "%d warning Function " |
| "definition found without " |
| "return type\n", |
| LT(1)->getLine()); |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration " |
| "Function definition without " |
| "return type\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4088 "CPPParser.cpp" |
| } |
| function_declarator(1); |
| compound_statement(); |
| if (inputState->guessing == 0) { |
| #line 747 "CPP_parser.g" |
| endFunctionDefinition(); |
| #line 4095 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LITERAL_template) && |
| (LA(2) == LESSTHAN)) { |
| if (inputState->guessing == 0) { |
| #line 750 "CPP_parser.g" |
| beginTemplateDeclaration(); |
| #line 4102 "CPPParser.cpp" |
| } |
| template_head(); |
| { |
| bool synPredMatched140 = false; |
| if (((_tokenSet_12.member(LA(1))) && |
| (_tokenSet_18.member(LA(2))))) { |
| int _m140 = mark(); |
| synPredMatched140 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE( |
| antlr) |
| NoViableAltException( |
| LT(1), |
| getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| } |
| } catch ( |
| ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched140 = false; |
| } |
| rewind(_m140); |
| inputState->guessing--; |
| } |
| if (synPredMatched140) { |
| if (inputState->guessing == 0) { |
| #line 755 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration " |
| "Templated forward " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4167 "CPPParser.cpp" |
| } |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE( |
| antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 758 "CPP_parser.g" |
| end_of_stmt(); |
| #line 4212 "CPPParser.cpp" |
| } |
| } else { |
| bool synPredMatched143 = false; |
| if (((_tokenSet_2.member(LA(1))) && |
| (_tokenSet_3.member(LA(2))))) { |
| int _m143 = mark(); |
| synPredMatched143 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(0); |
| match(SEMICOLON); |
| } |
| } catch (ANTLR_USE_NAMESPACE( |
| antlr) RecognitionException& |
| pe) { |
| synPredMatched143 = false; |
| } |
| rewind(_m143); |
| inputState->guessing--; |
| } |
| if (synPredMatched143) { |
| if (inputState->guessing == 0) { |
| #line 762 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration " |
| "Templated function " |
| "declaration\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4240 "CPPParser.cpp" |
| } |
| declaration(); |
| } else { |
| bool synPredMatched145 = false; |
| if (((_tokenSet_14.member( |
| LA(1))) && |
| (_tokenSet_15.member( |
| LA(2))))) { |
| int _m145 = mark(); |
| synPredMatched145 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| function_declarator(1); |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE( |
| antlr) RecognitionException& |
| pe) { |
| synPredMatched145 = false; |
| } |
| rewind(_m145); |
| inputState->guessing--; |
| } |
| if (synPredMatched145) { |
| if (inputState->guessing == 0) { |
| #line 769 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d member_declaration " |
| "Templated function " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4269 "CPPParser.cpp" |
| } |
| function_definition(); |
| } else { |
| bool synPredMatched147 = false; |
| if (((_tokenSet_8.member( |
| LA(1))) && |
| (_tokenSet_9.member( |
| LA(2))))) { |
| int _m147 = mark(); |
| synPredMatched147 = true; |
| inputState->guessing++; |
| try { |
| { |
| ctor_decl_spec(); |
| if (!(qualifiedItemIsOneOf( |
| qiCtor))) { |
| throw ANTLR_USE_NAMESPACE( |
| antlr) |
| SemanticException( |
| "qualifiedItemI" |
| "sOneOf(" |
| "qiCtor)"); |
| } |
| } |
| } catch ( |
| ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& |
| pe) { |
| synPredMatched147 = false; |
| } |
| rewind(_m147); |
| inputState->guessing--; |
| } |
| if (synPredMatched147) { |
| if (inputState->guessing == |
| 0) { |
| #line 779 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d " |
| "member_declaration " |
| "Templated " |
| "constructor " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4298 "CPPParser.cpp" |
| } |
| ctor_definition(); |
| } else if ((LA(1) == |
| OPERATOR) && |
| (_tokenSet_12.member( |
| LA(2)))) { |
| if (inputState->guessing == |
| 0) { |
| #line 785 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d " |
| "member_declaration " |
| "Templated operator " |
| "function\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4308 "CPPParser.cpp" |
| } |
| conversion_function_decl_or_def(); |
| } else if ( |
| ((LA(1) >= LITERAL_struct && |
| LA(1) <= |
| LITERAL_class)) && |
| (LA(2) == ID || |
| LA(2) == LCURLY)) { |
| if (inputState->guessing == |
| 0) { |
| #line 791 "CPP_parser.g" |
| if (statementTrace >= 1) { |
| printf( |
| "%d " |
| "member_declaration " |
| "Templated class " |
| "definition\n", |
| LT(1)->getLine()); |
| } |
| |
| #line 4318 "CPPParser.cpp" |
| } |
| class_head(); |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE( |
| antlr) |
| NoViableAltException( |
| LT(1), |
| getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == |
| 0) { |
| #line 794 "CPP_parser.g" |
| end_of_stmt(); |
| #line 4364 "CPPParser.cpp" |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE( |
| antlr) |
| NoViableAltException( |
| LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 796 "CPP_parser.g" |
| endTemplateDeclaration(); |
| #line 4375 "CPPParser.cpp" |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), |
| getFilename()); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::member_declarator_list() { |
| try { // for error handling |
| member_declarator(); |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| match(OCTALINT); |
| break; |
| } |
| case SEMICOLON: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| member_declarator(); |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| match(OCTALINT); |
| break; |
| } |
| case SEMICOLON: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else { |
| goto _loop253; |
| } |
| } |
| _loop253:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_22); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ctor_declarator(int definition) { |
| #line 1402 "CPP_parser.g" |
| char* q; |
| #line 4465 "CPPParser.cpp" |
| |
| try { // for error handling |
| q = qualified_ctor_id(); |
| if (inputState->guessing == 0) { |
| #line 1406 "CPP_parser.g" |
| declaratorParameterList(definition); |
| #line 4472 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1408 "CPP_parser.g" |
| declaratorEndParameterList(definition); |
| #line 4577 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case SEMICOLON: |
| case LCURLY: |
| case COLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_48); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::compound_statement() { |
| try { // for error handling |
| match(LCURLY); |
| if (inputState->guessing == 0) { |
| #line 1746 "CPP_parser.g" |
| end_of_stmt(); |
| enterNewLocalScope(); |
| |
| #line 4618 "CPPParser.cpp" |
| } |
| { |
| if ((_tokenSet_49.member(LA(1)))) { |
| statement_list(); |
| } else if ((LA(1) == RCURLY)) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| match(RCURLY); |
| if (inputState->guessing == 0) { |
| #line 1751 "CPP_parser.g" |
| exitLocalScope(); |
| #line 4635 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_50); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::class_head() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_struct: { |
| match(LITERAL_struct); |
| break; |
| } |
| case LITERAL_union: { |
| match(LITERAL_union); |
| break; |
| } |
| case LITERAL_class: { |
| match(LITERAL_class); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case ID: { |
| match(ID); |
| { |
| switch (LA(1)) { |
| case LESSTHAN: { |
| match(LESSTHAN); |
| template_argument_list(); |
| match(GREATERTHAN); |
| break; |
| } |
| case LCURLY: |
| case COLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case COLON: { |
| base_clause(); |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LCURLY); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_12); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::access_specifier() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_public: { |
| match(LITERAL_public); |
| break; |
| } |
| case LITERAL_protected: { |
| match(LITERAL_protected); |
| break; |
| } |
| case LITERAL_private: { |
| match(LITERAL_private); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_51); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::linkage_specification() { |
| try { // for error handling |
| match(LITERAL_extern); |
| match(StringLiteral); |
| { |
| switch (LA(1)) { |
| case LCURLY: { |
| match(LCURLY); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_0.member(LA(1)))) { |
| external_declaration(); |
| } else { |
| goto _loop164; |
| } |
| } |
| _loop164:; |
| } // ( ... )* |
| match(RCURLY); |
| break; |
| } |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case LITERAL_using: |
| case SCOPE: { |
| declaration(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::using_statement() { |
| #line 1836 "CPP_parser.g" |
| char* qid; |
| #line 4890 "CPPParser.cpp" |
| |
| try { // for error handling |
| match(LITERAL_using); |
| { |
| switch (LA(1)) { |
| case LITERAL_namespace: { |
| match(LITERAL_namespace); |
| qid = qualified_id(); |
| break; |
| } |
| case ID: |
| case LITERAL_typename: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case SCOPE: { |
| { |
| switch (LA(1)) { |
| case LITERAL_typename: { |
| match(LITERAL_typename); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| qid = qualified_id(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1843 "CPP_parser.g" |
| end_of_stmt(); |
| #line 4945 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::template_argument_list() { |
| try { // for error handling |
| template_argument(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| template_argument(); |
| } else { |
| goto _loop385; |
| } |
| } |
| _loop385:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_52); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::base_clause() { |
| try { // for error handling |
| match(COLON); |
| base_specifier(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| base_specifier(); |
| } else { |
| goto _loop220; |
| } |
| } |
| _loop220:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_53); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| CPPParser::StorageClass CPPParser::storage_class_specifier() { |
| #line 928 "CPP_parser.g" |
| CPPParser::StorageClass sc = scInvalid; |
| #line 5018 "CPPParser.cpp" |
| |
| try { // for error handling |
| switch (LA(1)) { |
| case LITERAL_auto: { |
| match(LITERAL_auto); |
| if (inputState->guessing == 0) { |
| #line 929 "CPP_parser.g" |
| sc = scAUTO; |
| #line 5028 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_register: { |
| match(LITERAL_register); |
| if (inputState->guessing == 0) { |
| #line 930 "CPP_parser.g" |
| sc = scREGISTER; |
| #line 5038 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_static: { |
| match(LITERAL_static); |
| if (inputState->guessing == 0) { |
| #line 931 "CPP_parser.g" |
| sc = scSTATIC; |
| #line 5048 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_extern: { |
| match(LITERAL_extern); |
| if (inputState->guessing == 0) { |
| #line 932 "CPP_parser.g" |
| sc = scEXTERN; |
| #line 5058 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_mutable: { |
| match(LITERAL_mutable); |
| if (inputState->guessing == 0) { |
| #line 933 "CPP_parser.g" |
| sc = scMUTABLE; |
| #line 5068 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_12); |
| } else { |
| throw; |
| } |
| } |
| return sc; |
| } |
| |
| CPPParser::TypeQualifier CPPParser::type_qualifier() { |
| #line 1025 "CPP_parser.g" |
| CPPParser::TypeQualifier tq = tqInvalid; |
| #line 5092 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_const: |
| case LITERAL___const: { |
| { |
| switch (LA(1)) { |
| case LITERAL_const: { |
| match(LITERAL_const); |
| break; |
| } |
| case LITERAL___const: { |
| match(LITERAL___const); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1027 "CPP_parser.g" |
| tq = tqCONST; |
| #line 5121 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_volatile: |
| case LITERAL___volatile__: { |
| { |
| switch (LA(1)) { |
| case LITERAL_volatile: { |
| match(LITERAL_volatile); |
| break; |
| } |
| case LITERAL___volatile__: { |
| match(LITERAL___volatile__); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1028 "CPP_parser.g" |
| tq = tqVOLATILE; |
| #line 5149 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_54); |
| } else { |
| throw; |
| } |
| } |
| return tq; |
| } |
| |
| CPPParser::TypeSpecifier CPPParser::type_specifier() { |
| #line 944 "CPP_parser.g" |
| CPPParser::TypeSpecifier ts = tsInvalid; |
| #line 5174 "CPPParser.cpp" |
| #line 944 "CPP_parser.g" |
| |
| TypeQualifier tq = tqInvalid; |
| |
| #line 5179 "CPPParser.cpp" |
| |
| try { // for error handling |
| ts = simple_type_specifier(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_24); |
| } else { |
| throw; |
| } |
| } |
| return ts; |
| } |
| |
| CPPParser::TypeSpecifier CPPParser::simple_type_specifier() { |
| #line 953 "CPP_parser.g" |
| CPPParser::TypeSpecifier ts = tsInvalid; |
| #line 5198 "CPPParser.cpp" |
| #line 953 "CPP_parser.g" |
| char* s; |
| ts = tsInvalid; |
| |
| #line 5203 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_typename: { |
| match(LITERAL_typename); |
| s = qualified_type(); |
| if (inputState->guessing == 0) { |
| #line 962 "CPP_parser.g" |
| declaratorID(s, qiType); |
| #line 5215 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: { |
| { // ( ... )+ |
| int _cnt192 = 0; |
| for (;;) { |
| switch (LA(1)) { |
| case LITERAL_char: { |
| match(LITERAL_char); |
| if (inputState->guessing == 0) { |
| #line 964 "CPP_parser.g" |
| ts |= tsCHAR; |
| #line 5261 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_wchar_t: { |
| match(LITERAL_wchar_t); |
| if (inputState->guessing == 0) { |
| #line 965 "CPP_parser.g" |
| ts |= tsWCHAR_T; |
| #line 5271 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_bool: { |
| match(LITERAL_bool); |
| if (inputState->guessing == 0) { |
| #line 966 "CPP_parser.g" |
| ts |= tsBOOL; |
| #line 5281 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_short: { |
| match(LITERAL_short); |
| if (inputState->guessing == 0) { |
| #line 967 "CPP_parser.g" |
| ts |= tsSHORT; |
| #line 5291 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_int: { |
| match(LITERAL_int); |
| if (inputState->guessing == 0) { |
| #line 968 "CPP_parser.g" |
| ts |= tsINT; |
| #line 5301 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 50: |
| case 51: |
| case 52: { |
| { |
| switch (LA(1)) { |
| case 50: { |
| match(50); |
| break; |
| } |
| case 51: { |
| match(51); |
| break; |
| } |
| case 52: { |
| match(52); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 969 "CPP_parser.g" |
| ts |= tsINT; |
| #line 5335 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 53: |
| case 54: |
| case 55: { |
| { |
| switch (LA(1)) { |
| case 53: { |
| match(53); |
| break; |
| } |
| case 54: { |
| match(54); |
| break; |
| } |
| case 55: { |
| match(55); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 970 "CPP_parser.g" |
| ts |= tsINT; |
| #line 5369 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 56: |
| case 57: |
| case 58: { |
| { |
| switch (LA(1)) { |
| case 56: { |
| match(56); |
| break; |
| } |
| case 57: { |
| match(57); |
| break; |
| } |
| case 58: { |
| match(58); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 971 "CPP_parser.g" |
| ts |= tsLONG; |
| #line 5403 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 59: |
| case 60: |
| case 61: { |
| { |
| switch (LA(1)) { |
| case 59: { |
| match(59); |
| break; |
| } |
| case 60: { |
| match(60); |
| break; |
| } |
| case 61: { |
| match(61); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 972 "CPP_parser.g" |
| ts |= tsLONG; |
| #line 5437 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 62: { |
| { match(62); } |
| if (inputState->guessing == 0) { |
| #line 973 "CPP_parser.g" |
| ts |= (tsUNSIGNED | tsINT); |
| #line 5449 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 63: { |
| { match(63); } |
| if (inputState->guessing == 0) { |
| #line 974 "CPP_parser.g" |
| ts |= (tsUNSIGNED | tsINT); |
| #line 5461 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 64: { |
| { match(64); } |
| if (inputState->guessing == 0) { |
| #line 975 "CPP_parser.g" |
| ts |= (tsUNSIGNED | tsLONG); |
| #line 5473 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 65: { |
| { match(65); } |
| if (inputState->guessing == 0) { |
| #line 976 "CPP_parser.g" |
| ts |= (tsUNSIGNED | tsLONG); |
| #line 5485 "CPPParser.cpp" |
| } |
| break; |
| } |
| case 66: |
| case 67: { |
| { |
| switch (LA(1)) { |
| case 66: { |
| match(66); |
| break; |
| } |
| case 67: { |
| match(67); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 977 "CPP_parser.g" |
| ts |= tsLONG; |
| #line 5513 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_long: { |
| match(LITERAL_long); |
| if (inputState->guessing == 0) { |
| #line 978 "CPP_parser.g" |
| ts |= tsLONG; |
| #line 5523 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_signed: { |
| match(LITERAL_signed); |
| if (inputState->guessing == 0) { |
| #line 979 "CPP_parser.g" |
| ts |= tsSIGNED; |
| #line 5533 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_unsigned: { |
| match(LITERAL_unsigned); |
| if (inputState->guessing == 0) { |
| #line 980 "CPP_parser.g" |
| ts |= tsUNSIGNED; |
| #line 5543 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_float: { |
| match(LITERAL_float); |
| if (inputState->guessing == 0) { |
| #line 981 "CPP_parser.g" |
| ts |= tsFLOAT; |
| #line 5553 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_double: { |
| match(LITERAL_double); |
| if (inputState->guessing == 0) { |
| #line 982 "CPP_parser.g" |
| ts |= tsDOUBLE; |
| #line 5563 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_void: { |
| match(LITERAL_void); |
| if (inputState->guessing == 0) { |
| #line 983 "CPP_parser.g" |
| ts |= tsVOID; |
| #line 5573 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL__declspec: |
| case LITERAL___declspec: { |
| { |
| switch (LA(1)) { |
| case LITERAL__declspec: { |
| match(LITERAL__declspec); |
| break; |
| } |
| case LITERAL___declspec: { |
| match(LITERAL___declspec); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LPAREN); |
| match(ID); |
| match(RPAREN); |
| break; |
| } |
| default: { |
| if (_cnt192 >= 1) { |
| goto _loop192; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| _cnt192++; |
| } |
| _loop192:; |
| } // ( ... )+ |
| break; |
| } |
| default: |
| if (((LA(1) == ID || LA(1) == SCOPE)) && |
| (qualifiedItemIsOneOf(qiType | qiCtor))) { |
| s = qualified_type(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_24); |
| } else { |
| throw; |
| } |
| } |
| return ts; |
| } |
| |
| char* CPPParser::qualified_type() { |
| #line 994 "CPP_parser.g" |
| char* q = NULL; |
| #line 5638 "CPPParser.cpp" |
| ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 994 "CPP_parser.g" |
| char* s; |
| static char qitem[CPPParser_MaxQualifiedItemSize + 1]; |
| #line 5642 "CPPParser.cpp" |
| |
| try { // for error handling |
| s = scope_override(); |
| id = LT(1); |
| match(ID); |
| { |
| if ((LA(1) == LESSTHAN) && (_tokenSet_55.member(LA(2)))) { |
| match(LESSTHAN); |
| template_argument_list(); |
| match(GREATERTHAN); |
| } else if ((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1008 "CPP_parser.g" |
| |
| strcpy(qitem, s); |
| strcat(qitem, (id->getText()).data()); |
| q = qitem; |
| |
| #line 5668 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_56); |
| } else { |
| throw; |
| } |
| } |
| return q; |
| } |
| |
| void CPPParser::class_prefix() { |
| try { // for error handling |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == LITERAL__declspec || LA(1) == LITERAL___declspec)) { |
| { |
| switch (LA(1)) { |
| case LITERAL__declspec: { |
| match(LITERAL__declspec); |
| break; |
| } |
| case LITERAL___declspec: { |
| match(LITERAL___declspec); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| } else { |
| goto _loop204; |
| } |
| } |
| _loop204:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 1036 "CPP_parser.g" |
| |
| #line 5721 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_58); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::expression() { |
| try { // for error handling |
| assignment_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| assignment_expression(); |
| } else { |
| goto _loop444; |
| } |
| } |
| _loop444:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_59); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::base_specifier() { |
| #line 1089 "CPP_parser.g" |
| char* qt; |
| #line 5765 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_virtual: { |
| match(LITERAL_virtual); |
| { |
| switch (LA(1)) { |
| case LITERAL_public: |
| case LITERAL_protected: |
| case LITERAL_private: { |
| access_specifier(); |
| break; |
| } |
| case ID: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| qt = qualified_type(); |
| break; |
| } |
| case LITERAL_public: |
| case LITERAL_protected: |
| case LITERAL_private: { |
| access_specifier(); |
| { |
| switch (LA(1)) { |
| case LITERAL_virtual: { |
| match(LITERAL_virtual); |
| break; |
| } |
| case ID: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| qt = qualified_type(); |
| break; |
| } |
| case ID: |
| case SCOPE: { |
| qt = qualified_type(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_60); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::enumerator_list() { |
| try { // for error handling |
| enumerator(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| enumerator(); |
| } else { |
| goto _loop232; |
| } |
| } |
| _loop232:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_61); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::enumerator() { |
| ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| |
| try { // for error handling |
| id = LT(1); |
| match(ID); |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| constant_expression(); |
| break; |
| } |
| case RCURLY: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1132 "CPP_parser.g" |
| enumElement((id->getText()).data()); |
| #line 5901 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_62); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::constant_expression() { |
| try { // for error handling |
| conditional_expression(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_63); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::optor() { |
| try { // for error handling |
| switch (LA(1)) { |
| case LITERAL_new: { |
| match(LITERAL_new); |
| { |
| if ((LA(1) == LSQUARE) && (LA(2) == RSQUARE)) { |
| match(LSQUARE); |
| match(RSQUARE); |
| } else if ((_tokenSet_64.member(LA(1))) && |
| (_tokenSet_57.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| break; |
| } |
| case LITERAL_delete: { |
| match(LITERAL_delete); |
| { |
| if ((LA(1) == LSQUARE) && (LA(2) == RSQUARE)) { |
| match(LSQUARE); |
| match(RSQUARE); |
| } else if ((_tokenSet_64.member(LA(1))) && |
| (_tokenSet_57.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| match(RPAREN); |
| break; |
| } |
| case LSQUARE: { |
| match(LSQUARE); |
| match(RSQUARE); |
| break; |
| } |
| case LESSTHAN: |
| case GREATERTHAN: |
| case ASSIGNEQUAL: |
| case COMMA: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case TIMESEQUAL: |
| case DIVIDEEQUAL: |
| case MINUSEQUAL: |
| case PLUSEQUAL: |
| case MODEQUAL: |
| case SHIFTLEFTEQUAL: |
| case SHIFTRIGHTEQUAL: |
| case BITWISEANDEQUAL: |
| case BITWISEXOREQUAL: |
| case BITWISEOREQUAL: |
| case OR: |
| case AND: |
| case BITWISEOR: |
| case BITWISEXOR: |
| case NOTEQUAL: |
| case EQUAL: |
| case LESSTHANOREQUALTO: |
| case GREATERTHANOREQUALTO: |
| case SHIFTLEFT: |
| case SHIFTRIGHT: |
| case PLUS: |
| case MINUS: |
| case DIVIDE: |
| case MOD: |
| case POINTERTOMBR: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case POINTERTO: |
| case NOT: { |
| optor_simple_tokclass(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_64); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::typeID() { |
| try { // for error handling |
| if (!(isTypeName((LT(1)->getText()).data()))) { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| SemanticException("isTypeName((LT(1)->getText()).data())"); |
| } |
| match(ID); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_1); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::init_declarator() { |
| try { // for error handling |
| declarator(); |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| initializer(); |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| expression_list(); |
| match(RPAREN); |
| break; |
| } |
| case SEMICOLON: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_65); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::declarator() { |
| try { // for error handling |
| bool synPredMatched261 = false; |
| if (((_tokenSet_25.member(LA(1))) && (_tokenSet_66.member(LA(2))))) { |
| int _m261 = mark(); |
| synPredMatched261 = true; |
| inputState->guessing++; |
| try { |
| { ptr_operator(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched261 = false; |
| } |
| rewind(_m261); |
| inputState->guessing--; |
| } |
| if (synPredMatched261) { |
| ptr_operator(); |
| declarator(); |
| } else if ((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2)))) { |
| direct_declarator(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_69); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::initializer() { |
| try { // for error handling |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| remainder_expression(); |
| break; |
| } |
| case LCURLY: { |
| match(LCURLY); |
| initializer(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LCURLY: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| initializer(); |
| break; |
| } |
| case RCURLY: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else { |
| goto _loop248; |
| } |
| } |
| _loop248:; |
| } // ( ... )* |
| match(RCURLY); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_70); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::expression_list() { |
| try { // for error handling |
| assignment_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| assignment_expression(); |
| } else { |
| goto _loop592; |
| } |
| } |
| _loop592:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_71); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::remainder_expression() { |
| try { // for error handling |
| { |
| bool synPredMatched452 = false; |
| if (((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2))))) { |
| int _m452 = mark(); |
| synPredMatched452 = true; |
| inputState->guessing++; |
| try { |
| { |
| conditional_expression(); |
| { |
| switch (LA(1)) { |
| case COMMA: { |
| match(COMMA); |
| break; |
| } |
| case SEMICOLON: { |
| match(SEMICOLON); |
| break; |
| } |
| case RPAREN: { |
| match(RPAREN); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched452 = false; |
| } |
| rewind(_m452); |
| inputState->guessing--; |
| } |
| if (synPredMatched452) { |
| if (inputState->guessing == 0) { |
| #line 1879 "CPP_parser.g" |
| assign_stmt_RHS_found += 1; |
| #line 6400 "CPPParser.cpp" |
| } |
| assignment_expression(); |
| if (inputState->guessing == 0) { |
| #line 1881 "CPP_parser.g" |
| |
| if (assign_stmt_RHS_found > 0) { |
| assign_stmt_RHS_found -= 1; |
| } else { |
| fprintf(stderr, "%d warning Error in assign_stmt_RHS_found = %d\n", |
| LT(1)->getLine(), assign_stmt_RHS_found); |
| fprintf(stderr, "Press return to continue\n"); |
| getchar(); |
| } |
| |
| #line 6416 "CPPParser.cpp" |
| } |
| } else if ((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2)))) { |
| assignment_expression(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_74); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::member_declarator() { |
| try { // for error handling |
| bool synPredMatched257 = false; |
| if (((LA(1) == ID || LA(1) == COLON) && (_tokenSet_75.member(LA(2))))) { |
| int _m257 = mark(); |
| synPredMatched257 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case ID: { |
| match(ID); |
| break; |
| } |
| case COLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(COLON); |
| constant_expression(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched257 = false; |
| } |
| rewind(_m257); |
| inputState->guessing--; |
| } |
| if (synPredMatched257) { |
| { |
| switch (LA(1)) { |
| case ID: { |
| match(ID); |
| break; |
| } |
| case COLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(COLON); |
| constant_expression(); |
| } else if ((_tokenSet_76.member(LA(1))) && (_tokenSet_77.member(LA(2)))) { |
| declarator(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_78); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ptr_operator() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case AMPERSAND: { |
| match(AMPERSAND); |
| if (inputState->guessing == 0) { |
| #line 2198 "CPP_parser.g" |
| is_address = true; |
| #line 6525 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: { |
| { |
| switch (LA(1)) { |
| case LITERAL__cdecl: { |
| match(LITERAL__cdecl); |
| break; |
| } |
| case LITERAL___cdecl: { |
| match(LITERAL___cdecl); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL__near: |
| case LITERAL___near: { |
| { |
| switch (LA(1)) { |
| case LITERAL__near: { |
| match(LITERAL__near); |
| break; |
| } |
| case LITERAL___near: { |
| match(LITERAL___near); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL__far: |
| case LITERAL___far: { |
| { |
| switch (LA(1)) { |
| case LITERAL__far: { |
| match(LITERAL__far); |
| break; |
| } |
| case LITERAL___far: { |
| match(LITERAL___far); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL___interrupt: { |
| match(LITERAL___interrupt); |
| break; |
| } |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| { |
| switch (LA(1)) { |
| case LITERAL_pascal: { |
| match(LITERAL_pascal); |
| break; |
| } |
| case LITERAL__pascal: { |
| match(LITERAL__pascal); |
| break; |
| } |
| case LITERAL___pascal: { |
| match(LITERAL___pascal); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: { |
| { |
| switch (LA(1)) { |
| case LITERAL__stdcall: { |
| match(LITERAL__stdcall); |
| break; |
| } |
| case LITERAL___stdcall: { |
| match(LITERAL___stdcall); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case ID: |
| case STAR: |
| case SCOPE: { |
| ptr_to_member(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_24); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::direct_declarator() { |
| ANTLR_USE_NAMESPACE(antlr) |
| RefToken dtor = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 1225 "CPP_parser.g" |
| char* id; |
| CPPParser::TypeQualifier tq; |
| #line 6684 "CPPParser.cpp" |
| |
| try { // for error handling |
| switch (LA(1)) { |
| case TILDE: { |
| match(TILDE); |
| dtor = LT(1); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 1271 "CPP_parser.g" |
| declaratorID((dtor->getText()).data(), qiDtor); |
| #line 6696 "CPPParser.cpp" |
| } |
| if (inputState->guessing == 0) { |
| #line 1272 "CPP_parser.g" |
| fprintf( |
| stderr, |
| "%d warning direct_declarator5 entered unexpectedly with %s\n", |
| LT(1)->getLine(), (dtor->getText()).data()); |
| #line 6702 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| if (inputState->guessing == 0) { |
| #line 1274 "CPP_parser.g" |
| declaratorParameterList(0); |
| #line 6708 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1276 "CPP_parser.g" |
| declaratorEndParameterList(0); |
| #line 6812 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| declarator(); |
| match(RPAREN); |
| { |
| if ((LA(1) == LPAREN || LA(1) == LSQUARE) && |
| (_tokenSet_79.member(LA(2)))) { |
| declarator_suffix(); |
| } else if ((_tokenSet_69.member(LA(1))) && |
| (_tokenSet_80.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| break; |
| } |
| default: |
| bool synPredMatched265 = false; |
| if (((_tokenSet_44.member(LA(1))) && (_tokenSet_28.member(LA(2))))) { |
| int _m265 = mark(); |
| synPredMatched265 = true; |
| inputState->guessing++; |
| try { |
| { |
| qualified_id(); |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case RPAREN: { |
| match(RPAREN); |
| break; |
| } |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case SCOPE: { |
| declaration_specifiers(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched265 = false; |
| } |
| rewind(_m265); |
| inputState->guessing--; |
| } |
| if (synPredMatched265) { |
| id = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1231 "CPP_parser.g" |
| if (_td == true) { // This statement is a typedef |
| declaratorID(id, qiType); |
| } else { |
| declaratorID(id, qiFun); |
| } |
| |
| #line 6941 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| if (inputState->guessing == 0) { |
| #line 1236 "CPP_parser.g" |
| declaratorParameterList(0); |
| #line 6947 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1238 "CPP_parser.g" |
| declaratorEndParameterList(0); |
| #line 7051 "CPPParser.cpp" |
| } |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop268; |
| } |
| } |
| _loop268:; |
| } // ( ... )* |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case GREATERTHAN: |
| case SEMICOLON: |
| case ASSIGNEQUAL: |
| case LPAREN: |
| case RPAREN: |
| case COMMA: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else { |
| bool synPredMatched271 = false; |
| if (((_tokenSet_44.member(LA(1))) && (_tokenSet_28.member(LA(2))))) { |
| int _m271 = mark(); |
| synPredMatched271 = true; |
| inputState->guessing++; |
| try { |
| { |
| qualified_id(); |
| match(LPAREN); |
| qualified_id(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched271 = false; |
| } |
| rewind(_m271); |
| inputState->guessing--; |
| } |
| if (synPredMatched271) { |
| id = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1244 "CPP_parser.g" |
| declaratorID(id, qiVar); |
| #line 7113 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| expression_list(); |
| match(RPAREN); |
| } else { |
| bool synPredMatched273 = false; |
| if (((_tokenSet_44.member(LA(1))) && |
| (_tokenSet_28.member(LA(2))))) { |
| int _m273 = mark(); |
| synPredMatched273 = true; |
| inputState->guessing++; |
| try { |
| { |
| qualified_id(); |
| match(LSQUARE); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched273 = false; |
| } |
| rewind(_m273); |
| inputState->guessing--; |
| } |
| if (synPredMatched273) { |
| id = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1251 "CPP_parser.g" |
| if (_td == true) { // This statement is a typedef |
| declaratorID(id, qiType); // This statement is a typedef |
| } else { |
| declaratorID(id, qiVar); |
| } |
| is_address = false; |
| is_pointer = false; |
| |
| #line 7147 "CPPParser.cpp" |
| } |
| { // ( ... )+ |
| int _cnt276 = 0; |
| for (;;) { |
| if ((LA(1) == LSQUARE)) { |
| match(LSQUARE); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| constant_expression(); |
| break; |
| } |
| case RSQUARE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RSQUARE); |
| } else { |
| if (_cnt276 >= 1) { |
| goto _loop276; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt276++; |
| } |
| _loop276:; |
| } // ( ... )+ |
| if (inputState->guessing == 0) { |
| #line 1259 "CPP_parser.g" |
| declaratorArray(); |
| #line 7248 "CPPParser.cpp" |
| } |
| } else if ((_tokenSet_44.member(LA(1))) && |
| (_tokenSet_81.member(LA(2)))) { |
| id = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1262 "CPP_parser.g" |
| if (_td == true) { |
| declaratorID(id, qiType); // This statement is a typedef |
| } else { |
| declaratorID(id, qiVar); |
| } |
| is_address = false; |
| is_pointer = false; |
| |
| #line 7261 "CPPParser.cpp" |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_69); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::parameter_list() { |
| try { // for error handling |
| parameter_declaration_list(); |
| { |
| switch (LA(1)) { |
| case ELLIPSIS: { |
| match(ELLIPSIS); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_71); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::exception_specification() { |
| #line 1560 "CPP_parser.g" |
| char* so; |
| #line 7314 "CPPParser.cpp" |
| |
| try { // for error handling |
| match(LITERAL_throw); |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case RPAREN: |
| case SCOPE: { |
| { |
| switch (LA(1)) { |
| case ID: |
| case SCOPE: { |
| so = scope_override(); |
| match(ID); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| so = scope_override(); |
| match(ID); |
| } else { |
| goto _loop366; |
| } |
| } |
| _loop366:; |
| } // ( ... )* |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case ELLIPSIS: { |
| match(ELLIPSIS); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_82); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::declarator_suffix() { |
| #line 1284 "CPP_parser.g" |
| CPPParser::TypeQualifier tq; |
| #line 7386 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| if ((LA(1) == LSQUARE)) { |
| { // ( ... )+ |
| int _cnt283 = 0; |
| for (;;) { |
| if ((LA(1) == LSQUARE)) { |
| match(LSQUARE); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| constant_expression(); |
| break; |
| } |
| case RSQUARE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RSQUARE); |
| } else { |
| if (_cnt283 >= 1) { |
| goto _loop283; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt283++; |
| } |
| _loop283:; |
| } // ( ... )+ |
| if (inputState->guessing == 0) { |
| #line 1290 "CPP_parser.g" |
| declaratorArray(); |
| #line 7490 "CPPParser.cpp" |
| } |
| } else if (((LA(1) == LPAREN)) && |
| ((!((LA(1) == LPAREN) && (LA(2) == ID)) || |
| (qualifiedItemIsOneOf(qiType | qiCtor, 1))))) { |
| match(LPAREN); |
| if (inputState->guessing == 0) { |
| #line 1293 "CPP_parser.g" |
| declaratorParameterList(0); |
| #line 7498 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1295 "CPP_parser.g" |
| declaratorEndParameterList(0); |
| #line 7602 "CPPParser.cpp" |
| } |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop286; |
| } |
| } |
| _loop286:; |
| } // ( ... )* |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case GREATERTHAN: |
| case SEMICOLON: |
| case ASSIGNEQUAL: |
| case LPAREN: |
| case RPAREN: |
| case COMMA: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_69); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::template_parameter_list() { |
| try { // for error handling |
| if (inputState->guessing == 0) { |
| #line 1581 "CPP_parser.g" |
| beginTemplateParameterList(); |
| #line 7662 "CPPParser.cpp" |
| } |
| template_parameter(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| template_parameter(); |
| } else { |
| goto _loop370; |
| } |
| } |
| _loop370:; |
| } // ( ... )* |
| if (inputState->guessing == 0) { |
| #line 1583 "CPP_parser.g" |
| endTemplateParameterList(); |
| #line 7681 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_52); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::function_direct_declarator(int definition) { |
| #line 1324 "CPP_parser.g" |
| char* q; |
| CPPParser::TypeQualifier tq; |
| #line 7700 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LPAREN: { |
| match(LPAREN); |
| q = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1340 "CPP_parser.g" |
| |
| declaratorID(q, qiFun); |
| |
| #line 7714 "CPPParser.cpp" |
| } |
| match(RPAREN); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case SCOPE: { |
| q = qualified_id(); |
| if (inputState->guessing == 0) { |
| #line 1346 "CPP_parser.g" |
| |
| declaratorID(q, qiFun); |
| |
| #line 7732 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1351 "CPP_parser.g" |
| |
| #ifdef MYCODE |
| if (definition) myCode_function_direct_declarator(q); |
| #endif // MYCODE |
| |
| #line 7750 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| if (inputState->guessing == 0) { |
| #line 1359 "CPP_parser.g" |
| |
| functionParameterList(); |
| if (K_and_R == false) in_parameter_list = true; |
| |
| #line 7760 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1365 "CPP_parser.g" |
| |
| if (K_and_R == false) { |
| in_parameter_list = false; |
| } else { |
| in_parameter_list = true; |
| } |
| |
| #line 7868 "CPPParser.cpp" |
| } |
| match(RPAREN); |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__)) && |
| (_tokenSet_83.member(LA(2)))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop303; |
| } |
| } |
| _loop303:; |
| } // ( ... )* |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| match(OCTALINT); |
| break; |
| } |
| case LITERAL_typedef: |
| case SEMICOLON: |
| case LITERAL_enum: |
| case ID: |
| case LCURLY: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case LITERAL_throw: |
| case LITERAL_using: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| if (inputState->guessing == 0) { |
| #line 1375 "CPP_parser.g" |
| functionEndParameterList(definition); |
| #line 7970 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case LITERAL_typedef: |
| case SEMICOLON: |
| case LITERAL_enum: |
| case ID: |
| case LCURLY: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case LITERAL_using: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_29); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ctor_head() { |
| try { // for error handling |
| ctor_decl_spec(); |
| ctor_declarator(1); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_84); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ctor_body() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case COLON: { |
| ctor_initializer(); |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| compound_statement(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_30); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| char* CPPParser::qualified_ctor_id() { |
| #line 1414 "CPP_parser.g" |
| char* q = NULL; |
| #line 8116 "CPPParser.cpp" |
| ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| #line 1414 "CPP_parser.g" |
| |
| char* so; |
| static char qitem[CPPParser_MaxQualifiedItemSize + 1]; |
| |
| #line 8123 "CPPParser.cpp" |
| |
| try { // for error handling |
| so = scope_override(); |
| if (inputState->guessing == 0) { |
| #line 1421 "CPP_parser.g" |
| strcpy(qitem, so); |
| #line 8130 "CPPParser.cpp" |
| } |
| id = LT(1); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 1423 "CPP_parser.g" |
| strcat(qitem, (id->getText()).data()); |
| q = qitem; |
| #line 8138 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_85); |
| } else { |
| throw; |
| } |
| } |
| return q; |
| } |
| |
| void CPPParser::ctor_initializer() { |
| try { // for error handling |
| match(COLON); |
| superclass_init(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| superclass_init(); |
| } else { |
| goto _loop320; |
| } |
| } |
| _loop320:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_53); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::superclass_init() { |
| #line 1441 "CPP_parser.g" |
| char* q; |
| #line 8184 "CPPParser.cpp" |
| |
| try { // for error handling |
| q = qualified_id(); |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_60); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::dtor_decl_spec() { |
| try { // for error handling |
| { // ( ... )* |
| for (;;) { |
| switch (LA(1)) { |
| case LITERAL_inline: |
| case LITERAL__inline: |
| case LITERAL___inline: { |
| { |
| switch (LA(1)) { |
| case LITERAL_inline: { |
| match(LITERAL_inline); |
| break; |
| } |
| case LITERAL__inline: { |
| match(LITERAL__inline); |
| break; |
| } |
| case LITERAL___inline: { |
| match(LITERAL___inline); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL_virtual: { |
| match(LITERAL_virtual); |
| break; |
| } |
| default: { goto _loop327; } |
| } |
| } |
| _loop327:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_86); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::dtor_declarator(int definition) { |
| #line 1461 "CPP_parser.g" |
| char* s; |
| #line 8346 "CPPParser.cpp" |
| |
| try { // for error handling |
| s = scope_override(); |
| match(TILDE); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 1466 "CPP_parser.g" |
| declaratorParameterList(definition); |
| #line 8355 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case LITERAL_void: { |
| match(LITERAL_void); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1468 "CPP_parser.g" |
| declaratorEndParameterList(definition); |
| #line 8379 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case SEMICOLON: |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_32); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::parameter_declaration_list() { |
| try { // for error handling |
| { |
| parameter_declaration(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == COMMA)) { |
| match(COMMA); |
| parameter_declaration(); |
| } else { |
| goto _loop337; |
| } |
| } |
| _loop337:; |
| } // ( ... )* |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_87); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::parameter_declaration() { |
| try { // for error handling |
| if (inputState->guessing == 0) { |
| #line 1494 "CPP_parser.g" |
| beginParameterDeclaration(); |
| #line 8446 "CPPParser.cpp" |
| } |
| { |
| if (((_tokenSet_12.member(LA(1))) && (_tokenSet_88.member(LA(2)))) && |
| (!((LA(1) == SCOPE) && (LA(2) == STAR || LA(2) == OPERATOR)) && |
| (!(LA(1) == SCOPE || LA(1) == ID) || |
| qualifiedItemIsOneOf(qiType | qiCtor)))) { |
| declaration_specifiers(); |
| { |
| bool synPredMatched342 = false; |
| if (((_tokenSet_76.member(LA(1))) && (_tokenSet_89.member(LA(2))))) { |
| int _m342 = mark(); |
| synPredMatched342 = true; |
| inputState->guessing++; |
| try { |
| { declarator(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched342 = false; |
| } |
| rewind(_m342); |
| inputState->guessing--; |
| } |
| if (synPredMatched342) { |
| declarator(); |
| } else if ((_tokenSet_90.member(LA(1))) && |
| (_tokenSet_91.member(LA(2)))) { |
| abstract_declarator(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } else { |
| bool synPredMatched344 = false; |
| if (((_tokenSet_76.member(LA(1))) && (_tokenSet_89.member(LA(2))))) { |
| int _m344 = mark(); |
| synPredMatched344 = true; |
| inputState->guessing++; |
| try { |
| { declarator(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched344 = false; |
| } |
| rewind(_m344); |
| inputState->guessing--; |
| } |
| if (synPredMatched344) { |
| declarator(); |
| } else if ((LA(1) == ELLIPSIS)) { |
| match(ELLIPSIS); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| remainder_expression(); |
| break; |
| } |
| case GREATERTHAN: |
| case RPAREN: |
| case COMMA: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_92); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::abstract_declarator() { |
| try { // for error handling |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| abstract_declarator(); |
| } else { |
| bool synPredMatched351 = false; |
| if (((LA(1) == LPAREN) && (_tokenSet_25.member(LA(2))))) { |
| int _m351 = mark(); |
| synPredMatched351 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LPAREN); |
| { // ( ... )+ |
| int _cnt350 = 0; |
| for (;;) { |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| } else { |
| if (_cnt350 >= 1) { |
| goto _loop350; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt350++; |
| } |
| _loop350:; |
| } // ( ... )+ |
| match(RPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched351 = false; |
| } |
| rewind(_m351); |
| inputState->guessing--; |
| } |
| if (synPredMatched351) { |
| match(LPAREN); |
| { // ( ... )+ |
| int _cnt353 = 0; |
| for (;;) { |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| } else { |
| if (_cnt353 >= 1) { |
| goto _loop353; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt353++; |
| } |
| _loop353:; |
| } // ( ... )+ |
| match(RPAREN); |
| { |
| switch (LA(1)) { |
| case LPAREN: |
| case LSQUARE: { |
| abstract_declarator_suffix(); |
| break; |
| } |
| case GREATERTHAN: |
| case ASSIGNEQUAL: |
| case RPAREN: |
| case COMMA: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else if ((_tokenSet_93.member(LA(1))) && (_tokenSet_94.member(LA(2)))) { |
| { |
| switch (LA(1)) { |
| case LPAREN: |
| case LSQUARE: { |
| abstract_declarator_suffix(); |
| break; |
| } |
| case GREATERTHAN: |
| case ASSIGNEQUAL: |
| case RPAREN: |
| case COMMA: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_95); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::type_id() { |
| try { // for error handling |
| declaration_specifiers(); |
| abstract_declarator(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_96); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::abstract_declarator_suffix() { |
| try { // for error handling |
| switch (LA(1)) { |
| case LSQUARE: { |
| { // ( ... )+ |
| int _cnt359 = 0; |
| for (;;) { |
| if ((LA(1) == LSQUARE)) { |
| match(LSQUARE); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| constant_expression(); |
| break; |
| } |
| case RSQUARE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RSQUARE); |
| } else { |
| if (_cnt359 >= 1) { |
| goto _loop359; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt359++; |
| } |
| _loop359:; |
| } // ( ... )+ |
| if (inputState->guessing == 0) { |
| #line 1548 "CPP_parser.g" |
| declaratorArray(); |
| #line 8780 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| if (inputState->guessing == 0) { |
| #line 1551 "CPP_parser.g" |
| declaratorParameterList(0); |
| #line 8790 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LPAREN: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| parameter_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1554 "CPP_parser.g" |
| declaratorEndParameterList(0); |
| #line 8894 "CPPParser.cpp" |
| } |
| cv_qualifier_seq(); |
| { |
| switch (LA(1)) { |
| case LITERAL_throw: { |
| exception_specification(); |
| break; |
| } |
| case GREATERTHAN: |
| case ASSIGNEQUAL: |
| case RPAREN: |
| case COMMA: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_95); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::cv_qualifier_seq() { |
| #line 2218 "CPP_parser.g" |
| CPPParser::TypeQualifier tq; |
| #line 8939 "CPPParser.cpp" |
| |
| try { // for error handling |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop581; |
| } |
| } |
| _loop581:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_97); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::template_parameter() { |
| try { // for error handling |
| { |
| if ((_tokenSet_98.member(LA(1))) && (_tokenSet_99.member(LA(2)))) { |
| type_parameter(); |
| } else if ((_tokenSet_100.member(LA(1))) && |
| (_tokenSet_15.member(LA(2)))) { |
| parameter_declaration(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_101); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::type_parameter() { |
| ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| ANTLR_USE_NAMESPACE(antlr) |
| RefToken id2 = ANTLR_USE_NAMESPACE(antlr) nullToken; |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_class: |
| case LITERAL_typename: { |
| { |
| switch (LA(1)) { |
| case LITERAL_class: { |
| match(LITERAL_class); |
| break; |
| } |
| case LITERAL_typename: { |
| match(LITERAL_typename); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case ID: { |
| id = LT(1); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 1610 "CPP_parser.g" |
| |
| templateTypeParameter((id->getText()).data()); |
| |
| #line 9030 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| assigned_type_name(); |
| break; |
| } |
| case GREATERTHAN: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case GREATERTHAN: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case LITERAL_template: { |
| template_head(); |
| match(LITERAL_class); |
| { |
| switch (LA(1)) { |
| case ID: { |
| id2 = LT(1); |
| match(ID); |
| if (inputState->guessing == 0) { |
| #line 1618 "CPP_parser.g" |
| |
| templateTypeParameter((id2->getText()).data()); |
| |
| #line 9081 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| assigned_type_name(); |
| break; |
| } |
| case GREATERTHAN: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| case GREATERTHAN: |
| case COMMA: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_101); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::assigned_type_name() { |
| #line 1631 "CPP_parser.g" |
| char* qt; |
| TypeSpecifier ts; |
| #line 9137 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| if ((LA(1) == ID || LA(1) == SCOPE) && (_tokenSet_102.member(LA(2)))) { |
| qt = qualified_type(); |
| abstract_declarator(); |
| } else if ((_tokenSet_103.member(LA(1))) && |
| (_tokenSet_104.member(LA(2)))) { |
| ts = simple_type_specifier(); |
| abstract_declarator(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_101); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::template_id() { |
| try { // for error handling |
| match(ID); |
| match(LESSTHAN); |
| template_argument_list(); |
| match(GREATERTHAN); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_1); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::template_argument() { |
| try { // for error handling |
| if (((_tokenSet_12.member(LA(1))) && (_tokenSet_105.member(LA(2)))) && |
| ((!(LA(1) == SCOPE || LA(1) == ID) || |
| qualifiedItemIsOneOf(qiType | qiCtor)))) { |
| type_id(); |
| } else if ((_tokenSet_72.member(LA(1))) && (_tokenSet_106.member(LA(2)))) { |
| shift_expression(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_101); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::shift_expression() { |
| try { // for error handling |
| additive_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == SHIFTLEFT || LA(1) == SHIFTRIGHT)) { |
| { |
| switch (LA(1)) { |
| case SHIFTLEFT: { |
| match(SHIFTLEFT); |
| break; |
| } |
| case SHIFTRIGHT: { |
| match(SHIFTRIGHT); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| additive_expression(); |
| } else { |
| goto _loop482; |
| } |
| } |
| _loop482:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_107); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::statement_list() { |
| try { // for error handling |
| { // ( ... )+ |
| int _cnt389 = 0; |
| for (;;) { |
| if ((_tokenSet_49.member(LA(1)))) { |
| statement(); |
| } else { |
| if (_cnt389 >= 1) { |
| goto _loop389; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt389++; |
| } |
| _loop389:; |
| } // ( ... )+ |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_61); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::statement() { |
| #line 1680 "CPP_parser.g" |
| |
| FunctionSpecifier fs = fsInvalid; // inline,virtual,explicit |
| |
| #line 9285 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_case: { |
| case_statement(); |
| break; |
| } |
| case LITERAL_default: { |
| default_statement(); |
| break; |
| } |
| case LCURLY: { |
| compound_statement(); |
| break; |
| } |
| case LITERAL_if: |
| case LITERAL_switch: { |
| selection_statement(); |
| break; |
| } |
| case LITERAL_while: |
| case LITERAL_do: |
| case LITERAL_for: { |
| iteration_statement(); |
| break; |
| } |
| case LITERAL_goto: |
| case LITERAL_continue: |
| case LITERAL_break: |
| case LITERAL_return: { |
| jump_statement(); |
| break; |
| } |
| case LITERAL_try: { |
| try_block(); |
| break; |
| } |
| case LITERAL_throw: { |
| throw_statement(); |
| break; |
| } |
| default: |
| bool synPredMatched393 = false; |
| if (((_tokenSet_108.member(LA(1))) && |
| (_tokenSet_109.member(LA(2))))) { |
| int _m393 = mark(); |
| synPredMatched393 = true; |
| inputState->guessing++; |
| try { |
| { |
| switch (LA(1)) { |
| case LITERAL_namespace: { |
| match(LITERAL_namespace); |
| break; |
| } |
| case LITERAL_using: { |
| match(LITERAL_using); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched393 = false; |
| } |
| rewind(_m393); |
| inputState->guessing--; |
| } |
| if (synPredMatched393) { |
| block_declaration(); |
| } else { |
| bool synPredMatched397 = false; |
| if (((_tokenSet_20.member(LA(1))) && |
| (_tokenSet_110.member(LA(2))))) { |
| int _m397 = mark(); |
| synPredMatched397 = true; |
| inputState->guessing++; |
| try { |
| { |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: { |
| match(LITERAL_typedef); |
| break; |
| } |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| class_specifier(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case SCOPE: { |
| qualified_id(); |
| break; |
| } |
| case LCURLY: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LCURLY); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched397 = false; |
| } |
| rewind(_m397); |
| inputState->guessing--; |
| } |
| if (synPredMatched397) { |
| member_declaration(); |
| } else { |
| bool synPredMatched399 = false; |
| if (((_tokenSet_20.member(LA(1))) && |
| (_tokenSet_110.member(LA(2))))) { |
| int _m399 = mark(); |
| synPredMatched399 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| match(LPAREN); |
| ptr_operator(); |
| qualified_id(); |
| match(RPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched399 = false; |
| } |
| rewind(_m399); |
| inputState->guessing--; |
| } |
| if (synPredMatched399) { |
| member_declaration(); |
| } else { |
| bool synPredMatched402 = false; |
| if (((_tokenSet_20.member(LA(1))) && |
| (_tokenSet_110.member(LA(2))))) { |
| int _m402 = mark(); |
| synPredMatched402 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| { |
| ptr_operator(); |
| ptr_operator(); |
| } |
| qualified_id(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched402 = false; |
| } |
| rewind(_m402); |
| inputState->guessing--; |
| } |
| if (synPredMatched402) { |
| member_declaration(); |
| } else { |
| bool synPredMatched407 = false; |
| if (((_tokenSet_20.member(LA(1))) && |
| (_tokenSet_110.member(LA(2))))) { |
| int _m407 = mark(); |
| synPredMatched407 = true; |
| inputState->guessing++; |
| try { |
| { |
| declaration_specifiers(); |
| { |
| bool synPredMatched406 = false; |
| if (((_tokenSet_25.member(LA(1))) && |
| (_tokenSet_111.member(LA(2))))) { |
| int _m406 = mark(); |
| synPredMatched406 = true; |
| inputState->guessing++; |
| try { |
| { ptr_operator(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched406 = false; |
| } |
| rewind(_m406); |
| inputState->guessing--; |
| } |
| if (synPredMatched406) { |
| ptr_operator(); |
| } else if ((_tokenSet_44.member(LA(1))) && (true)) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| qualified_id(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) |
| RecognitionException& pe) { |
| synPredMatched407 = false; |
| } |
| rewind(_m407); |
| inputState->guessing--; |
| } |
| if (synPredMatched407) { |
| member_declaration(); |
| } else if ((LA(1) == ID) && (LA(2) == COLON)) { |
| labeled_statement(); |
| } else if ((_tokenSet_72.member(LA(1))) && |
| (_tokenSet_112.member(LA(2)))) { |
| expression(); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1698 "CPP_parser.g" |
| end_of_stmt(); |
| #line 9539 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == SEMICOLON) && |
| (_tokenSet_40.member(LA(2)))) { |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1703 "CPP_parser.g" |
| end_of_stmt(); |
| #line 9547 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LITERAL_antlrTrace_on) && |
| (_tokenSet_40.member(LA(2)))) { |
| match(LITERAL_antlrTrace_on); |
| if (inputState->guessing == 0) { |
| #line 1708 "CPP_parser.g" |
| antlrTrace(true); |
| #line 9555 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == LITERAL_antlrTrace_off) && |
| (_tokenSet_40.member(LA(2)))) { |
| match(LITERAL_antlrTrace_off); |
| if (inputState->guessing == 0) { |
| #line 1710 "CPP_parser.g" |
| antlrTrace(false); |
| #line 9563 "CPPParser.cpp" |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::block_declaration() { |
| try { // for error handling |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case SCOPE: { |
| simple_declaration(); |
| break; |
| } |
| case LITERAL_asm: |
| case LITERAL__asm: |
| case LITERAL___asm: |
| case LITERAL___asm__: { |
| asm_definition(); |
| break; |
| } |
| case LITERAL_namespace: { |
| namespace_alias_definition(); |
| break; |
| } |
| case LITERAL_using: { |
| using_statement(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::labeled_statement() { |
| try { // for error handling |
| match(ID); |
| match(COLON); |
| statement(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::case_statement() { |
| try { // for error handling |
| match(LITERAL_case); |
| constant_expression(); |
| match(COLON); |
| statement(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::default_statement() { |
| try { // for error handling |
| match(LITERAL_default); |
| match(COLON); |
| statement(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::selection_statement() { |
| try { // for error handling |
| switch (LA(1)) { |
| case LITERAL_if: { |
| match(LITERAL_if); |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| statement(); |
| { |
| if ((LA(1) == LITERAL_else) && (_tokenSet_49.member(LA(2)))) { |
| match(LITERAL_else); |
| statement(); |
| } else if ((_tokenSet_40.member(LA(1))) && |
| (_tokenSet_113.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| break; |
| } |
| case LITERAL_switch: { |
| match(LITERAL_switch); |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| statement(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::iteration_statement() { |
| try { // for error handling |
| switch (LA(1)) { |
| case LITERAL_while: { |
| match(LITERAL_while); |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| statement(); |
| break; |
| } |
| case LITERAL_do: { |
| match(LITERAL_do); |
| statement(); |
| match(LITERAL_while); |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1777 "CPP_parser.g" |
| end_of_stmt(); |
| #line 9814 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_for: { |
| match(LITERAL_for); |
| match(LPAREN); |
| { |
| bool synPredMatched421 = false; |
| if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) { |
| int _m421 = mark(); |
| synPredMatched421 = true; |
| inputState->guessing++; |
| try { |
| { declaration(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched421 = false; |
| } |
| rewind(_m421); |
| inputState->guessing--; |
| } |
| if (synPredMatched421) { |
| declaration(); |
| } else if ((_tokenSet_72.member(LA(1))) && |
| (_tokenSet_112.member(LA(2)))) { |
| expression(); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1781 "CPP_parser.g" |
| end_of_stmt(); |
| #line 9848 "CPPParser.cpp" |
| } |
| } else if ((LA(1) == SEMICOLON)) { |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1782 "CPP_parser.g" |
| end_of_stmt(); |
| #line 9856 "CPPParser.cpp" |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1784 "CPP_parser.g" |
| end_of_stmt(); |
| #line 9949 "CPPParser.cpp" |
| } |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| statement(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::jump_statement() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_goto: { |
| match(LITERAL_goto); |
| match(ID); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1791 "CPP_parser.g" |
| end_of_stmt(); |
| #line 10065 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_continue: { |
| match(LITERAL_continue); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1792 "CPP_parser.g" |
| end_of_stmt(); |
| #line 10076 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_break: { |
| match(LITERAL_break); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1793 "CPP_parser.g" |
| end_of_stmt(); |
| #line 10087 "CPPParser.cpp" |
| } |
| break; |
| } |
| case LITERAL_return: { |
| match(LITERAL_return); |
| if (inputState->guessing == 0) { |
| #line 1795 "CPP_parser.g" |
| in_return = true; |
| #line 10097 "CPPParser.cpp" |
| } |
| { |
| bool synPredMatched428 = false; |
| if (((LA(1) == LPAREN) && (LA(2) == ID))) { |
| int _m428 = mark(); |
| synPredMatched428 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LPAREN); |
| if (!((qualifiedItemIsOneOf(qiType)))) { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| SemanticException("(qualifiedItemIsOneOf(qiType) )"); |
| } |
| match(ID); |
| match(RPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched428 = false; |
| } |
| rewind(_m428); |
| inputState->guessing--; |
| } |
| if (synPredMatched428) { |
| match(LPAREN); |
| match(ID); |
| match(RPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else if ((_tokenSet_72.member(LA(1))) && |
| (_tokenSet_112.member(LA(2)))) { |
| expression(); |
| } else if ((LA(1) == SEMICOLON)) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1802 "CPP_parser.g" |
| in_return = false, end_of_stmt(); |
| #line 10220 "CPPParser.cpp" |
| } |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::try_block() { |
| try { // for error handling |
| match(LITERAL_try); |
| compound_statement(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == LITERAL_catch)) { |
| handler(); |
| } else { |
| goto _loop432; |
| } |
| } |
| _loop432:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::throw_statement() { |
| try { // for error handling |
| match(LITERAL_throw); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| assignment_expression(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1833 "CPP_parser.g" |
| end_of_stmt(); |
| #line 10358 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::simple_declaration() { |
| try { // for error handling |
| declaration_specifiers(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LPAREN: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| init_declarator_list(); |
| break; |
| } |
| case SEMICOLON: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1725 "CPP_parser.g" |
| end_of_stmt(); |
| #line 10417 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::asm_definition() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_asm: { |
| match(LITERAL_asm); |
| break; |
| } |
| case LITERAL__asm: { |
| match(LITERAL__asm); |
| break; |
| } |
| case LITERAL___asm: { |
| match(LITERAL___asm); |
| break; |
| } |
| case LITERAL___asm__: { |
| match(LITERAL___asm__); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LPAREN); |
| match(StringLiteral); |
| match(RPAREN); |
| match(SEMICOLON); |
| if (inputState->guessing == 0) { |
| #line 1848 "CPP_parser.g" |
| end_of_stmt(); |
| #line 10468 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_40); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::handler() { |
| try { // for error handling |
| match(LITERAL_catch); |
| if (inputState->guessing == 0) { |
| #line 1814 "CPP_parser.g" |
| exceptionBeginHandler(); |
| #line 10488 "CPPParser.cpp" |
| } |
| if (inputState->guessing == 0) { |
| #line 1815 "CPP_parser.g" |
| declaratorParameterList(1); |
| #line 10493 "CPPParser.cpp" |
| } |
| match(LPAREN); |
| exception_declaration(); |
| match(RPAREN); |
| if (inputState->guessing == 0) { |
| #line 1817 "CPP_parser.g" |
| declaratorEndParameterList(1); |
| #line 10501 "CPPParser.cpp" |
| } |
| compound_statement(); |
| if (inputState->guessing == 0) { |
| #line 1819 "CPP_parser.g" |
| exceptionEndHandler(); |
| #line 10507 "CPPParser.cpp" |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_114); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::exception_declaration() { |
| try { // for error handling |
| parameter_declaration_list(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_71); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::assignment_expression() { |
| try { // for error handling |
| conditional_expression(); |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: |
| case TIMESEQUAL: |
| case DIVIDEEQUAL: |
| case MINUSEQUAL: |
| case PLUSEQUAL: |
| case MODEQUAL: |
| case SHIFTLEFTEQUAL: |
| case SHIFTRIGHTEQUAL: |
| case BITWISEANDEQUAL: |
| case BITWISEXOREQUAL: |
| case BITWISEOREQUAL: { |
| { |
| switch (LA(1)) { |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| break; |
| } |
| case TIMESEQUAL: { |
| match(TIMESEQUAL); |
| break; |
| } |
| case DIVIDEEQUAL: { |
| match(DIVIDEEQUAL); |
| break; |
| } |
| case MINUSEQUAL: { |
| match(MINUSEQUAL); |
| break; |
| } |
| case PLUSEQUAL: { |
| match(PLUSEQUAL); |
| break; |
| } |
| case MODEQUAL: { |
| match(MODEQUAL); |
| break; |
| } |
| case SHIFTLEFTEQUAL: { |
| match(SHIFTLEFTEQUAL); |
| break; |
| } |
| case SHIFTRIGHTEQUAL: { |
| match(SHIFTRIGHTEQUAL); |
| break; |
| } |
| case BITWISEANDEQUAL: { |
| match(BITWISEANDEQUAL); |
| break; |
| } |
| case BITWISEXOREQUAL: { |
| match(BITWISEXOREQUAL); |
| break; |
| } |
| case BITWISEOREQUAL: { |
| match(BITWISEOREQUAL); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| remainder_expression(); |
| break; |
| } |
| case GREATERTHAN: |
| case SEMICOLON: |
| case RCURLY: |
| case COLON: |
| case RPAREN: |
| case COMMA: |
| case RSQUARE: |
| case ELLIPSIS: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_74); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::conditional_expression() { |
| try { // for error handling |
| logical_or_expression(); |
| { |
| switch (LA(1)) { |
| case QUESTIONMARK: { |
| match(QUESTIONMARK); |
| expression(); |
| match(COLON); |
| conditional_expression(); |
| break; |
| } |
| case GREATERTHAN: |
| case SEMICOLON: |
| case RCURLY: |
| case ASSIGNEQUAL: |
| case COLON: |
| case RPAREN: |
| case COMMA: |
| case RSQUARE: |
| case ELLIPSIS: |
| case TIMESEQUAL: |
| case DIVIDEEQUAL: |
| case MINUSEQUAL: |
| case PLUSEQUAL: |
| case MODEQUAL: |
| case SHIFTLEFTEQUAL: |
| case SHIFTRIGHTEQUAL: |
| case BITWISEANDEQUAL: |
| case BITWISEXOREQUAL: |
| case BITWISEOREQUAL: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_115); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::logical_or_expression() { |
| try { // for error handling |
| logical_and_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == OR)) { |
| match(OR); |
| logical_and_expression(); |
| } else { |
| goto _loop458; |
| } |
| } |
| _loop458:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_116); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::logical_and_expression() { |
| try { // for error handling |
| inclusive_or_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == AND)) { |
| match(AND); |
| inclusive_or_expression(); |
| } else { |
| goto _loop461; |
| } |
| } |
| _loop461:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_117); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::inclusive_or_expression() { |
| try { // for error handling |
| exclusive_or_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == BITWISEOR)) { |
| match(BITWISEOR); |
| exclusive_or_expression(); |
| } else { |
| goto _loop464; |
| } |
| } |
| _loop464:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_118); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::exclusive_or_expression() { |
| try { // for error handling |
| and_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == BITWISEXOR)) { |
| match(BITWISEXOR); |
| and_expression(); |
| } else { |
| goto _loop467; |
| } |
| } |
| _loop467:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_119); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::and_expression() { |
| try { // for error handling |
| equality_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == AMPERSAND)) { |
| match(AMPERSAND); |
| equality_expression(); |
| } else { |
| goto _loop470; |
| } |
| } |
| _loop470:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_120); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::equality_expression() { |
| try { // for error handling |
| relational_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == NOTEQUAL || LA(1) == EQUAL)) { |
| { |
| switch (LA(1)) { |
| case NOTEQUAL: { |
| match(NOTEQUAL); |
| break; |
| } |
| case EQUAL: { |
| match(EQUAL); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| relational_expression(); |
| } else { |
| goto _loop474; |
| } |
| } |
| _loop474:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_121); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::relational_expression() { |
| try { // for error handling |
| shift_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_122.member(LA(1))) && (_tokenSet_72.member(LA(2)))) { |
| { |
| switch (LA(1)) { |
| case LESSTHAN: { |
| match(LESSTHAN); |
| break; |
| } |
| case GREATERTHAN: { |
| match(GREATERTHAN); |
| break; |
| } |
| case LESSTHANOREQUALTO: { |
| match(LESSTHANOREQUALTO); |
| break; |
| } |
| case GREATERTHANOREQUALTO: { |
| match(GREATERTHANOREQUALTO); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| shift_expression(); |
| } else { |
| goto _loop478; |
| } |
| } |
| _loop478:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_123); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::additive_expression() { |
| try { // for error handling |
| multiplicative_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == PLUS || LA(1) == MINUS)) { |
| { |
| switch (LA(1)) { |
| case PLUS: { |
| match(PLUS); |
| break; |
| } |
| case MINUS: { |
| match(MINUS); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| multiplicative_expression(); |
| } else { |
| goto _loop486; |
| } |
| } |
| _loop486:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_124); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::multiplicative_expression() { |
| try { // for error handling |
| pm_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_125.member(LA(1)))) { |
| { |
| switch (LA(1)) { |
| case STAR: { |
| match(STAR); |
| break; |
| } |
| case DIVIDE: { |
| match(DIVIDE); |
| break; |
| } |
| case MOD: { |
| match(MOD); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| pm_expression(); |
| } else { |
| goto _loop490; |
| } |
| } |
| _loop490:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_126); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::pm_expression() { |
| try { // for error handling |
| cast_expression(); |
| { // ( ... )* |
| for (;;) { |
| if ((LA(1) == DOTMBR || LA(1) == POINTERTOMBR)) { |
| { |
| switch (LA(1)) { |
| case DOTMBR: { |
| match(DOTMBR); |
| break; |
| } |
| case POINTERTOMBR: { |
| match(POINTERTOMBR); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| cast_expression(); |
| } else { |
| goto _loop494; |
| } |
| } |
| _loop494:; |
| } // ( ... )* |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_127); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::cast_expression() { |
| #line 2021 "CPP_parser.g" |
| TypeQualifier tq; |
| TypeSpecifier ts; |
| #line 11084 "CPPParser.cpp" |
| |
| try { // for error handling |
| bool synPredMatched501 = false; |
| if (((LA(1) == LPAREN) && (_tokenSet_128.member(LA(2))))) { |
| int _m501 = mark(); |
| synPredMatched501 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LPAREN); |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| type_qualifier(); |
| } else { |
| goto _loop498; |
| } |
| } |
| _loop498:; |
| } // ( ... )* |
| simple_type_specifier(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| } else { |
| goto _loop500; |
| } |
| } |
| _loop500:; |
| } // ( ... )* |
| match(RPAREN); |
| unary_expression(); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched501 = false; |
| } |
| rewind(_m501); |
| inputState->guessing--; |
| } |
| if (synPredMatched501) { |
| match(LPAREN); |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop503; |
| } |
| } |
| _loop503:; |
| } // ( ... )* |
| ts = simple_type_specifier(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| } else { |
| goto _loop505; |
| } |
| } |
| _loop505:; |
| } // ( ... )* |
| match(RPAREN); |
| unary_expression(); |
| } else { |
| bool synPredMatched511 = false; |
| if (((LA(1) == LPAREN) && (_tokenSet_128.member(LA(2))))) { |
| int _m511 = mark(); |
| synPredMatched511 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LPAREN); |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && |
| LA(1) <= LITERAL___volatile__))) { |
| type_qualifier(); |
| } else { |
| goto _loop508; |
| } |
| } |
| _loop508:; |
| } // ( ... )* |
| simple_type_specifier(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| } else { |
| goto _loop510; |
| } |
| } |
| _loop510:; |
| } // ( ... )* |
| match(RPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched511 = false; |
| } |
| rewind(_m511); |
| inputState->guessing--; |
| } |
| if (synPredMatched511) { |
| match(LPAREN); |
| { // ( ... )* |
| for (;;) { |
| if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) { |
| tq = type_qualifier(); |
| } else { |
| goto _loop513; |
| } |
| } |
| _loop513:; |
| } // ( ... )* |
| ts = simple_type_specifier(); |
| { // ( ... )* |
| for (;;) { |
| if ((_tokenSet_25.member(LA(1)))) { |
| ptr_operator(); |
| } else { |
| goto _loop515; |
| } |
| } |
| _loop515:; |
| } // ( ... )* |
| match(RPAREN); |
| cast_expression(); |
| } else if ((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2)))) { |
| unary_expression(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_129); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::unary_expression() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case PLUSPLUS: { |
| match(PLUSPLUS); |
| unary_expression(); |
| break; |
| } |
| case MINUSMINUS: { |
| match(MINUSMINUS); |
| unary_expression(); |
| break; |
| } |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: { |
| { |
| switch (LA(1)) { |
| case LITERAL_sizeof: { |
| match(LITERAL_sizeof); |
| break; |
| } |
| case LITERAL___alignof__: { |
| match(LITERAL___alignof__); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| bool synPredMatched523 = false; |
| if (((_tokenSet_72.member(LA(1))) && |
| (_tokenSet_73.member(LA(2))))) { |
| int _m523 = mark(); |
| synPredMatched523 = true; |
| inputState->guessing++; |
| try { |
| { unary_expression(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched523 = false; |
| } |
| rewind(_m523); |
| inputState->guessing--; |
| } |
| if (synPredMatched523) { |
| unary_expression(); |
| } else if ((LA(1) == LPAREN) && (_tokenSet_12.member(LA(2)))) { |
| match(LPAREN); |
| type_id(); |
| match(RPAREN); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| break; |
| } |
| default: |
| bool synPredMatched519 = false; |
| if (((_tokenSet_130.member(LA(1))) && |
| (_tokenSet_131.member(LA(2))))) { |
| int _m519 = mark(); |
| synPredMatched519 = true; |
| inputState->guessing++; |
| try { |
| { postfix_expression(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched519 = false; |
| } |
| rewind(_m519); |
| inputState->guessing--; |
| } |
| if (synPredMatched519) { |
| postfix_expression(); |
| } else if ((_tokenSet_132.member(LA(1))) && |
| (_tokenSet_72.member(LA(2)))) { |
| unary_operator(); |
| cast_expression(); |
| } else if ((_tokenSet_133.member(LA(1))) && |
| (_tokenSet_134.member(LA(2)))) { |
| { |
| switch (LA(1)) { |
| case SCOPE: { |
| match(SCOPE); |
| break; |
| } |
| case LITERAL_new: |
| case LITERAL_delete: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_new: { |
| new_expression(); |
| break; |
| } |
| case LITERAL_delete: { |
| delete_expression(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_129); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::postfix_expression() { |
| #line 2063 "CPP_parser.g" |
| |
| TypeSpecifier ts; |
| |
| #line 11404 "CPPParser.cpp" |
| |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: { |
| { |
| switch (LA(1)) { |
| case LITERAL_dynamic_cast: { |
| match(LITERAL_dynamic_cast); |
| break; |
| } |
| case LITERAL_static_cast: { |
| match(LITERAL_static_cast); |
| break; |
| } |
| case LITERAL_reinterpret_cast: { |
| match(LITERAL_reinterpret_cast); |
| break; |
| } |
| case LITERAL_const_cast: { |
| match(LITERAL_const_cast); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(LESSTHAN); |
| { |
| switch (LA(1)) { |
| case LITERAL_const: { |
| match(LITERAL_const); |
| break; |
| } |
| case LITERAL___const: { |
| match(LITERAL___const); |
| break; |
| } |
| case ID: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| ts = type_specifier(); |
| { |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| ptr_operator(); |
| break; |
| } |
| case GREATERTHAN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(GREATERTHAN); |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| break; |
| } |
| case LITERAL_typeid: { |
| match(LITERAL_typeid); |
| match(LPAREN); |
| { |
| bool synPredMatched544 = false; |
| if (((_tokenSet_12.member(LA(1))) && |
| (_tokenSet_135.member(LA(2))))) { |
| int _m544 = mark(); |
| synPredMatched544 = true; |
| inputState->guessing++; |
| try { |
| { type_id(); } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched544 = false; |
| } |
| rewind(_m544); |
| inputState->guessing--; |
| } |
| if (synPredMatched544) { |
| type_id(); |
| } else if ((_tokenSet_72.member(LA(1))) && |
| (_tokenSet_136.member(LA(2)))) { |
| expression(); |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| match(RPAREN); |
| break; |
| } |
| default: |
| bool synPredMatched529 = false; |
| if ((((_tokenSet_103.member(LA(1))) && |
| (_tokenSet_137.member(LA(2)))) && |
| (!(LA(1) == LPAREN)))) { |
| int _m529 = mark(); |
| synPredMatched529 = true; |
| inputState->guessing++; |
| try { |
| { |
| ts = simple_type_specifier(); |
| match(LPAREN); |
| match(RPAREN); |
| match(LPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched529 = false; |
| } |
| rewind(_m529); |
| inputState->guessing--; |
| } |
| if (synPredMatched529) { |
| ts = simple_type_specifier(); |
| match(LPAREN); |
| match(RPAREN); |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| } else { |
| bool synPredMatched532 = false; |
| if ((((_tokenSet_103.member(LA(1))) && |
| (_tokenSet_137.member(LA(2)))) && |
| (!(LA(1) == LPAREN)))) { |
| int _m532 = mark(); |
| synPredMatched532 = true; |
| inputState->guessing++; |
| try { |
| { |
| ts = simple_type_specifier(); |
| match(LPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched532 = false; |
| } |
| rewind(_m532); |
| inputState->guessing--; |
| } |
| if (synPredMatched532) { |
| ts = simple_type_specifier(); |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| } else if ((_tokenSet_138.member(LA(1))) && |
| (_tokenSet_131.member(LA(2)))) { |
| primary_expression(); |
| { // ( ... )* |
| for (;;) { |
| switch (LA(1)) { |
| case LSQUARE: { |
| match(LSQUARE); |
| expression(); |
| match(RSQUARE); |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| break; |
| } |
| case DOT: |
| case POINTERTO: { |
| { |
| switch (LA(1)) { |
| case DOT: { |
| match(DOT); |
| break; |
| } |
| case POINTERTO: { |
| match(POINTERTO); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_template: { |
| match(LITERAL_template); |
| break; |
| } |
| case ID: |
| case OPERATOR: |
| case TILDE: |
| case SCOPE: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| id_expression(); |
| break; |
| } |
| case PLUSPLUS: { |
| match(PLUSPLUS); |
| break; |
| } |
| case MINUSMINUS: { |
| match(MINUSMINUS); |
| break; |
| } |
| default: { goto _loop538; } |
| } |
| } |
| _loop538:; |
| } // ( ... )* |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_129); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::unary_operator() { |
| try { // for error handling |
| switch (LA(1)) { |
| case AMPERSAND: { |
| match(AMPERSAND); |
| break; |
| } |
| case STAR: { |
| match(STAR); |
| break; |
| } |
| case PLUS: { |
| match(PLUS); |
| break; |
| } |
| case MINUS: { |
| match(MINUS); |
| break; |
| } |
| case TILDE: { |
| match(TILDE); |
| break; |
| } |
| case NOT: { |
| match(NOT); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_72); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::new_expression() { |
| try { // for error handling |
| { |
| match(LITERAL_new); |
| { |
| bool synPredMatched557 = false; |
| if (((LA(1) == LPAREN) && (_tokenSet_72.member(LA(2))))) { |
| int _m557 = mark(); |
| synPredMatched557 = true; |
| inputState->guessing++; |
| try { |
| { |
| match(LPAREN); |
| expression_list(); |
| match(RPAREN); |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { |
| synPredMatched557 = false; |
| } |
| rewind(_m557); |
| inputState->guessing--; |
| } |
| if (synPredMatched557) { |
| match(LPAREN); |
| expression_list(); |
| match(RPAREN); |
| } else if ((_tokenSet_139.member(LA(1))) && |
| (_tokenSet_140.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| { |
| switch (LA(1)) { |
| case LITERAL_typedef: |
| case LITERAL_enum: |
| case ID: |
| case LITERAL_inline: |
| case LITERAL_friend: |
| case LITERAL_extern: |
| case LITERAL_struct: |
| case LITERAL_union: |
| case LITERAL_class: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case LITERAL_GFEXCLUDE: |
| case LITERAL_GFINCLUDE: |
| case LITERAL_GFID: |
| case LITERAL_GFUNREAD: |
| case LITERAL_GFARRAYSIZE: |
| case LITERAL_GFARRAYSIZES: |
| case LITERAL_GFARRAYELEMSIZE: |
| case LITERAL_auto: |
| case LITERAL_register: |
| case LITERAL_static: |
| case LITERAL_mutable: |
| case LITERAL__inline: |
| case LITERAL___inline: |
| case LITERAL_virtual: |
| case LITERAL_explicit: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case LITERAL_const: |
| case LITERAL___const: |
| case LITERAL_volatile: |
| case LITERAL___volatile__: |
| case SCOPE: { |
| new_type_id(); |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| type_id(); |
| match(RPAREN); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| { |
| switch (LA(1)) { |
| case LPAREN: { |
| new_initializer(); |
| break; |
| } |
| case LESSTHAN: |
| case GREATERTHAN: |
| case SEMICOLON: |
| case RCURLY: |
| case ASSIGNEQUAL: |
| case COLON: |
| case RPAREN: |
| case COMMA: |
| case RSQUARE: |
| case STAR: |
| case AMPERSAND: |
| case ELLIPSIS: |
| case TIMESEQUAL: |
| case DIVIDEEQUAL: |
| case MINUSEQUAL: |
| case PLUSEQUAL: |
| case MODEQUAL: |
| case SHIFTLEFTEQUAL: |
| case SHIFTRIGHTEQUAL: |
| case BITWISEANDEQUAL: |
| case BITWISEXOREQUAL: |
| case BITWISEOREQUAL: |
| case QUESTIONMARK: |
| case OR: |
| case AND: |
| case BITWISEOR: |
| case BITWISEXOR: |
| case NOTEQUAL: |
| case EQUAL: |
| case LESSTHANOREQUALTO: |
| case GREATERTHANOREQUALTO: |
| case SHIFTLEFT: |
| case SHIFTRIGHT: |
| case PLUS: |
| case MINUS: |
| case DIVIDE: |
| case MOD: |
| case DOTMBR: |
| case POINTERTOMBR: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_129); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::delete_expression() { |
| try { // for error handling |
| match(LITERAL_delete); |
| { |
| switch (LA(1)) { |
| case LSQUARE: { |
| match(LSQUARE); |
| match(RSQUARE); |
| break; |
| } |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| cast_expression(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_129); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::primary_expression() { |
| try { // for error handling |
| switch (LA(1)) { |
| case ID: |
| case OPERATOR: |
| case TILDE: |
| case SCOPE: { |
| id_expression(); |
| break; |
| } |
| case StringLiteral: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: { |
| constant(); |
| break; |
| } |
| case LITERAL_this: { |
| match(LITERAL_this); |
| break; |
| } |
| case LPAREN: { |
| match(LPAREN); |
| expression(); |
| match(RPAREN); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_141); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::id_expression() { |
| #line 2105 "CPP_parser.g" |
| char* s; |
| #line 12353 "CPPParser.cpp" |
| |
| try { // for error handling |
| s = scope_override(); |
| { |
| switch (LA(1)) { |
| case ID: { |
| match(ID); |
| break; |
| } |
| case OPERATOR: { |
| match(OPERATOR); |
| optor(); |
| break; |
| } |
| case TILDE: { |
| match(TILDE); |
| { |
| switch (LA(1)) { |
| case STAR: { |
| match(STAR); |
| break; |
| } |
| case ID: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(ID); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_141); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::constant() { |
| try { // for error handling |
| switch (LA(1)) { |
| case OCTALINT: { |
| match(OCTALINT); |
| break; |
| } |
| case DECIMALINT: { |
| match(DECIMALINT); |
| break; |
| } |
| case HEXADECIMALINT: { |
| match(HEXADECIMALINT); |
| break; |
| } |
| case CharLiteral: { |
| match(CharLiteral); |
| break; |
| } |
| case WCharLiteral: { |
| match(WCharLiteral); |
| break; |
| } |
| case StringLiteral: |
| case WStringLiteral: { |
| { // ( ... )+ |
| int _cnt551 = 0; |
| for (;;) { |
| switch (LA(1)) { |
| case StringLiteral: { |
| match(StringLiteral); |
| break; |
| } |
| case WStringLiteral: { |
| match(WStringLiteral); |
| break; |
| } |
| default: { |
| if (_cnt551 >= 1) { |
| goto _loop551; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| _cnt551++; |
| } |
| _loop551:; |
| } // ( ... )+ |
| break; |
| } |
| case FLOATONE: { |
| match(FLOATONE); |
| break; |
| } |
| case FLOATTWO: { |
| match(FLOATTWO); |
| break; |
| } |
| case LITERAL_true: { |
| match(LITERAL_true); |
| break; |
| } |
| case LITERAL_false: { |
| match(LITERAL_false); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_141); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::new_type_id() { |
| try { // for error handling |
| declaration_specifiers(); |
| { |
| if ((_tokenSet_142.member(LA(1))) && (_tokenSet_143.member(LA(2)))) { |
| new_declarator(); |
| } else if ((_tokenSet_144.member(LA(1))) && |
| (_tokenSet_57.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_144); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::new_initializer() { |
| try { // for error handling |
| match(LPAREN); |
| { |
| switch (LA(1)) { |
| case ID: |
| case StringLiteral: |
| case LPAREN: |
| case LITERAL_typename: |
| case LITERAL_char: |
| case LITERAL_wchar_t: |
| case LITERAL_bool: |
| case LITERAL_short: |
| case LITERAL_int: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 55: |
| case 56: |
| case 57: |
| case 58: |
| case 59: |
| case 60: |
| case 61: |
| case 62: |
| case 63: |
| case 64: |
| case 65: |
| case 66: |
| case 67: |
| case LITERAL_long: |
| case LITERAL_signed: |
| case LITERAL_unsigned: |
| case LITERAL_float: |
| case LITERAL_double: |
| case LITERAL_void: |
| case LITERAL__declspec: |
| case LITERAL___declspec: |
| case OPERATOR: |
| case LITERAL_this: |
| case LITERAL_true: |
| case LITERAL_false: |
| case OCTALINT: |
| case TILDE: |
| case STAR: |
| case AMPERSAND: |
| case PLUS: |
| case MINUS: |
| case PLUSPLUS: |
| case MINUSMINUS: |
| case LITERAL_sizeof: |
| case LITERAL___alignof__: |
| case SCOPE: |
| case LITERAL_dynamic_cast: |
| case LITERAL_static_cast: |
| case LITERAL_reinterpret_cast: |
| case LITERAL_const_cast: |
| case LITERAL_typeid: |
| case DECIMALINT: |
| case HEXADECIMALINT: |
| case CharLiteral: |
| case WCharLiteral: |
| case WStringLiteral: |
| case FLOATONE: |
| case FLOATTWO: |
| case NOT: |
| case LITERAL_new: |
| case LITERAL_delete: { |
| expression_list(); |
| break; |
| } |
| case RPAREN: { |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| match(RPAREN); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_129); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::new_declarator() { |
| try { // for error handling |
| switch (LA(1)) { |
| case ID: |
| case LITERAL__stdcall: |
| case LITERAL___stdcall: |
| case STAR: |
| case AMPERSAND: |
| case SCOPE: |
| case LITERAL__cdecl: |
| case LITERAL___cdecl: |
| case LITERAL__near: |
| case LITERAL___near: |
| case LITERAL__far: |
| case LITERAL___far: |
| case LITERAL___interrupt: |
| case LITERAL_pascal: |
| case LITERAL__pascal: |
| case LITERAL___pascal: { |
| ptr_operator(); |
| { |
| if ((_tokenSet_142.member(LA(1))) && (_tokenSet_143.member(LA(2)))) { |
| new_declarator(); |
| } else if ((_tokenSet_144.member(LA(1))) && |
| (_tokenSet_57.member(LA(2)))) { |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| break; |
| } |
| case LSQUARE: { |
| direct_new_declarator(); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_144); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::direct_new_declarator() { |
| try { // for error handling |
| { // ( ... )+ |
| int _cnt570 = 0; |
| for (;;) { |
| if ((LA(1) == LSQUARE)) { |
| match(LSQUARE); |
| expression(); |
| match(RSQUARE); |
| } else { |
| if (_cnt570 >= 1) { |
| goto _loop570; |
| } else { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| |
| _cnt570++; |
| } |
| _loop570:; |
| } // ( ... )+ |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_144); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::ptr_to_member() { |
| #line 2211 "CPP_parser.g" |
| char* s; |
| #line 12715 "CPPParser.cpp" |
| |
| try { // for error handling |
| s = scope_override(); |
| match(STAR); |
| if (inputState->guessing == 0) { |
| #line 2214 "CPP_parser.g" |
| is_pointer = true; |
| #line 12723 "CPPParser.cpp" |
| } |
| cv_qualifier_seq(); |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_24); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::optor_simple_tokclass() { |
| try { // for error handling |
| { |
| switch (LA(1)) { |
| case PLUS: { |
| match(PLUS); |
| break; |
| } |
| case MINUS: { |
| match(MINUS); |
| break; |
| } |
| case STAR: { |
| match(STAR); |
| break; |
| } |
| case DIVIDE: { |
| match(DIVIDE); |
| break; |
| } |
| case MOD: { |
| match(MOD); |
| break; |
| } |
| case BITWISEXOR: { |
| match(BITWISEXOR); |
| break; |
| } |
| case AMPERSAND: { |
| match(AMPERSAND); |
| break; |
| } |
| case BITWISEOR: { |
| match(BITWISEOR); |
| break; |
| } |
| case TILDE: { |
| match(TILDE); |
| break; |
| } |
| case NOT: { |
| match(NOT); |
| break; |
| } |
| case SHIFTLEFT: { |
| match(SHIFTLEFT); |
| break; |
| } |
| case SHIFTRIGHT: { |
| match(SHIFTRIGHT); |
| break; |
| } |
| case ASSIGNEQUAL: { |
| match(ASSIGNEQUAL); |
| break; |
| } |
| case TIMESEQUAL: { |
| match(TIMESEQUAL); |
| break; |
| } |
| case DIVIDEEQUAL: { |
| match(DIVIDEEQUAL); |
| break; |
| } |
| case MODEQUAL: { |
| match(MODEQUAL); |
| break; |
| } |
| case PLUSEQUAL: { |
| match(PLUSEQUAL); |
| break; |
| } |
| case MINUSEQUAL: { |
| match(MINUSEQUAL); |
| break; |
| } |
| case SHIFTLEFTEQUAL: { |
| match(SHIFTLEFTEQUAL); |
| break; |
| } |
| case SHIFTRIGHTEQUAL: { |
| match(SHIFTRIGHTEQUAL); |
| break; |
| } |
| case BITWISEANDEQUAL: { |
| match(BITWISEANDEQUAL); |
| break; |
| } |
| case BITWISEXOREQUAL: { |
| match(BITWISEXOREQUAL); |
| break; |
| } |
| case BITWISEOREQUAL: { |
| match(BITWISEOREQUAL); |
| break; |
| } |
| case EQUAL: { |
| match(EQUAL); |
| break; |
| } |
| case NOTEQUAL: { |
| match(NOTEQUAL); |
| break; |
| } |
| case LESSTHAN: { |
| match(LESSTHAN); |
| break; |
| } |
| case GREATERTHAN: { |
| match(GREATERTHAN); |
| break; |
| } |
| case LESSTHANOREQUALTO: { |
| match(LESSTHANOREQUALTO); |
| break; |
| } |
| case GREATERTHANOREQUALTO: { |
| match(GREATERTHANOREQUALTO); |
| break; |
| } |
| case OR: { |
| match(OR); |
| break; |
| } |
| case AND: { |
| match(AND); |
| break; |
| } |
| case PLUSPLUS: { |
| match(PLUSPLUS); |
| break; |
| } |
| case MINUSMINUS: { |
| match(MINUSMINUS); |
| break; |
| } |
| case COMMA: { |
| match(COMMA); |
| break; |
| } |
| case POINTERTO: { |
| match(POINTERTO); |
| break; |
| } |
| case POINTERTOMBR: { |
| match(POINTERTOMBR); |
| break; |
| } |
| default: { |
| throw ANTLR_USE_NAMESPACE(antlr) |
| NoViableAltException(LT(1), getFilename()); |
| } |
| } |
| } |
| } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) { |
| if (inputState->guessing == 0) { |
| reportError(ex); |
| recover(ex, _tokenSet_64); |
| } else { |
| throw; |
| } |
| } |
| } |
| |
| void CPPParser::initializeASTFactory(ANTLR_USE_NAMESPACE(antlr) ASTFactory&) {} |
| const char* CPPParser::tokenNames[] = {"<0>", |
| "EOF", |
| "<2>", |
| "NULL_TREE_LOOKAHEAD", |
| "\"template\"", |
| "LESSTHAN", |
| "GREATERTHAN", |
| "\"typedef\"", |
| "SEMICOLON", |
| "\"enum\"", |
| "ID", |
| "LCURLY", |
| "\"inline\"", |
| "\"friend\"", |
| "\"namespace\"", |
| "\"antlrTrace_on\"", |
| "\"antlrTrace_off\"", |
| "RCURLY", |
| "ASSIGNEQUAL", |
| "COLON", |
| "\"extern\"", |
| "StringLiteral", |
| "\"struct\"", |
| "\"union\"", |
| "\"class\"", |
| "\"_stdcall\"", |
| "\"__stdcall\"", |
| "\"GFEXCLUDE\"", |
| "\"GFINCLUDE\"", |
| "\"GFID\"", |
| "\"GFUNREAD\"", |
| "\"GFARRAYSIZE\"", |
| "LPAREN", |
| "RPAREN", |
| "\"GFARRAYSIZES\"", |
| "\"GFARRAYELEMSIZE\"", |
| "\"auto\"", |
| "\"register\"", |
| "\"static\"", |
| "\"mutable\"", |
| "\"_inline\"", |
| "\"__inline\"", |
| "\"virtual\"", |
| "\"explicit\"", |
| "\"typename\"", |
| "\"char\"", |
| "\"wchar_t\"", |
| "\"bool\"", |
| "\"short\"", |
| "\"int\"", |
| "\"_int8\"", |
| "\"__int8\"", |
| "\"int8_t\"", |
| "\"_int16\"", |
| "\"__int16\"", |
| "\"int16_t\"", |
| "\"_int32\"", |
| "\"__int32\"", |
| "\"int32_t\"", |
| "\"_int64\"", |
| "\"__int64\"", |
| "\"int64_t\"", |
| "\"uint8_t\"", |
| "\"uint16_t\"", |
| "\"uint32_t\"", |
| "\"uint64_t\"", |
| "\"_w64\"", |
| "\"__w64\"", |
| "\"long\"", |
| "\"signed\"", |
| "\"unsigned\"", |
| "\"float\"", |
| "\"double\"", |
| "\"void\"", |
| "\"_declspec\"", |
| "\"__declspec\"", |
| "\"const\"", |
| "\"__const\"", |
| "\"volatile\"", |
| "\"__volatile__\"", |
| "\"GFIGNORE\"", |
| "COMMA", |
| "\"public\"", |
| "\"protected\"", |
| "\"private\"", |
| "\"operator\"", |
| "\"this\"", |
| "\"true\"", |
| "\"false\"", |
| "OCTALINT", |
| "LSQUARE", |
| "RSQUARE", |
| "TILDE", |
| "STAR", |
| "AMPERSAND", |
| "ELLIPSIS", |
| "\"throw\"", |
| "\"using\"", |
| "\"case\"", |
| "\"default\"", |
| "\"if\"", |
| "\"else\"", |
| "\"switch\"", |
| "\"while\"", |
| "\"do\"", |
| "\"for\"", |
| "\"goto\"", |
| "\"continue\"", |
| "\"break\"", |
| "\"return\"", |
| "\"try\"", |
| "\"catch\"", |
| "\"asm\"", |
| "\"_asm\"", |
| "\"__asm\"", |
| "\"__asm__\"", |
| "TIMESEQUAL", |
| "DIVIDEEQUAL", |
| "MINUSEQUAL", |
| "PLUSEQUAL", |
| "MODEQUAL", |
| "SHIFTLEFTEQUAL", |
| "SHIFTRIGHTEQUAL", |
| "BITWISEANDEQUAL", |
| "BITWISEXOREQUAL", |
| "BITWISEOREQUAL", |
| "QUESTIONMARK", |
| "OR", |
| "AND", |
| "BITWISEOR", |
| "BITWISEXOR", |
| "NOTEQUAL", |
| "EQUAL", |
| "LESSTHANOREQUALTO", |
| "GREATERTHANOREQUALTO", |
| "SHIFTLEFT", |
| "SHIFTRIGHT", |
| "PLUS", |
| "MINUS", |
| "DIVIDE", |
| "MOD", |
| "DOTMBR", |
| "POINTERTOMBR", |
| "PLUSPLUS", |
| "MINUSMINUS", |
| "\"sizeof\"", |
| "\"__alignof__\"", |
| "SCOPE", |
| "DOT", |
| "POINTERTO", |
| "\"dynamic_cast\"", |
| "\"static_cast\"", |
| "\"reinterpret_cast\"", |
| "\"const_cast\"", |
| "\"typeid\"", |
| "DECIMALINT", |
| "HEXADECIMALINT", |
| "CharLiteral", |
| "WCharLiteral", |
| "WStringLiteral", |
| "FLOATONE", |
| "FLOATTWO", |
| "NOT", |
| "\"new\"", |
| "\"_cdecl\"", |
| "\"__cdecl\"", |
| "\"_near\"", |
| "\"__near\"", |
| "\"_far\"", |
| "\"__far\"", |
| "\"__interrupt\"", |
| "\"pascal\"", |
| "\"_pascal\"", |
| "\"__pascal\"", |
| "\"delete\"", |
| "Whitespace", |
| "Comment", |
| "CPPComment", |
| "a preprocessor directive", |
| "LineDirective", |
| "Space", |
| "Pragma", |
| "Error", |
| "EndOfLine", |
| "Escape", |
| "Digit", |
| "Decimal", |
| "LongSuffix", |
| "UnsignedSuffix", |
| "FloatSuffix", |
| "Exponent", |
| "Vocabulary", |
| "Number", |
| 0}; |
| |
| const unsigned long CPPParser::_tokenSet_0_data_[] = { |
| 4291950480UL, 4294967293UL, 1910571007UL, 2UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace" |
| // "antlrTrace_on" "antlrTrace_off" "extern" "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND |
| // "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_0( |
| _tokenSet_0_data_, 12); |
| const unsigned long CPPParser::_tokenSet_1_data_[] = {2UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // EOF |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_1( |
| _tokenSet_1_data_, 8); |
| const unsigned long CPPParser::_tokenSet_2_data_[] = { |
| 4291835520UL, 4294967292UL, 65535UL, 2UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "using" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_2( |
| _tokenSet_2_data_, 12); |
| const unsigned long CPPParser::_tokenSet_3_data_[] = { |
| 4293949344UL, 4294967293UL, 1910571007UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace" |
| // "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall" |
| // "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline" |
| // "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__" |
| // "operator" "this" "true" "false" TILDE STAR AMPERSAND SCOPE "_cdecl" |
| // "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" |
| // "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_3( |
| _tokenSet_3_data_, 12); |
| const unsigned long CPPParser::_tokenSet_4_data_[] = {4096UL, 3840UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // "inline" "_inline" "__inline" "virtual" "explicit" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_4( |
| _tokenSet_4_data_, 8); |
| const unsigned long CPPParser::_tokenSet_5_data_[] = { |
| 3072UL, 0UL, 31457280UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID LCURLY "operator" "this" "true" "false" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_5( |
| _tokenSet_5_data_, 12); |
| const unsigned long CPPParser::_tokenSet_6_data_[] = { |
| 5136UL, 1792UL, 268435456UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" ID "inline" "_inline" "__inline" "virtual" TILDE SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_6( |
| _tokenSet_6_data_, 12); |
| const unsigned long CPPParser::_tokenSet_7_data_[] = { |
| 5152UL, 1792UL, 268435456UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN ID "inline" "_inline" "__inline" "virtual" TILDE SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_7( |
| _tokenSet_7_data_, 12); |
| const unsigned long CPPParser::_tokenSet_8_data_[] = { |
| 5120UL, 2816UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "inline" "_inline" "__inline" "explicit" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_8( |
| _tokenSet_8_data_, 12); |
| const unsigned long CPPParser::_tokenSet_9_data_[] = { |
| 5152UL, 2817UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN ID "inline" LPAREN "_inline" "__inline" "explicit" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_9( |
| _tokenSet_9_data_, 12); |
| const unsigned long CPPParser::_tokenSet_10_data_[] = { |
| 5120UL, 0UL, 2097152UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "inline" "operator" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_10( |
| _tokenSet_10_data_, 12); |
| const unsigned long CPPParser::_tokenSet_11_data_[] = { |
| 4291835552UL, 4294967292UL, 2162687UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" |
| // "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" |
| // "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char" |
| // "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" |
| // "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" |
| // "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" |
| // "unsigned" "float" "double" "void" "_declspec" "__declspec" "const" |
| // "__const" "volatile" "__volatile__" "operator" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_11( |
| _tokenSet_11_data_, 12); |
| const unsigned long CPPParser::_tokenSet_12_data_[] = { |
| 4291835520UL, 4294967292UL, 65535UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_12( |
| _tokenSet_12_data_, 12); |
| const unsigned long CPPParser::_tokenSet_13_data_[] = { |
| 4291835552UL, 4294967293UL, 1642135551UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" |
| // "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" |
| // "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename" |
| // "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" |
| // "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "operator" "this" "true" |
| // "false" STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" |
| // "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_13( |
| _tokenSet_13_data_, 12); |
| const unsigned long CPPParser::_tokenSet_14_data_[] = { |
| 4291835520UL, 4294967293UL, 1642135551UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" STAR AMPERSAND SCOPE |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_14( |
| _tokenSet_14_data_, 12); |
| const unsigned long CPPParser::_tokenSet_15_data_[] = { |
| 4292097760UL, 4294967293UL, 1977810943UL, 3220176896UL, 2744319UL, 32764UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL |
| // "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" |
| // "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" COMMA "operator" |
| // "this" "true" "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL |
| // EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS |
| // MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT |
| // "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" |
| // "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_15( |
| _tokenSet_15_data_, 12); |
| const unsigned long CPPParser::_tokenSet_16_data_[] = { |
| 29372416UL, 3840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "inline" "friend" "struct" "union" "class" "_inline" "__inline" "virtual" |
| // "explicit" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_16( |
| _tokenSet_16_data_, 8); |
| const unsigned long CPPParser::_tokenSet_17_data_[] = { |
| 29367296UL, 3840UL, 31525888UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID LCURLY "inline" "struct" "union" "class" "_inline" "__inline" "virtual" |
| // "explicit" "_declspec" "__declspec" "GFIGNORE" "operator" "this" "true" |
| // "false" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_17( |
| _tokenSet_17_data_, 12); |
| const unsigned long CPPParser::_tokenSet_18_data_[] = { |
| 4291835808UL, 4294967293UL, 1910571007UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" "extern" "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "operator" "this" "true" |
| // "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" |
| // "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_18( |
| _tokenSet_18_data_, 12); |
| const unsigned long CPPParser::_tokenSet_19_data_[] = { |
| 4292081554UL, 4294967293UL, 1910571007UL, 2UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace" |
| // "antlrTrace_on" "antlrTrace_off" RCURLY "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND |
| // "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_19( |
| _tokenSet_19_data_, 12); |
| const unsigned long CPPParser::_tokenSet_20_data_[] = { |
| 4291934096UL, 4294967293UL, 1912406015UL, 2UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "typedef" SEMICOLON "enum" ID "inline" "friend" "antlrTrace_on" |
| // "antlrTrace_off" "extern" "struct" "union" "class" "_stdcall" "__stdcall" |
| // "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline" |
| // "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__" |
| // "public" "protected" "private" "operator" "this" "true" "false" TILDE |
| // STAR AMPERSAND "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" |
| // "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_20( |
| _tokenSet_20_data_, 12); |
| const unsigned long CPPParser::_tokenSet_21_data_[] = { |
| 100664576UL, 1UL, 1910505472UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON ID "_stdcall" "__stdcall" LPAREN "operator" "this" "true" |
| // "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" |
| // "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_21( |
| _tokenSet_21_data_, 12); |
| const unsigned long CPPParser::_tokenSet_22_data_[] = {256UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_22( |
| _tokenSet_22_data_, 8); |
| const unsigned long CPPParser::_tokenSet_23_data_[] = { |
| 101188864UL, 1UL, 1910505472UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON ID COLON "_stdcall" "__stdcall" LPAREN "operator" "this" "true" |
| // "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" |
| // "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_23( |
| _tokenSet_23_data_, 12); |
| const unsigned long CPPParser::_tokenSet_24_data_[] = { |
| 101582176UL, 3UL, 4259446784UL, 4293918720UL, 557055UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON "_stdcall" |
| // "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE |
| // RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" "__cdecl" "_near" "__near" |
| // "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_24( |
| _tokenSet_24_data_, 12); |
| const unsigned long CPPParser::_tokenSet_25_data_[] = { |
| 100664320UL, 0UL, 1610612736UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "_stdcall" "__stdcall" STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" |
| // "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_25( |
| _tokenSet_25_data_, 12); |
| const unsigned long CPPParser::_tokenSet_26_data_[] = { |
| 100664352UL, 1UL, 1642131456UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN ID "_stdcall" "__stdcall" LPAREN "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" STAR AMPERSAND SCOPE |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_26( |
| _tokenSet_26_data_, 12); |
| const unsigned long CPPParser::_tokenSet_27_data_[] = { |
| 1024UL, 1UL, 31457280UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID LPAREN "operator" "this" "true" "false" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_27( |
| _tokenSet_27_data_, 12); |
| const unsigned long CPPParser::_tokenSet_28_data_[] = { |
| 263264UL, 1UL, 1977745408UL, 3220176896UL, 2744319UL, 16396UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID ASSIGNEQUAL LPAREN COMMA "operator" "this" "true" |
| // "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR |
| // PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_28( |
| _tokenSet_28_data_, 12); |
| const unsigned long CPPParser::_tokenSet_29_data_[] = { |
| 4291837824UL, 4294967292UL, 65535UL, 2UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "extern" "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" |
| // "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename" |
| // "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" |
| // "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "using" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_29( |
| _tokenSet_29_data_, 12); |
| const unsigned long CPPParser::_tokenSet_30_data_[] = { |
| 4294180754UL, 4294967293UL, 1945960447UL, 1015807UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" |
| // "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral |
| // "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" |
| // "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" "public" "protected" |
| // "private" "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND |
| // "throw" "using" "case" "default" "if" "else" "switch" "while" "do" "for" |
| // "goto" "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" |
| // PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_30( |
| _tokenSet_30_data_, 12); |
| const unsigned long CPPParser::_tokenSet_31_data_[] = { |
| 4291835520UL, 4294967293UL, 1910571007UL, 2UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND |
| // "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_31( |
| _tokenSet_31_data_, 12); |
| const unsigned long CPPParser::_tokenSet_32_data_[] = {2304UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON LCURLY |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_32( |
| _tokenSet_32_data_, 8); |
| const unsigned long CPPParser::_tokenSet_33_data_[] = { |
| 1024UL, 0UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_33( |
| _tokenSet_33_data_, 12); |
| const unsigned long CPPParser::_tokenSet_34_data_[] = { |
| 1024UL, 0UL, 836763648UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "operator" "this" "true" "false" TILDE STAR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_34( |
| _tokenSet_34_data_, 8); |
| const unsigned long CPPParser::_tokenSet_35_data_[] = { |
| 4291837568UL, 4294967292UL, 65535UL, 2UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID LCURLY "inline" "friend" "extern" "struct" "union" |
| // "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" |
| // "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char" |
| // "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" |
| // "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" |
| // "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" |
| // "unsigned" "float" "double" "void" "_declspec" "__declspec" "const" |
| // "__const" "volatile" "__volatile__" "using" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_35( |
| _tokenSet_35_data_, 12); |
| const unsigned long CPPParser::_tokenSet_36_data_[] = { |
| 4294180784UL, 4294967293UL, 1945960447UL, 1015775UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" LESSTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" |
| // "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral |
| // "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" |
| // "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" "public" "protected" |
| // "private" "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND |
| // "throw" "using" "case" "default" "if" "switch" "while" "do" "for" "goto" |
| // "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS |
| // MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_36( |
| _tokenSet_36_data_, 12); |
| const unsigned long CPPParser::_tokenSet_37_data_[] = { |
| 4294180752UL, 4294967293UL, 1945960447UL, 1015775UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace" |
| // "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "public" "protected" "private" |
| // "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw" |
| // "using" "case" "default" "if" "switch" "while" "do" "for" "goto" "continue" |
| // "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS MINUS PLUSPLUS |
| // MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast" |
| // "reinterpret_cast" "const_cast" "typeid" DECIMALINT HEXADECIMALINT |
| // CharLiteral |
| // WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl" |
| // "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| // "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_37( |
| _tokenSet_37_data_, 12); |
| const unsigned long CPPParser::_tokenSet_38_data_[] = { |
| 100664320UL, 1UL, 1642070016UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "_stdcall" "__stdcall" LPAREN "operator" "this" "true" "false" STAR |
| // AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_38( |
| _tokenSet_38_data_, 12); |
| const unsigned long CPPParser::_tokenSet_39_data_[] = { |
| 100926560UL, 1UL, 1977806848UL, 3220176896UL, 2744319UL, 32764UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID ASSIGNEQUAL "_stdcall" "__stdcall" LPAREN "const" |
| // "__const" "volatile" "__volatile__" COMMA "operator" "this" "true" "false" |
| // LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR |
| // PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT "new" "_cdecl" "__cdecl" "_near" |
| // "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| // "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_39( |
| _tokenSet_39_data_, 12); |
| const unsigned long CPPParser::_tokenSet_40_data_[] = { |
| 4294180752UL, 4294967293UL, 1945960447UL, 1015807UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace" |
| // "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "public" "protected" "private" |
| // "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw" |
| // "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto" |
| // "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS |
| // MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_40( |
| _tokenSet_40_data_, 12); |
| const unsigned long CPPParser::_tokenSet_41_data_[] = { |
| 101453120UL, 3UL, 4125229056UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON ID LCURLY ASSIGNEQUAL COLON "_stdcall" "__stdcall" |
| // LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE TILDE STAR |
| // AMPERSAND ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" |
| // "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_41( |
| _tokenSet_41_data_, 12); |
| const unsigned long CPPParser::_tokenSet_42_data_[] = { |
| 5120UL, 1792UL, 268435456UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "inline" "_inline" "__inline" "virtual" TILDE SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_42( |
| _tokenSet_42_data_, 12); |
| const unsigned long CPPParser::_tokenSet_43_data_[] = { |
| 4291835520UL, 4294967292UL, 2162687UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "operator" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_43( |
| _tokenSet_43_data_, 12); |
| const unsigned long CPPParser::_tokenSet_44_data_[] = { |
| 1024UL, 0UL, 31457280UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "operator" "this" "true" "false" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_44( |
| _tokenSet_44_data_, 12); |
| const unsigned long CPPParser::_tokenSet_45_data_[] = { |
| 263520UL, 1UL, 1977745408UL, 3220176896UL, 2744319UL, 16396UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL LPAREN COMMA "operator" |
| // "this" "true" "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL |
| // EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS |
| // MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT |
| // "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_45( |
| _tokenSet_45_data_, 12); |
| const unsigned long CPPParser::_tokenSet_46_data_[] = { |
| 100668416UL, 3841UL, 1642070016UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "inline" "_stdcall" "__stdcall" LPAREN "_inline" "__inline" "virtual" |
| // "explicit" "operator" "this" "true" "false" STAR AMPERSAND SCOPE "_cdecl" |
| // "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" |
| // "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_46( |
| _tokenSet_46_data_, 12); |
| const unsigned long CPPParser::_tokenSet_47_data_[] = { |
| 100930656UL, 3841UL, 1977806848UL, 3220176896UL, 2744319UL, 32764UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID "inline" ASSIGNEQUAL "_stdcall" "__stdcall" |
| // LPAREN "_inline" "__inline" "virtual" "explicit" "const" "__const" "volatile" |
| // "__volatile__" COMMA "operator" "this" "true" "false" LSQUARE TILDE |
| // STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL |
| // SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| // OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO |
| // SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS |
| // SCOPE POINTERTO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" |
| // "__far" "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_47( |
| _tokenSet_47_data_, 12); |
| const unsigned long CPPParser::_tokenSet_48_data_[] = {526592UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON LCURLY COLON |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_48( |
| _tokenSet_48_data_, 8); |
| const unsigned long CPPParser::_tokenSet_49_data_[] = { |
| 4294049680UL, 4294967293UL, 1945960447UL, 1015775UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace" |
| // "antlrTrace_on" "antlrTrace_off" "extern" StringLiteral "struct" "union" |
| // "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" |
| // "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename" |
| // "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" |
| // "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "public" "protected" "private" |
| // "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw" |
| // "using" "case" "default" "if" "switch" "while" "do" "for" "goto" "continue" |
| // "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS MINUS PLUSPLUS |
| // MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast" |
| // "reinterpret_cast" "const_cast" "typeid" DECIMALINT HEXADECIMALINT |
| // CharLiteral |
| // WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl" |
| // "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| // "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_49( |
| _tokenSet_49_data_, 12); |
| const unsigned long CPPParser::_tokenSet_50_data_[] = { |
| 4294180754UL, 4294967293UL, 1945960447UL, 1048575UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" |
| // "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral |
| // "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" |
| // "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" "public" "protected" |
| // "private" "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND |
| // "throw" "using" "case" "default" "if" "else" "switch" "while" "do" "for" |
| // "goto" "continue" "break" "return" "try" "catch" "asm" "_asm" "__asm" |
| // "__asm__" PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE |
| // "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_50( |
| _tokenSet_50_data_, 12); |
| const unsigned long CPPParser::_tokenSet_51_data_[] = { |
| 525312UL, 1024UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID COLON "virtual" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_51( |
| _tokenSet_51_data_, 12); |
| const unsigned long CPPParser::_tokenSet_52_data_[] = {64UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_52( |
| _tokenSet_52_data_, 8); |
| const unsigned long CPPParser::_tokenSet_53_data_[] = {2048UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LCURLY |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_53( |
| _tokenSet_53_data_, 8); |
| const unsigned long CPPParser::_tokenSet_54_data_[] = { |
| 4292755424UL, 4294967295UL, 4259512319UL, 4293918723UL, 557055UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" |
| // RCURLY ASSIGNEQUAL COLON "extern" "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" |
| // "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char" |
| // "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" |
| // "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" |
| // "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" |
| // "unsigned" "float" "double" "void" "_declspec" "__declspec" "const" |
| // "__const" "volatile" "__volatile__" COMMA "operator" "this" "true" "false" |
| // LSQUARE RSQUARE TILDE STAR AMPERSAND ELLIPSIS "throw" "using" TIMESEQUAL |
| // DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL |
| // BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR |
| // BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT |
| // SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" |
| // "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" |
| // "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_54( |
| _tokenSet_54_data_, 12); |
| const unsigned long CPPParser::_tokenSet_55_data_[] = { |
| 4293932672UL, 4294967293UL, 1944125439UL, 0UL, 4291790336UL, 16399UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "operator" "this" "true" |
| // "false" OCTALINT TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS |
| // "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" |
| // "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral |
| // WStringLiteral FLOATONE FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_55( |
| _tokenSet_55_data_, 12); |
| const unsigned long CPPParser::_tokenSet_56_data_[] = { |
| 101584224UL, 3UL, 4259446784UL, 4293918720UL, 557055UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID LCURLY RCURLY ASSIGNEQUAL COLON "_stdcall" |
| // "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE |
| // RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" "__cdecl" "_near" "__near" |
| // "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_56( |
| _tokenSet_56_data_, 12); |
| const unsigned long CPPParser::_tokenSet_57_data_[] = { |
| 4294967282UL, 4294967295UL, 4294967295UL, 4294934527UL, |
| 4294967295UL, 32767UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY |
| // "inline" "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY |
| // ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" |
| // "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char" |
| // "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" |
| // "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" |
| // "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" |
| // "unsigned" "float" "double" "void" "_declspec" "__declspec" "const" |
| // "__const" "volatile" "__volatile__" "GFIGNORE" COMMA "public" "protected" |
| // "private" "operator" "this" "true" "false" OCTALINT LSQUARE RSQUARE |
| // TILDE STAR AMPERSAND ELLIPSIS "throw" "using" "case" "default" "if" |
| // "else" "switch" "while" "do" "for" "goto" "continue" "break" "return" |
| // "try" "asm" "_asm" "__asm" "__asm__" TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" |
| // SCOPE DOT POINTERTO "dynamic_cast" "static_cast" "reinterpret_cast" |
| // "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral |
| // WStringLiteral FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" |
| // "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| // "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_57( |
| _tokenSet_57_data_, 12); |
| const unsigned long CPPParser::_tokenSet_58_data_[] = { |
| 3072UL, 0UL, 31522816UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID LCURLY "GFIGNORE" "operator" "this" "true" "false" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_58( |
| _tokenSet_58_data_, 12); |
| const unsigned long CPPParser::_tokenSet_59_data_[] = { |
| 524544UL, 2UL, 134217728UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON COLON RPAREN RSQUARE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_59( |
| _tokenSet_59_data_, 8); |
| const unsigned long CPPParser::_tokenSet_60_data_[] = { |
| 2048UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LCURLY COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_60( |
| _tokenSet_60_data_, 8); |
| const unsigned long CPPParser::_tokenSet_61_data_[] = {131072UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // RCURLY |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_61( |
| _tokenSet_61_data_, 8); |
| const unsigned long CPPParser::_tokenSet_62_data_[] = { |
| 131072UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // RCURLY COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_62( |
| _tokenSet_62_data_, 8); |
| const unsigned long CPPParser::_tokenSet_63_data_[] = { |
| 917760UL, 0UL, 134348800UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON RCURLY ASSIGNEQUAL COLON COMMA RSQUARE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_63( |
| _tokenSet_63_data_, 8); |
| const unsigned long CPPParser::_tokenSet_64_data_[] = { |
| 101584224UL, 3UL, 4259446784UL, 4293918720UL, 3801087UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID LCURLY RCURLY ASSIGNEQUAL COLON "_stdcall" |
| // "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE |
| // RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE DOT POINTERTO |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_64( |
| _tokenSet_64_data_, 12); |
| const unsigned long CPPParser::_tokenSet_65_data_[] = { |
| 256UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_65( |
| _tokenSet_65_data_, 8); |
| const unsigned long CPPParser::_tokenSet_66_data_[] = { |
| 100664352UL, 1UL, 1910566912UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN ID "_stdcall" "__stdcall" LPAREN "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND |
| // SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_66( |
| _tokenSet_66_data_, 12); |
| const unsigned long CPPParser::_tokenSet_67_data_[] = { |
| 1024UL, 1UL, 299892736UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID LPAREN "operator" "this" "true" "false" TILDE SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_67( |
| _tokenSet_67_data_, 12); |
| const unsigned long CPPParser::_tokenSet_68_data_[] = { |
| 100926816UL, 3UL, 4125229056UL, 3220176896UL, 2744319UL, 32764UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL "_stdcall" "__stdcall" |
| // LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE TILDE STAR |
| // AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL |
| // SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| // OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO |
| // SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS |
| // SCOPE POINTERTO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" |
| // "__far" "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_68( |
| _tokenSet_68_data_, 12); |
| const unsigned long CPPParser::_tokenSet_69_data_[] = { |
| 262464UL, 3UL, 2147614720UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON ASSIGNEQUAL LPAREN RPAREN COMMA ELLIPSIS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_69( |
| _tokenSet_69_data_, 8); |
| const unsigned long CPPParser::_tokenSet_70_data_[] = { |
| 131328UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON RCURLY COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_70( |
| _tokenSet_70_data_, 8); |
| const unsigned long CPPParser::_tokenSet_71_data_[] = {0UL, 2UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // RPAREN |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_71( |
| _tokenSet_71_data_, 8); |
| const unsigned long CPPParser::_tokenSet_72_data_[] = { |
| 2098176UL, 4294963201UL, 1944063999UL, 0UL, 4291790336UL, 16399UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID StringLiteral LPAREN "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "operator" "this" "true" "false" OCTALINT |
| // TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" |
| // SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_72( |
| _tokenSet_72_data_, 12); |
| const unsigned long CPPParser::_tokenSet_73_data_[] = { |
| 4294850528UL, 4294967295UL, 4293066751UL, 4293918720UL, |
| 4294967295UL, 16399UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" |
| // RCURLY ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" |
| // "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char" |
| // "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" |
| // "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" |
| // "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" |
| // "unsigned" "float" "double" "void" "_declspec" "__declspec" "const" |
| // "__const" "volatile" "__volatile__" COMMA "operator" "this" "true" "false" |
| // OCTALINT LSQUARE RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR |
| // NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT |
| // PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" |
| // "__alignof__" SCOPE DOT POINTERTO "dynamic_cast" "static_cast" |
| // "reinterpret_cast" |
| // "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral |
| // WStringLiteral FLOATONE FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_73( |
| _tokenSet_73_data_, 12); |
| const unsigned long CPPParser::_tokenSet_74_data_[] = { |
| 655680UL, 2UL, 2281832448UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY COLON RPAREN COMMA RSQUARE ELLIPSIS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_74( |
| _tokenSet_74_data_, 8); |
| const unsigned long CPPParser::_tokenSet_75_data_[] = { |
| 2622464UL, 4294963201UL, 1944063999UL, 0UL, 4291790336UL, 16399UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID COLON StringLiteral LPAREN "typename" "char" "wchar_t" "bool" "short" |
| // "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" |
| // "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" |
| // "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" |
| // "double" "void" "_declspec" "__declspec" "operator" "this" "true" "false" |
| // OCTALINT TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" |
| // "__alignof__" SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" |
| // "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral |
| // WStringLiteral FLOATONE FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_75( |
| _tokenSet_75_data_, 12); |
| const unsigned long CPPParser::_tokenSet_76_data_[] = { |
| 100664320UL, 1UL, 1910505472UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "_stdcall" "__stdcall" LPAREN "operator" "this" "true" "false" TILDE |
| // STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_76( |
| _tokenSet_76_data_, 12); |
| const unsigned long CPPParser::_tokenSet_77_data_[] = { |
| 100926816UL, 1UL, 1977806848UL, 3220176896UL, 2744319UL, 32764UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL "_stdcall" "__stdcall" |
| // LPAREN "const" "__const" "volatile" "__volatile__" COMMA "operator" |
| // "this" "true" "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL |
| // EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS |
| // MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT |
| // "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" |
| // "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_77( |
| _tokenSet_77_data_, 12); |
| const unsigned long CPPParser::_tokenSet_78_data_[] = { |
| 262400UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SEMICOLON ASSIGNEQUAL COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_78( |
| _tokenSet_78_data_, 8); |
| const unsigned long CPPParser::_tokenSet_79_data_[] = { |
| 4293932672UL, 4294967295UL, 4225826815UL, 0UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" "operator" |
| // "this" "true" "false" OCTALINT RSQUARE TILDE STAR AMPERSAND ELLIPSIS |
| // PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_79( |
| _tokenSet_79_data_, 12); |
| const unsigned long CPPParser::_tokenSet_80_data_[] = { |
| 4294967250UL, 4294967295UL, 4160684031UL, 1015807UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" |
| // "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY ASSIGNEQUAL |
| // COLON "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall" |
| // "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN |
| // "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" COMMA "public" "protected" "private" "operator" "this" |
| // "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND ELLIPSIS "throw" |
| // "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto" |
| // "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS |
| // MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_80( |
| _tokenSet_80_data_, 12); |
| const unsigned long CPPParser::_tokenSet_81_data_[] = { |
| 263520UL, 3UL, 4125229056UL, 3220176896UL, 2744319UL, 16396UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL LPAREN RPAREN COMMA "operator" |
| // "this" "true" "false" LSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL |
| // DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL |
| // BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR |
| // NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT |
| // PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO |
| // NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_81( |
| _tokenSet_81_data_, 12); |
| const unsigned long CPPParser::_tokenSet_82_data_[] = { |
| 4292624320UL, 4294967295UL, 2147680255UL, 2UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" |
| // ASSIGNEQUAL |
| // COLON "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" |
| // "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline" |
| // "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__" |
| // COMMA ELLIPSIS "using" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_82( |
| _tokenSet_82_data_, 12); |
| const unsigned long CPPParser::_tokenSet_83_data_[] = { |
| 4292099968UL, 4294967292UL, 65535UL, 3UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" ASSIGNEQUAL "extern" |
| // "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" |
| // "GFID" "GFUNREAD" "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "throw" "using" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_83( |
| _tokenSet_83_data_, 12); |
| const unsigned long CPPParser::_tokenSet_84_data_[] = {526336UL, 0UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LCURLY COLON |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_84( |
| _tokenSet_84_data_, 8); |
| const unsigned long CPPParser::_tokenSet_85_data_[] = {0UL, 1UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LPAREN |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_85( |
| _tokenSet_85_data_, 8); |
| const unsigned long CPPParser::_tokenSet_86_data_[] = { |
| 1024UL, 0UL, 268435456UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID TILDE SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_86( |
| _tokenSet_86_data_, 12); |
| const unsigned long CPPParser::_tokenSet_87_data_[] = { |
| 0UL, 2UL, 2147483648UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // RPAREN ELLIPSIS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_87( |
| _tokenSet_87_data_, 8); |
| const unsigned long CPPParser::_tokenSet_88_data_[] = { |
| 4292097760UL, 4294967295UL, 4125294591UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL |
| // "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" |
| // "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline" |
| // "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__" |
| // COMMA "operator" "this" "true" "false" LSQUARE TILDE STAR AMPERSAND |
| // ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_88( |
| _tokenSet_88_data_, 12); |
| const unsigned long CPPParser::_tokenSet_89_data_[] = { |
| 100926560UL, 3UL, 4125290496UL, 3220176896UL, 2744319UL, 32764UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID ASSIGNEQUAL "_stdcall" "__stdcall" LPAREN RPAREN |
| // "const" "__const" "volatile" "__volatile__" COMMA "operator" "this" |
| // "true" "false" LSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL |
| // EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS |
| // MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT |
| // "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" |
| // "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_89( |
| _tokenSet_89_data_, 12); |
| const unsigned long CPPParser::_tokenSet_90_data_[] = { |
| 100926528UL, 3UL, 3825336320UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN ID ASSIGNEQUAL "_stdcall" "__stdcall" LPAREN RPAREN COMMA |
| // LSQUARE STAR AMPERSAND ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" |
| // "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_90( |
| _tokenSet_90_data_, 12); |
| const unsigned long CPPParser::_tokenSet_91_data_[] = { |
| 4294721520UL, 4294967295UL, 4293066751UL, 3UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY |
| // "inline" "friend" ASSIGNEQUAL COLON "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" COMMA "operator" |
| // "this" "true" "false" OCTALINT LSQUARE RSQUARE TILDE STAR AMPERSAND |
| // ELLIPSIS "throw" "using" PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" |
| // "__alignof__" |
| // SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_91( |
| _tokenSet_91_data_, 12); |
| const unsigned long CPPParser::_tokenSet_92_data_[] = { |
| 64UL, 2UL, 2147614720UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN RPAREN COMMA ELLIPSIS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_92( |
| _tokenSet_92_data_, 8); |
| const unsigned long CPPParser::_tokenSet_93_data_[] = { |
| 262208UL, 3UL, 2214723584UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN ASSIGNEQUAL LPAREN RPAREN COMMA LSQUARE ELLIPSIS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_93( |
| _tokenSet_93_data_, 8); |
| const unsigned long CPPParser::_tokenSet_94_data_[] = { |
| 4294852594UL, 4294967295UL, 4293066751UL, 4293918723UL, |
| 4291821567UL, 32767UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY |
| // "inline" "friend" RCURLY ASSIGNEQUAL COLON "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" COMMA "operator" |
| // "this" "true" "false" OCTALINT LSQUARE RSQUARE TILDE STAR AMPERSAND |
| // ELLIPSIS "throw" "using" TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" |
| // SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_94( |
| _tokenSet_94_data_, 12); |
| const unsigned long CPPParser::_tokenSet_95_data_[] = { |
| 262208UL, 2UL, 2147614720UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN ASSIGNEQUAL RPAREN COMMA ELLIPSIS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_95( |
| _tokenSet_95_data_, 8); |
| const unsigned long CPPParser::_tokenSet_96_data_[] = { |
| 64UL, 2UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN RPAREN COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_96( |
| _tokenSet_96_data_, 8); |
| const unsigned long CPPParser::_tokenSet_97_data_[] = { |
| 101582176UL, 3UL, 4259446784UL, 4293918721UL, 557055UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON "_stdcall" |
| // "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE |
| // RSQUARE TILDE STAR AMPERSAND ELLIPSIS "throw" TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR |
| // NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT |
| // PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" "__cdecl" "_near" |
| // "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_97( |
| _tokenSet_97_data_, 12); |
| const unsigned long CPPParser::_tokenSet_98_data_[] = { |
| 16777232UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "class" "typename" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_98( |
| _tokenSet_98_data_, 8); |
| const unsigned long CPPParser::_tokenSet_99_data_[] = { |
| 1120UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_99( |
| _tokenSet_99_data_, 8); |
| const unsigned long CPPParser::_tokenSet_100_data_[] = { |
| 4291835520UL, 4294967293UL, 4058054655UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND |
| // ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_100( |
| _tokenSet_100_data_, 12); |
| const unsigned long CPPParser::_tokenSet_101_data_[] = { |
| 64UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN COMMA |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_101( |
| _tokenSet_101_data_, 8); |
| const unsigned long CPPParser::_tokenSet_102_data_[] = { |
| 100664416UL, 1UL, 1677852672UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID "_stdcall" "__stdcall" LPAREN COMMA LSQUARE |
| // STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_102( |
| _tokenSet_102_data_, 12); |
| const unsigned long CPPParser::_tokenSet_103_data_[] = { |
| 1024UL, 4294963200UL, 4095UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" |
| // "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" |
| // "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" |
| // "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_103( |
| _tokenSet_103_data_, 12); |
| const unsigned long CPPParser::_tokenSet_104_data_[] = { |
| 100664416UL, 4294959105UL, 1677856767UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN ID "_stdcall" "__stdcall" LPAREN "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" COMMA LSQUARE STAR |
| // AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" |
| // "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_104( |
| _tokenSet_104_data_, 12); |
| const unsigned long CPPParser::_tokenSet_105_data_[] = { |
| 4291835616UL, 4294967293UL, 1677918207UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" "extern" |
| // "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" |
| // "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" COMMA LSQUARE |
| // STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_105( |
| _tokenSet_105_data_, 12); |
| const unsigned long CPPParser::_tokenSet_106_data_[] = { |
| 4294194912UL, 4294967293UL, 2011365375UL, 3220176896UL, |
| 4294967295UL, 16399UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL |
| // "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall" |
| // "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline" |
| // "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__" |
| // COMMA "operator" "this" "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND |
| // TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL OR AND |
| // BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO |
| // SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS |
| // MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_106( |
| _tokenSet_106_data_, 12); |
| const unsigned long CPPParser::_tokenSet_107_data_[] = { |
| 917856UL, 2UL, 3355574272UL, 4293918720UL, 127UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA |
| // RSQUARE AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_107( |
| _tokenSet_107_data_, 12); |
| const unsigned long CPPParser::_tokenSet_108_data_[] = { |
| 4291851904UL, 4294967292UL, 65535UL, 983042UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "namespace" "extern" "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" |
| // "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename" |
| // "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" |
| // "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "using" "asm" "_asm" "__asm" |
| // "__asm__" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_108( |
| _tokenSet_108_data_, 12); |
| const unsigned long CPPParser::_tokenSet_109_data_[] = { |
| 4291852192UL, 4294967293UL, 1910571007UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace" |
| // "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" |
| // "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" |
| // "GFARRAYELEMSIZE" |
| // "auto" "register" "static" "mutable" "_inline" "__inline" "virtual" |
| // "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" "operator" |
| // "this" "true" "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" |
| // "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_109( |
| _tokenSet_109_data_, 12); |
| const unsigned long CPPParser::_tokenSet_110_data_[] = { |
| 4294967280UL, 4294967293UL, 2013265919UL, 3221192703UL, |
| 4293910527UL, 32767UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY |
| // "inline" "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY |
| // ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "GFIGNORE" COMMA "public" "protected" "private" "operator" |
| // "this" "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND "throw" |
| // "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto" |
| // "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" TIMESEQUAL |
| // DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL |
| // BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR |
| // NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT |
| // PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" |
| // SCOPE POINTERTO "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" |
| // "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral |
| // FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" |
| // "__far" "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_110( |
| _tokenSet_110_data_, 12); |
| const unsigned long CPPParser::_tokenSet_111_data_[] = { |
| 1056UL, 0UL, 568389632UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN ID "const" "__const" "volatile" "__volatile__" "operator" "this" |
| // "true" "false" STAR SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_111( |
| _tokenSet_111_data_, 12); |
| const unsigned long CPPParser::_tokenSet_112_data_[] = { |
| 4294195168UL, 4294967293UL, 2011365375UL, 4293918720UL, |
| 4294967295UL, 16399UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" |
| // ASSIGNEQUAL "extern" StringLiteral "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE |
| // TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL |
| // SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| // QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR |
| // POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO |
| // "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_112( |
| _tokenSet_112_data_, 12); |
| const unsigned long CPPParser::_tokenSet_113_data_[] = { |
| 4294967282UL, 4294967293UL, 2013265919UL, 4294967295UL, |
| 4294967295UL, 32767UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // EOF "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY |
| // "inline" "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY |
| // ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" "GFIGNORE" COMMA "public" "protected" "private" "operator" |
| // "this" "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND "throw" |
| // "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto" |
| // "continue" "break" "return" "try" "catch" "asm" "_asm" "__asm" "__asm__" |
| // TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| // OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO |
| // SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS |
| // MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_113( |
| _tokenSet_113_data_, 12); |
| const unsigned long CPPParser::_tokenSet_114_data_[] = { |
| 4294180752UL, 4294967293UL, 1945960447UL, 1048575UL, 4291790336UL, 32767UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace" |
| // "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "public" "protected" "private" |
| // "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw" |
| // "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto" |
| // "continue" "break" "return" "try" "catch" "asm" "_asm" "__asm" "__asm__" |
| // PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" |
| // "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT |
| // HEXADECIMALINT |
| // CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_114( |
| _tokenSet_114_data_, 12); |
| const unsigned long CPPParser::_tokenSet_115_data_[] = { |
| 917824UL, 2UL, 2281832448UL, 1072693248UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_115( |
| _tokenSet_115_data_, 8); |
| const unsigned long CPPParser::_tokenSet_116_data_[] = { |
| 917824UL, 2UL, 2281832448UL, 2146435072UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_116( |
| _tokenSet_116_data_, 8); |
| const unsigned long CPPParser::_tokenSet_117_data_[] = { |
| 917824UL, 2UL, 2281832448UL, 4293918720UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| // OR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_117( |
| _tokenSet_117_data_, 8); |
| const unsigned long CPPParser::_tokenSet_118_data_[] = { |
| 917824UL, 2UL, 2281832448UL, 4293918720UL, 1UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| // OR AND |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_118( |
| _tokenSet_118_data_, 12); |
| const unsigned long CPPParser::_tokenSet_119_data_[] = { |
| 917824UL, 2UL, 2281832448UL, 4293918720UL, 3UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| // OR AND BITWISEOR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_119( |
| _tokenSet_119_data_, 12); |
| const unsigned long CPPParser::_tokenSet_120_data_[] = { |
| 917824UL, 2UL, 2281832448UL, 4293918720UL, 7UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| // OR AND BITWISEOR BITWISEXOR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_120( |
| _tokenSet_120_data_, 12); |
| const unsigned long CPPParser::_tokenSet_121_data_[] = { |
| 917824UL, 2UL, 3355574272UL, 4293918720UL, 7UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL |
| // SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| // QUESTIONMARK OR AND BITWISEOR BITWISEXOR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_121( |
| _tokenSet_121_data_, 12); |
| const unsigned long CPPParser::_tokenSet_122_data_[] = { |
| 96UL, 0UL, 0UL, 0UL, 96UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN LESSTHANOREQUALTO GREATERTHANOREQUALTO |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_122( |
| _tokenSet_122_data_, 12); |
| const unsigned long CPPParser::_tokenSet_123_data_[] = { |
| 917824UL, 2UL, 3355574272UL, 4293918720UL, 31UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE |
| // AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL |
| // SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| // QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_123( |
| _tokenSet_123_data_, 12); |
| const unsigned long CPPParser::_tokenSet_124_data_[] = { |
| 917856UL, 2UL, 3355574272UL, 4293918720UL, 511UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA |
| // RSQUARE AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_124( |
| _tokenSet_124_data_, 12); |
| const unsigned long CPPParser::_tokenSet_125_data_[] = { |
| 0UL, 0UL, 536870912UL, 0UL, 6144UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // STAR DIVIDE MOD |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_125( |
| _tokenSet_125_data_, 12); |
| const unsigned long CPPParser::_tokenSet_126_data_[] = { |
| 917856UL, 2UL, 3355574272UL, 4293918720UL, 2047UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA |
| // RSQUARE AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_126( |
| _tokenSet_126_data_, 12); |
| const unsigned long CPPParser::_tokenSet_127_data_[] = { |
| 917856UL, 2UL, 3892445184UL, 4293918720UL, 8191UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA |
| // RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_127( |
| _tokenSet_127_data_, 12); |
| const unsigned long CPPParser::_tokenSet_128_data_[] = { |
| 1024UL, 4294963200UL, 65535UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" |
| // "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" |
| // "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" |
| // "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" "const" "__const" "volatile" "__volatile__" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_128( |
| _tokenSet_128_data_, 12); |
| const unsigned long CPPParser::_tokenSet_129_data_[] = { |
| 917856UL, 2UL, 3892445184UL, 4293918720UL, 32767UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA |
| // RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL |
| // MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_129( |
| _tokenSet_129_data_, 12); |
| const unsigned long CPPParser::_tokenSet_130_data_[] = { |
| 2098176UL, 4294963201UL, 333451263UL, 0UL, 4291297280UL, 3UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID StringLiteral LPAREN "typename" "char" "wchar_t" "bool" "short" "int" |
| // "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" |
| // "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" |
| // "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double" |
| // "void" "_declspec" "__declspec" "operator" "this" "true" "false" OCTALINT |
| // TILDE SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" |
| // "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral |
| // FLOATONE FLOATTWO |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_130( |
| _tokenSet_130_data_, 12); |
| const unsigned long CPPParser::_tokenSet_131_data_[] = { |
| 3016032UL, 4294963203UL, 4293005311UL, 4293918720UL, 4294967295UL, 16399UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON StringLiteral |
| // LPAREN RPAREN "typename" "char" "wchar_t" "bool" "short" "int" "_int8" |
| // "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" |
| // "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" |
| // "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE |
| // RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" |
| // SCOPE DOT POINTERTO "dynamic_cast" "static_cast" "reinterpret_cast" |
| // "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral |
| // WStringLiteral FLOATONE FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_131( |
| _tokenSet_131_data_, 12); |
| const unsigned long CPPParser::_tokenSet_132_data_[] = { |
| 0UL, 0UL, 1879048192UL, 0UL, 1536UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // TILDE STAR AMPERSAND PLUS MINUS NOT |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_132( |
| _tokenSet_132_data_, 12); |
| const unsigned long CPPParser::_tokenSet_133_data_[] = { |
| 0UL, 0UL, 0UL, 0UL, 524288UL, 16392UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // SCOPE "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_133( |
| _tokenSet_133_data_, 12); |
| const unsigned long CPPParser::_tokenSet_134_data_[] = { |
| 4293932672UL, 4294967293UL, 2011234303UL, 0UL, 4291790336UL, 16399UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" StringLiteral "struct" |
| // "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" |
| // "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" "operator" "this" "true" |
| // "false" OCTALINT LSQUARE TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS |
| // "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" |
| // "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral |
| // WStringLiteral FLOATONE FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_134( |
| _tokenSet_134_data_, 12); |
| const unsigned long CPPParser::_tokenSet_135_data_[] = { |
| 4291835552UL, 4294967295UL, 1677787135UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" |
| // "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" |
| // "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit" |
| // "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" |
| // "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" |
| // "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" |
| // "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec" |
| // "const" "__const" "volatile" "__volatile__" LSQUARE STAR AMPERSAND SCOPE |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_135( |
| _tokenSet_135_data_, 12); |
| const unsigned long CPPParser::_tokenSet_136_data_[] = { |
| 4294194912UL, 4294967295UL, 2011365375UL, 4293918720UL, |
| 4294967295UL, 16399UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL |
| // "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall" |
| // "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN |
| // "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE |
| // TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL |
| // SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL |
| // QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR |
| // POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO |
| // "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_136( |
| _tokenSet_136_data_, 12); |
| const unsigned long CPPParser::_tokenSet_137_data_[] = { |
| 1056UL, 4294959105UL, 4095UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN ID LPAREN "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" |
| // "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" |
| // "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" |
| // "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec" |
| // "__declspec" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_137( |
| _tokenSet_137_data_, 12); |
| const unsigned long CPPParser::_tokenSet_138_data_[] = { |
| 2098176UL, 1UL, 333447168UL, 0UL, 4161273856UL, 3UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID StringLiteral LPAREN "operator" "this" "true" "false" OCTALINT TILDE |
| // SCOPE DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral |
| // FLOATONE FLOATTWO |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_138( |
| _tokenSet_138_data_, 12); |
| const unsigned long CPPParser::_tokenSet_139_data_[] = { |
| 4291835520UL, 4294967293UL, 65535UL, 0UL, 524288UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class" |
| // "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" |
| // "GFARRAYSIZE" |
| // LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" |
| // "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t" |
| // "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" SCOPE |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_139( |
| _tokenSet_139_data_, 12); |
| const unsigned long CPPParser::_tokenSet_140_data_[] = { |
| 4292753376UL, 4294967295UL, 3959619583UL, 4293918720UL, 557055UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" |
| // RCURLY ASSIGNEQUAL COLON "extern" "struct" "union" "class" "_stdcall" |
| // "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" |
| // LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" |
| // "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char" |
| // "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" |
| // "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" |
| // "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" |
| // "unsigned" "float" "double" "void" "_declspec" "__declspec" "const" |
| // "__const" "volatile" "__volatile__" COMMA LSQUARE RSQUARE STAR AMPERSAND |
| // ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL |
| // SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK |
| // OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO |
| // GREATERTHANOREQUALTO |
| // SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR SCOPE |
| // "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" |
| // "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_140( |
| _tokenSet_140_data_, 12); |
| const unsigned long CPPParser::_tokenSet_141_data_[] = { |
| 917856UL, 3UL, 3959554048UL, 4293918720UL, 3276799UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON LPAREN RPAREN |
| // COMMA LSQUARE RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL |
| // MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR |
| // NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT |
| // PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS DOT POINTERTO |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_141( |
| _tokenSet_141_data_, 12); |
| const unsigned long CPPParser::_tokenSet_142_data_[] = { |
| 100664320UL, 0UL, 1677721600UL, 0UL, 524288UL, 16368UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // ID "_stdcall" "__stdcall" LSQUARE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" |
| // "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_142( |
| _tokenSet_142_data_, 12); |
| const unsigned long CPPParser::_tokenSet_143_data_[] = { |
| 103679328UL, 4294963203UL, 4293066751UL, 4293918720UL, |
| 4291821567UL, 32767UL, 0UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON StringLiteral |
| // "_stdcall" "__stdcall" LPAREN RPAREN "typename" "char" "wchar_t" "bool" |
| // "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" |
| // "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" |
| // "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" |
| // "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile" |
| // "__volatile__" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE |
| // RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" |
| // SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid" |
| // DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE |
| // FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" |
| // "__interrupt" "pascal" "_pascal" "__pascal" "delete" |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_143( |
| _tokenSet_143_data_, 12); |
| const unsigned long CPPParser::_tokenSet_144_data_[] = { |
| 917856UL, 3UL, 3892445184UL, 4293918720UL, 32767UL, 0UL, |
| 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; |
| // LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON LPAREN RPAREN |
| // COMMA RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL |
| // PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL |
| // BITWISEXOREQUAL |
| // BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL |
| // LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS |
| // DIVIDE MOD DOTMBR POINTERTOMBR |
| const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_144( |
| _tokenSet_144_data_, 12); |