http://git-wip-us.apache.org/repos/asf/geode-native/blob/97ded703/contrib/pdxautoserializer/src/impl/CPPParser/CPPParser.cpp ---------------------------------------------------------------------- diff --git a/contrib/pdxautoserializer/src/impl/CPPParser/CPPParser.cpp b/contrib/pdxautoserializer/src/impl/CPPParser/CPPParser.cpp new file mode 100644 index 0000000..f0278ce --- /dev/null +++ b/contrib/pdxautoserializer/src/impl/CPPParser/CPPParser.cpp @@ -0,0 +1,14278 @@ +/* + * 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); +
<TRUNCATED>
