http://git-wip-us.apache.org/repos/asf/geode-native/blob/97ded703/contrib/pdxautoserializer/src/impl/CPPParser/CPPLexer.cpp ---------------------------------------------------------------------- diff --git a/contrib/pdxautoserializer/src/impl/CPPParser/CPPLexer.cpp b/contrib/pdxautoserializer/src/impl/CPPParser/CPPLexer.cpp new file mode 100644 index 0000000..2094032 --- /dev/null +++ b/contrib/pdxautoserializer/src/impl/CPPParser/CPPLexer.cpp @@ -0,0 +1,2832 @@ +/* + * 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" -> "CPPLexer.cpp"$ */ +#ifndef _WIN32 +#include <stdio.h> +#include <strings.h> +#endif +#include "CPPLexer.hpp" +#include <antlr/CharBuffer.hpp> +#include <antlr/TokenStreamException.hpp> +#include <antlr/TokenStreamIOException.hpp> +#include <antlr/TokenStreamRecognitionException.hpp> +#include <antlr/CharStreamException.hpp> +#include <antlr/CharStreamIOException.hpp> +#include <antlr/NoViableAltForCharException.hpp> + +#line 1 "CPP_parser.g" +#line 13 "CPPLexer.cpp" +CPPLexer::CPPLexer(ANTLR_USE_NAMESPACE(std) istream& in) + : ANTLR_USE_NAMESPACE(antlr) + CharScanner(new ANTLR_USE_NAMESPACE(antlr) CharBuffer(in), true) { + initLiterals(); +} + +CPPLexer::CPPLexer(ANTLR_USE_NAMESPACE(antlr) InputBuffer& ib) + : ANTLR_USE_NAMESPACE(antlr) CharScanner(ib, true) { + initLiterals(); +} + +CPPLexer::CPPLexer(const ANTLR_USE_NAMESPACE(antlr) + LexerSharedInputState& state) + : ANTLR_USE_NAMESPACE(antlr) CharScanner(state, true) { + initLiterals(); +} + +void CPPLexer::initLiterals() { + literals["_cdecl"] = 164; + literals["__stdcall"] = 26; + literals["extern"] = 20; + literals["public"] = 82; + literals["namespace"] = 14; + literals["case"] = 98; + literals["short"] = 48; + literals["break"] = 108; + literals["while"] = 103; + literals["__int8"] = 51; + literals["delete"] = 174; + literals["new"] = 163; + literals["__declspec"] = 75; + literals["uint32_t"] = 64; + literals["int16_t"] = 55; + literals["_int32"] = 56; + literals["GFID"] = 29; + literals["GFARRAYSIZE"] = 31; + literals["__pascal"] = 173; + literals["template"] = 4; + literals["GFEXCLUDE"] = 27; + literals["reinterpret_cast"] = 152; + literals["inline"] = 12; + literals["unsigned"] = 70; + literals["const"] = 76; + literals["float"] = 71; + literals["_int8"] = 50; + literals["__int16"] = 54; + literals["static_cast"] = 151; + literals["return"] = 109; + literals["throw"] = 96; + literals["int64_t"] = 61; + literals["typename"] = 44; + literals["using"] = 97; + literals["operator"] = 85; + literals["__far"] = 169; + literals["sizeof"] = 145; + literals["protected"] = 83; + literals["class"] = 24; + literals["_stdcall"] = 25; + literals["friend"] = 13; + literals["do"] = 104; + literals["__interrupt"] = 170; + literals["_far"] = 168; + literals["typeid"] = 154; + literals["__volatile__"] = 79; + literals["__alignof__"] = 146; + literals["__cdecl"] = 165; + literals["_int64"] = 59; + literals["__asm"] = 114; + literals["pascal"] = 171; + literals["typedef"] = 7; + literals["__const"] = 77; + literals["const_cast"] = 153; + literals["__asm__"] = 115; + literals["uint16_t"] = 63; + literals["explicit"] = 43; + literals["_asm"] = 113; + literals["if"] = 100; + literals["__int32"] = 57; + literals["double"] = 72; + literals["volatile"] = 78; + literals["catch"] = 111; + literals["dynamic_cast"] = 150; + literals["union"] = 23; + literals["try"] = 110; + literals["register"] = 37; + literals["_inline"] = 40; + literals["auto"] = 36; + literals["GFINCLUDE"] = 28; + literals["goto"] = 106; + literals["enum"] = 9; + literals["int"] = 49; + literals["for"] = 105; + literals["int32_t"] = 58; + literals["uint64_t"] = 65; + literals["char"] = 45; + literals["__near"] = 167; + literals["private"] = 84; + literals["GFARRAYELEMSIZE"] = 35; + literals["default"] = 99; + literals["false"] = 88; + literals["this"] = 86; + literals["static"] = 38; + literals["mutable"] = 39; + literals["int8_t"] = 52; + literals["GFARRAYSIZES"] = 34; + literals["uint8_t"] = 62; + literals["_int16"] = 53; + literals["continue"] = 107; + literals["bool"] = 47; + literals["struct"] = 22; + literals["GFUNREAD"] = 30; + literals["_near"] = 166; + literals["__int64"] = 60; + literals["signed"] = 69; + literals["GFIGNORE"] = 80; + literals["else"] = 101; + literals["_declspec"] = 74; + literals["_pascal"] = 172; + literals["__w64"] = 67; + literals["antlrTrace_on"] = 15; + literals["void"] = 73; + literals["antlrTrace_off"] = 16; + literals["wchar_t"] = 46; + literals["switch"] = 102; + literals["__inline"] = 41; + literals["true"] = 87; + literals["long"] = 68; + literals["asm"] = 112; + literals["virtual"] = 42; + literals["_w64"] = 66; +} + +ANTLR_USE_NAMESPACE(antlr) RefToken CPPLexer::nextToken() { + ANTLR_USE_NAMESPACE(antlr) RefToken theRetToken; + for (;;) { + ANTLR_USE_NAMESPACE(antlr) RefToken theRetToken; + int _ttype = ANTLR_USE_NAMESPACE(antlr) Token::INVALID_TYPE; + resetText(); + try { // for lexical and char stream error handling + switch (LA(1)) { + case 0x2c /* ',' */: { + mCOMMA(true); + theRetToken = _returnToken; + break; + } + case 0x3f /* '?' */: { + mQUESTIONMARK(true); + theRetToken = _returnToken; + break; + } + case 0x3b /* ';' */: { + mSEMICOLON(true); + theRetToken = _returnToken; + break; + } + case 0x28 /* '(' */: { + mLPAREN(true); + theRetToken = _returnToken; + break; + } + case 0x29 /* ')' */: { + mRPAREN(true); + theRetToken = _returnToken; + break; + } + case 0x5b /* '[' */: { + mLSQUARE(true); + theRetToken = _returnToken; + break; + } + case 0x5d /* ']' */: { + mRSQUARE(true); + theRetToken = _returnToken; + break; + } + case 0x7b /* '{' */: { + mLCURLY(true); + theRetToken = _returnToken; + break; + } + case 0x7d /* '}' */: { + mRCURLY(true); + theRetToken = _returnToken; + break; + } + case 0x7e /* '~' */: { + mTILDE(true); + theRetToken = _returnToken; + break; + } + case 0x9 /* '\t' */: + case 0xa /* '\n' */: + case 0xc /* '\14' */: + case 0xd /* '\r' */: + case 0x20 /* ' ' */: + case 0x5c /* '\\' */: { + mWhitespace(true); + theRetToken = _returnToken; + break; + } + case 0x23 /* '#' */: { + mPREPROC_DIRECTIVE(true); + theRetToken = _returnToken; + break; + } + case 0x22 /* '\"' */: { + mStringLiteral(true); + theRetToken = _returnToken; + break; + } + case 0x27 /* '\'' */: { + mCharLiteral(true); + theRetToken = _returnToken; + break; + } + default: + if ((LA(1) == 0x3e /* '>' */) && (LA(2) == 0x3e /* '>' */) && + (LA(3) == 0x3d /* '=' */)) { + mSHIFTRIGHTEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3c /* '<' */) && (LA(2) == 0x3c /* '<' */) && + (LA(3) == 0x3d /* '=' */)) { + mSHIFTLEFTEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2d /* '-' */) && (LA(2) == 0x3e /* '>' */) && + (LA(3) == 0x2a /* '*' */)) { + mPOINTERTOMBR(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2d /* '-' */) && (LA(2) == 0x3e /* '>' */) && + (true)) { + mPOINTERTO(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3d /* '=' */) && (LA(2) == 0x3d /* '=' */)) { + mEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x21 /* '!' */) && (LA(2) == 0x3d /* '=' */)) { + mNOTEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3c /* '<' */) && (LA(2) == 0x3d /* '=' */)) { + mLESSTHANOREQUALTO(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3e /* '>' */) && (LA(2) == 0x3d /* '=' */)) { + mGREATERTHANOREQUALTO(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2f /* '/' */) && (LA(2) == 0x3d /* '=' */)) { + mDIVIDEEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2b /* '+' */) && (LA(2) == 0x3d /* '=' */)) { + mPLUSEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2b /* '+' */) && (LA(2) == 0x2b /* '+' */)) { + mPLUSPLUS(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2d /* '-' */) && (LA(2) == 0x3d /* '=' */)) { + mMINUSEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2d /* '-' */) && (LA(2) == 0x2d /* '-' */)) { + mMINUSMINUS(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2a /* '*' */) && (LA(2) == 0x3d /* '=' */)) { + mTIMESEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x25 /* '%' */) && (LA(2) == 0x3d /* '=' */)) { + mMODEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3e /* '>' */) && (LA(2) == 0x3e /* '>' */) && + (true)) { + mSHIFTRIGHT(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3c /* '<' */) && (LA(2) == 0x3c /* '<' */) && + (true)) { + mSHIFTLEFT(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x26 /* '&' */) && (LA(2) == 0x26 /* '&' */)) { + mAND(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x7c /* '|' */) && (LA(2) == 0x7c /* '|' */)) { + mOR(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x26 /* '&' */) && (LA(2) == 0x3d /* '=' */)) { + mBITWISEANDEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x7c /* '|' */) && (LA(2) == 0x3d /* '=' */)) { + mBITWISEOREQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x5e /* '^' */) && (LA(2) == 0x3d /* '=' */)) { + mBITWISEXOREQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2e /* '.' */) && (LA(2) == 0x2a /* '*' */)) { + mDOTMBR(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3a /* ':' */) && (LA(2) == 0x3a /* ':' */)) { + mSCOPE(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2f /* '/' */) && (LA(2) == 0x2a /* '*' */)) { + mComment(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2f /* '/' */) && (LA(2) == 0x2f /* '/' */)) { + mCPPComment(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x4c /* 'L' */) && (LA(2) == 0x27 /* '\'' */)) { + mWCharLiteral(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x4c /* 'L' */) && (LA(2) == 0x22 /* '\"' */)) { + mWStringLiteral(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3d /* '=' */) && (true)) { + mASSIGNEQUAL(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3a /* ':' */) && (true)) { + mCOLON(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3c /* '<' */) && (true)) { + mLESSTHAN(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x3e /* '>' */) && (true)) { + mGREATERTHAN(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2f /* '/' */) && (true)) { + mDIVIDE(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2b /* '+' */) && (true)) { + mPLUS(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2d /* '-' */) && (true)) { + mMINUS(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x2a /* '*' */) && (true)) { + mSTAR(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x25 /* '%' */) && (true)) { + mMOD(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x21 /* '!' */) && (true)) { + mNOT(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x26 /* '&' */) && (true)) { + mAMPERSAND(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x7c /* '|' */) && (true)) { + mBITWISEOR(true); + theRetToken = _returnToken; + } else if ((LA(1) == 0x5e /* '^' */) && (true)) { + mBITWISEXOR(true); + theRetToken = _returnToken; + } else if ((_tokenSet_0.member(LA(1))) && (true)) { + mNumber(true); + theRetToken = _returnToken; + } else if ((_tokenSet_1.member(LA(1))) && (true)) { + mID(true); + theRetToken = _returnToken; + } else { + if (LA(1) == EOF_CHAR) { + uponEOF(); + _returnToken = + makeToken(ANTLR_USE_NAMESPACE(antlr) Token::EOF_TYPE); + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if (!_returnToken) goto tryAgain; // found SKIP token + + _ttype = _returnToken->getType(); + _ttype = testLiteralsTable(_ttype); + _returnToken->setType(_ttype); + return _returnToken; + } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& e) { + throw ANTLR_USE_NAMESPACE(antlr) TokenStreamRecognitionException(e); + } catch (ANTLR_USE_NAMESPACE(antlr) CharStreamIOException& csie) { + throw ANTLR_USE_NAMESPACE(antlr) TokenStreamIOException(csie.io); + } catch (ANTLR_USE_NAMESPACE(antlr) CharStreamException& cse) { + throw ANTLR_USE_NAMESPACE(antlr) TokenStreamException(cse.getMessage()); + } + tryAgain:; + } +} + +void CPPLexer::mASSIGNEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = ASSIGNEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('=' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mCOLON(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = COLON; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(':' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mCOMMA(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = COMMA; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(',' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mQUESTIONMARK(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = QUESTIONMARK; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('?' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSEMICOLON(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = SEMICOLON; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(';' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPOINTERTO(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = POINTERTO; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("->"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLPAREN(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LPAREN; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('(' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mRPAREN(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = RPAREN; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(')' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLSQUARE(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LSQUARE; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('[' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mRSQUARE(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = RSQUARE; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(']' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLCURLY(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LCURLY; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('{' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mRCURLY(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = RCURLY; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('}' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = EQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("=="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mNOTEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = NOTEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("!="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLESSTHANOREQUALTO(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LESSTHANOREQUALTO; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("<="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLESSTHAN(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LESSTHAN; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("<"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mGREATERTHANOREQUALTO(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = GREATERTHANOREQUALTO; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(">="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mGREATERTHAN(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = GREATERTHAN; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(">"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mDIVIDE(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = DIVIDE; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('/' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mDIVIDEEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = DIVIDEEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("/="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPLUS(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = PLUS; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('+' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPLUSEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = PLUSEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("+="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPLUSPLUS(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = PLUSPLUS; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("++"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mMINUS(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = MINUS; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('-' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mMINUSEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = MINUSEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("-="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mMINUSMINUS(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = MINUSMINUS; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("--"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSTAR(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = STAR; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('*' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mTIMESEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = TIMESEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("*="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mMOD(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = MOD; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('%' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mMODEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = MODEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("%="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSHIFTRIGHT(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = SHIFTRIGHT; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(">>"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSHIFTRIGHTEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = SHIFTRIGHTEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(">>="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSHIFTLEFT(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = SHIFTLEFT; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("<<"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSHIFTLEFTEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = SHIFTLEFTEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("<<="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mAND(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = AND; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("&&"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mNOT(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = NOT; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('!' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mOR(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = OR; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("||"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mAMPERSAND(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = AMPERSAND; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('&' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mBITWISEANDEQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = BITWISEANDEQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("&="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mTILDE(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = TILDE; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('~' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mBITWISEOR(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = BITWISEOR; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('|' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mBITWISEOREQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = BITWISEOREQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("|="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mBITWISEXOR(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = BITWISEXOR; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('^' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mBITWISEXOREQUAL(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = BITWISEXOREQUAL; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("^="); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPOINTERTOMBR(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = POINTERTOMBR; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("->*"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mDOTMBR(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = DOTMBR; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match(".*"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSCOPE(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = SCOPE; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("::"); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mWhitespace(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Whitespace; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + switch (LA(1)) { + case 0x9 /* '\t' */: + case 0xc /* '\14' */: + case 0x20 /* ' ' */: { + { + switch (LA(1)) { + case 0x20 /* ' ' */: { + match(' ' /* charlit */); + break; + } + case 0x9 /* '\t' */: { + match('\t' /* charlit */); + break; + } + case 0xc /* '\14' */: { + match('\14' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + break; + } + case 0xa /* '\n' */: + case 0xd /* '\r' */: { + { + if ((LA(1) == 0xd /* '\r' */) && (LA(2) == 0xa /* '\n' */)) { + match('\r' /* charlit */); + match('\n' /* charlit */); + } else if ((LA(1) == 0xd /* '\r' */) && (true)) { + match('\r' /* charlit */); + } else if ((LA(1) == 0xa /* '\n' */)) { + match('\n' /* charlit */); + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (inputState->guessing == 0) { +#line 2391 "CPP_parser.g" + newline(); +#line 1165 "CPPLexer.cpp" + } + break; + } + case 0x5c /* '\\' */: { + { + if ((LA(1) == 0x5c /* '\\' */) && (LA(2) == 0xd /* '\r' */) && + (LA(3) == 0xa /* '\n' */)) { + match('\\' /* charlit */); + match('\r' /* charlit */); + match('\n' /* charlit */); + } else if ((LA(1) == 0x5c /* '\\' */) && (LA(2) == 0xd /* '\r' */) && + (true)) { + match('\\' /* charlit */); + match('\r' /* charlit */); + } else if ((LA(1) == 0x5c /* '\\' */) && (LA(2) == 0xa /* '\n' */)) { + match('\\' /* charlit */); + match('\n' /* charlit */); + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (inputState->guessing == 0) { +#line 2396 "CPP_parser.g" + printf("CPP_parser.g continuation line detected\n"); + deferredNewline(); +#line 1194 "CPPLexer.cpp" + } + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if (inputState->guessing == 0) { +#line 2399 "CPP_parser.g" + _ttype = ANTLR_USE_NAMESPACE(antlr) Token::SKIP; +#line 1207 "CPPLexer.cpp" + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mComment(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Comment; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("/*"); + { // ( ... )* + for (;;) { + if (((LA(1) == 0x2a /* '*' */) && + ((LA(2) >= 0x0 /* '\0' */ && LA(2) <= 0xff)) && + ((LA(3) >= 0x0 /* '\0' */ && LA(3) <= 0xff))) && + (LA(2) != '/')) { + match('*' /* charlit */); + } else if ((LA(1) == 0xa /* '\n' */ || LA(1) == 0xd /* '\r' */)) { + mEndOfLine(false); + if (inputState->guessing == 0) { +#line 2406 "CPP_parser.g" + deferredNewline(); +#line 1233 "CPPLexer.cpp" + } + } else if ((_tokenSet_2.member(LA(1)))) { + { match(_tokenSet_2); } + } else { + goto _loop653; + } + } + _loop653:; + } // ( ... )* + match("*/"); + if (inputState->guessing == 0) { +#line 2409 "CPP_parser.g" + _ttype = ANTLR_USE_NAMESPACE(antlr) Token::SKIP; +#line 1252 "CPPLexer.cpp" + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mEndOfLine(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = EndOfLine; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + if ((LA(1) == 0xd /* '\r' */) && (LA(2) == 0xa /* '\n' */) && (true)) { + match("\r\n"); + } else if ((LA(1) == 0xd /* '\r' */) && (true) && (true)) { + match('\r' /* charlit */); + } else if ((LA(1) == 0xa /* '\n' */)) { + match('\n' /* charlit */); + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mCPPComment(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = CPPComment; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match("//"); + { // ( ... )* + for (;;) { + if ((_tokenSet_3.member(LA(1)))) { + { match(_tokenSet_3); } + } else { + goto _loop657; + } + } + _loop657:; + } // ( ... )* + mEndOfLine(false); + if (inputState->guessing == 0) { +#line 2415 "CPP_parser.g" + _ttype = ANTLR_USE_NAMESPACE(antlr) Token::SKIP; + newline(); +#line 1314 "CPPLexer.cpp" + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPREPROC_DIRECTIVE(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = PREPROC_DIRECTIVE; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + match('#' /* charlit */); + { // ( ... )* + for (;;) { + if ((_tokenSet_3.member(LA(1)))) { + { match(_tokenSet_3); } + } else { + goto _loop662; + } + } + _loop662:; + } // ( ... )* + mEndOfLine(false); + } + if (inputState->guessing == 0) { +#line 2422 "CPP_parser.g" + _ttype = ANTLR_USE_NAMESPACE(antlr) Token::SKIP; + newline(); +#line 1350 "CPPLexer.cpp" + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLineDirective(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LineDirective; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + ANTLR_USE_NAMESPACE(antlr) RefToken n; + ANTLR_USE_NAMESPACE(antlr) RefToken sl; + + { + switch (LA(1)) { + case 0x6c /* 'l' */: { + match("line"); + break; + } + case 0x9 /* '\t' */: + case 0xc /* '\14' */: + case 0x20 /* ' ' */: { + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )+ + int _cnt666 = 0; + for (;;) { + if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || + LA(1) == 0x20 /* ' ' */)) { + mSpace(false); + } else { + if (_cnt666 >= 1) { + goto _loop666; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt666++; + } + _loop666:; + } // ( ... )+ + mDecimal(true); + n = _returnToken; + { // ( ... )+ + int _cnt668 = 0; + for (;;) { + if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || + LA(1) == 0x20 /* ' ' */)) { + mSpace(false); + } else { + if (_cnt668 >= 1) { + goto _loop668; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt668++; + } + _loop668:; + } // ( ... )+ + { + mStringLiteral(true); + sl = _returnToken; + } + { // ( ... )* + for (;;) { + if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || + LA(1) == 0x20 /* ' ' */)) { + { // ( ... )+ + int _cnt672 = 0; + for (;;) { + if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || + LA(1) == 0x20 /* ' ' */)) { + mSpace(false); + } else { + if (_cnt672 >= 1) { + goto _loop672; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt672++; + } + _loop672:; + } // ( ... )+ + mDecimal(false); + } else { + goto _loop673; + } + } + _loop673:; + } // ( ... )* + if (inputState->guessing == 0) { +#line 2434 "CPP_parser.g" + + process_line_directive((sl->getText()).data(), + (n->getText()).data()); // see main() + +#line 1451 "CPPLexer.cpp" + } + mEndOfLine(false); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mSpace(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Space; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + switch (LA(1)) { + case 0x20 /* ' ' */: { + match(' ' /* charlit */); + break; + } + case 0x9 /* '\t' */: { + match('\t' /* charlit */); + break; + } + case 0xc /* '\14' */: { + match('\14' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mDecimal(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Decimal; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { // ( ... )+ + int _cnt710 = 0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + matchRange('0', '9'); + } else { + if (_cnt710 >= 1) { + goto _loop710; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt710++; + } + _loop710:; + } // ( ... )+ + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mStringLiteral(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = StringLiteral; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('\"' /* charlit */); + { // ( ... )* + for (;;) { + if ((LA(1) == 0x5c /* '\\' */) && (_tokenSet_4.member(LA(2)))) { + mEscape(false); + } else if ((LA(1) == 0x5c /* '\\' */) && + (LA(2) == 0xa /* '\n' */ || LA(2) == 0xd /* '\r' */)) { + { + if ((LA(1) == 0x5c /* '\\' */) && (LA(2) == 0xd /* '\r' */) && + (LA(3) == 0xa /* '\n' */)) { + match("\\\r\n"); + } else if ((LA(1) == 0x5c /* '\\' */) && (LA(2) == 0xd /* '\r' */) && + (_tokenSet_3.member(LA(3)))) { + match("\\\r"); + } else if ((LA(1) == 0x5c /* '\\' */) && (LA(2) == 0xa /* '\n' */)) { + match("\\\n"); + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (inputState->guessing == 0) { +#line 2496 "CPP_parser.g" + deferredNewline(); +#line 1555 "CPPLexer.cpp" + } + } else if ((_tokenSet_5.member(LA(1)))) { + { match(_tokenSet_5); } + } else { + goto _loop694; + } + } + _loop694:; + } // ( ... )* + match('\"' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mPragma(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Pragma; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + match('#' /* charlit */); + match("pragma"); + { // ( ... )* + for (;;) { + if ((_tokenSet_3.member(LA(1)))) { + { match(_tokenSet_3); } + } else { + goto _loop680; + } + } + _loop680:; + } // ( ... )* + mEndOfLine(false); + } + if (inputState->guessing == 0) { +#line 2451 "CPP_parser.g" + _ttype = ANTLR_USE_NAMESPACE(antlr) Token::SKIP; + newline(); +#line 1606 "CPPLexer.cpp" + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mError(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Error; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + match('#' /* charlit */); + match("error"); + { // ( ... )* + for (;;) { + if ((_tokenSet_3.member(LA(1)))) { + { match(_tokenSet_3); } + } else { + goto _loop685; + } + } + _loop685:; + } // ( ... )* + mEndOfLine(false); + } + if (inputState->guessing == 0) { +#line 2458 "CPP_parser.g" + _ttype = ANTLR_USE_NAMESPACE(antlr) Token::SKIP; + newline(); +#line 1643 "CPPLexer.cpp" + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mCharLiteral(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = CharLiteral; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('\'' /* charlit */); + { + if ((LA(1) == 0x5c /* '\\' */) && (_tokenSet_4.member(LA(2))) && + (_tokenSet_6.member(LA(3)))) { + mEscape(false); + } else if ((_tokenSet_7.member(LA(1))) && (LA(2) == 0x27 /* '\'' */) && + (true)) { + { match(_tokenSet_7); } + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + match('\'' /* charlit */); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mEscape(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Escape; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('\\' /* charlit */); + { + switch (LA(1)) { + case 0x61 /* 'a' */: { + match('a' /* charlit */); + break; + } + case 0x62 /* 'b' */: { + match('b' /* charlit */); + break; + } + case 0x66 /* 'f' */: { + match('f' /* charlit */); + break; + } + case 0x6e /* 'n' */: { + match('n' /* charlit */); + break; + } + case 0x72 /* 'r' */: { + match('r' /* charlit */); + break; + } + case 0x74 /* 't' */: { + match('t' /* charlit */); + break; + } + case 0x76 /* 'v' */: { + match('v' /* charlit */); + break; + } + case 0x22 /* '\"' */: { + match('\"' /* charlit */); + break; + } + case 0x27 /* '\'' */: { + match('\'' /* charlit */); + break; + } + case 0x5c /* '\\' */: { + match('\\' /* charlit */); + break; + } + case 0x3f /* '?' */: { + match('?' /* charlit */); + break; + } + case 0x30 /* '0' */: + case 0x31 /* '1' */: + case 0x32 /* '2' */: + case 0x33 /* '3' */: { + { matchRange('0', '3'); } + { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */)) && + (_tokenSet_3.member(LA(2))) && (true)) { + mDigit(false); + { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */)) && + (_tokenSet_3.member(LA(2))) && (true)) { + mDigit(false); + } else if ((_tokenSet_3.member(LA(1))) && (true) && (true)) { + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } else if ((_tokenSet_3.member(LA(1))) && (true) && (true)) { + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + break; + } + case 0x34 /* '4' */: + case 0x35 /* '5' */: + case 0x36 /* '6' */: + case 0x37 /* '7' */: { + { matchRange('4', '7'); } + { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */)) && + (_tokenSet_3.member(LA(2))) && (true)) { + mDigit(false); + } else if ((_tokenSet_3.member(LA(1))) && (true) && (true)) { + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + break; + } + case 0x78 /* 'x' */: { + match('x' /* charlit */); + { // ( ... )+ + int _cnt706 = 0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */)) && + (_tokenSet_3.member(LA(2))) && (true)) { + mDigit(false); + } else if (((LA(1) >= 0x61 /* 'a' */ && LA(1) <= 0x66 /* 'f' */)) && + (_tokenSet_3.member(LA(2))) && (true)) { + matchRange('a', 'f'); + } else if (((LA(1) >= 0x41 /* 'A' */ && LA(1) <= 0x46 /* 'F' */)) && + (_tokenSet_3.member(LA(2))) && (true)) { + matchRange('A', 'F'); + } else { + if (_cnt706 >= 1) { + goto _loop706; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt706++; + } + _loop706:; + } // ( ... )+ + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mWCharLiteral(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = WCharLiteral; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('L' /* charlit */); + mCharLiteral(false); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mWStringLiteral(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = WStringLiteral; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + match('L' /* charlit */); + mStringLiteral(false); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mDigit(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Digit; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + matchRange('0', '9'); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mLongSuffix(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = LongSuffix; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + switch (LA(1)) { + case 0x6c /* 'l' */: { + match('l' /* charlit */); + break; + } + case 0x4c /* 'L' */: { + match('L' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mUnsignedSuffix(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = UnsignedSuffix; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + switch (LA(1)) { + case 0x75 /* 'u' */: { + match('u' /* charlit */); + break; + } + case 0x55 /* 'U' */: { + match('U' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mFloatSuffix(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = FloatSuffix; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + switch (LA(1)) { + case 0x66 /* 'f' */: { + match('f' /* charlit */); + break; + } + case 0x46 /* 'F' */: { + match('F' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mExponent(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Exponent; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + switch (LA(1)) { + case 0x65 /* 'e' */: { + match('e' /* charlit */); + break; + } + case 0x45 /* 'E' */: { + match('E' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + switch (LA(1)) { + case 0x2b /* '+' */: { + match('+' /* charlit */); + break; + } + case 0x2d /* '-' */: { + match('-' /* charlit */); + break; + } + case 0x30 /* '0' */: + case 0x31 /* '1' */: + case 0x32 /* '2' */: + case 0x33 /* '3' */: + case 0x34 /* '4' */: + case 0x35 /* '5' */: + case 0x36 /* '6' */: + case 0x37 /* '7' */: + case 0x38 /* '8' */: + case 0x39 /* '9' */: { + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )+ + int _cnt718 = 0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + mDigit(false); + } else { + if (_cnt718 >= 1) { + goto _loop718; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt718++; + } + _loop718:; + } // ( ... )+ + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mVocabulary(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Vocabulary; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + matchRange('\3', static_cast<unsigned char>('\377')); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mNumber(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = Number; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + bool synPredMatched725 = false; + if ((((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */)) && + (_tokenSet_8.member(LA(2))) && (true))) { + int _m725 = mark(); + synPredMatched725 = true; + inputState->guessing++; + try { + { + { // ( ... )+ + int _cnt723 = 0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + mDigit(false); + } else { + if (_cnt723 >= 1) { + goto _loop723; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt723++; + } + _loop723:; + } // ( ... )+ + { + switch (LA(1)) { + case 0x2e /* '.' */: { + match('.' /* charlit */); + break; + } + case 0x65 /* 'e' */: { + match('e' /* charlit */); + break; + } + case 0x45 /* 'E' */: { + match('E' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + } + } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { + synPredMatched725 = false; + } + rewind(_m725); + inputState->guessing--; + } + if (synPredMatched725) { + { // ( ... )+ + int _cnt727 = 0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + mDigit(false); + } else { + if (_cnt727 >= 1) { + goto _loop727; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt727++; + } + _loop727:; + } // ( ... )+ + { + switch (LA(1)) { + case 0x2e /* '.' */: { + match('.' /* charlit */); + { // ( ... )* + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + mDigit(false); + } else { + goto _loop730; + } + } + _loop730:; + } // ( ... )* + { + if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */)) { + mExponent(false); + } else { + } + } + if (inputState->guessing == 0) { +#line 2606 "CPP_parser.g" + _ttype = FLOATONE; +#line 2158 "CPPLexer.cpp" + } + break; + } + case 0x45 /* 'E' */: + case 0x65 /* 'e' */: { + mExponent(false); + if (inputState->guessing == 0) { +#line 2607 "CPP_parser.g" + _ttype = FLOATTWO; +#line 2169 "CPPLexer.cpp" + } + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + switch (LA(1)) { + case 0x46 /* 'F' */: + case 0x66 /* 'f' */: { + mFloatSuffix(false); + break; + } + case 0x4c /* 'L' */: + case 0x6c /* 'l' */: { + mLongSuffix(false); + break; + } + default: {} + } + } + } else { + bool synPredMatched734 = false; + if (((LA(1) == 0x2e /* '.' */) && (LA(2) == 0x2e /* '.' */))) { + int _m734 = mark(); + synPredMatched734 = true; + inputState->guessing++; + try { + { match("..."); } + } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) { + synPredMatched734 = false; + } + rewind(_m734); + inputState->guessing--; + } + if (synPredMatched734) { + match("..."); + if (inputState->guessing == 0) { +#line 2613 "CPP_parser.g" + _ttype = ELLIPSIS; +#line 2221 "CPPLexer.cpp" + } + } else if ((LA(1) == 0x30 /* '0' */) && + (LA(2) == 0x58 /* 'X' */ || LA(2) == 0x78 /* 'x' */)) { + match('0' /* charlit */); + { + switch (LA(1)) { + case 0x78 /* 'x' */: { + match('x' /* charlit */); + break; + } + case 0x58 /* 'X' */: { + match('X' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )+ + int _cnt750 = 0; + for (;;) { + switch (LA(1)) { + case 0x61 /* 'a' */: + case 0x62 /* 'b' */: + case 0x63 /* 'c' */: + case 0x64 /* 'd' */: + case 0x65 /* 'e' */: + case 0x66 /* 'f' */: { + matchRange('a', 'f'); + break; + } + case 0x41 /* 'A' */: + case 0x42 /* 'B' */: + case 0x43 /* 'C' */: + case 0x44 /* 'D' */: + case 0x45 /* 'E' */: + case 0x46 /* 'F' */: { + matchRange('A', 'F'); + break; + } + case 0x30 /* '0' */: + case 0x31 /* '1' */: + case 0x32 /* '2' */: + case 0x33 /* '3' */: + case 0x34 /* '4' */: + case 0x35 /* '5' */: + case 0x36 /* '6' */: + case 0x37 /* '7' */: + case 0x38 /* '8' */: + case 0x39 /* '9' */: { + mDigit(false); + break; + } + default: { + if (_cnt750 >= 1) { + goto _loop750; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + _cnt750++; + } + _loop750:; + } // ( ... )+ + { // ( ... )* + for (;;) { + switch (LA(1)) { + case 0x4c /* 'L' */: + case 0x6c /* 'l' */: { + mLongSuffix(false); + break; + } + case 0x55 /* 'U' */: + case 0x75 /* 'u' */: { + mUnsignedSuffix(false); + break; + } + default: { goto _loop752; } + } + } + _loop752:; + } // ( ... )* + if (inputState->guessing == 0) { +#line 2637 "CPP_parser.g" + _ttype = HEXADECIMALINT; +#line 2317 "CPPLexer.cpp" + } + } else if ((LA(1) == 0x2e /* '.' */) && (true)) { + match('.' /* charlit */); + if (inputState->guessing == 0) { +#line 2615 "CPP_parser.g" + _ttype = DOT; +#line 2325 "CPPLexer.cpp" + } + { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + { // ( ... )+ + int _cnt737 = 0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + mDigit(false); + } else { + if (_cnt737 >= 1) { + goto _loop737; + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + + _cnt737++; + } + _loop737:; + } // ( ... )+ + { + if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */)) { + mExponent(false); + } else { + } + } + if (inputState->guessing == 0) { +#line 2616 "CPP_parser.g" + _ttype = FLOATONE; +#line 2354 "CPPLexer.cpp" + } + { + switch (LA(1)) { + case 0x46 /* 'F' */: + case 0x66 /* 'f' */: { + mFloatSuffix(false); + break; + } + case 0x4c /* 'L' */: + case 0x6c /* 'l' */: { + mLongSuffix(false); + break; + } + default: {} + } + } + } else { + } + } + } else if ((LA(1) == 0x30 /* '0' */) && (true) && (true)) { + match('0' /* charlit */); + { // ( ... )* + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */))) { + matchRange('0', '7'); + } else { + goto _loop741; + } + } + _loop741:; + } // ( ... )* + { // ( ... )* + for (;;) { + switch (LA(1)) { + case 0x4c /* 'L' */: + case 0x6c /* 'l' */: { + mLongSuffix(false); + break; + } + case 0x55 /* 'U' */: + case 0x75 /* 'u' */: { + mUnsignedSuffix(false); + break; + } + default: { goto _loop743; } + } + } + _loop743:; + } // ( ... )* + if (inputState->guessing == 0) { +#line 2626 "CPP_parser.g" + _ttype = OCTALINT; +#line 2421 "CPPLexer.cpp" + } + } else if (((LA(1) >= 0x31 /* '1' */ && LA(1) <= 0x39 /* '9' */)) && + (true) && (true)) { + matchRange('1', '9'); + { // ( ... )* + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */))) { + mDigit(false); + } else { + goto _loop745; + } + } + _loop745:; + } // ( ... )* + { // ( ... )* + for (;;) { + switch (LA(1)) { + case 0x4c /* 'L' */: + case 0x6c /* 'l' */: { + mLongSuffix(false); + break; + } + case 0x55 /* 'U' */: + case 0x75 /* 'u' */: { + mUnsignedSuffix(false); + break; + } + default: { goto _loop747; } + } + } + _loop747:; + } // ( ... )* + if (inputState->guessing == 0) { +#line 2631 "CPP_parser.g" + _ttype = DECIMALINT; +#line 2464 "CPPLexer.cpp" + } + } else { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +void CPPLexer::mID(bool _createToken) { + int _ttype; + ANTLR_USE_NAMESPACE(antlr) RefToken _token; + ANTLR_USE_NAMESPACE(std) string::size_type _begin = text.length(); + _ttype = ID; + ANTLR_USE_NAMESPACE(std) string::size_type _saveIndex; + + { + switch (LA(1)) { + case 0x61 /* 'a' */: + case 0x62 /* 'b' */: + case 0x63 /* 'c' */: + case 0x64 /* 'd' */: + case 0x65 /* 'e' */: + case 0x66 /* 'f' */: + case 0x67 /* 'g' */: + case 0x68 /* 'h' */: + case 0x69 /* 'i' */: + case 0x6a /* 'j' */: + case 0x6b /* 'k' */: + case 0x6c /* 'l' */: + case 0x6d /* 'm' */: + case 0x6e /* 'n' */: + case 0x6f /* 'o' */: + case 0x70 /* 'p' */: + case 0x71 /* 'q' */: + case 0x72 /* 'r' */: + case 0x73 /* 's' */: + case 0x74 /* 't' */: + case 0x75 /* 'u' */: + case 0x76 /* 'v' */: + case 0x77 /* 'w' */: + case 0x78 /* 'x' */: + case 0x79 /* 'y' */: + case 0x7a /* 'z' */: { + matchRange('a', 'z'); + break; + } + case 0x41 /* 'A' */: + case 0x42 /* 'B' */: + case 0x43 /* 'C' */: + case 0x44 /* 'D' */: + case 0x45 /* 'E' */: + case 0x46 /* 'F' */: + case 0x47 /* 'G' */: + case 0x48 /* 'H' */: + case 0x49 /* 'I' */: + case 0x4a /* 'J' */: + case 0x4b /* 'K' */: + case 0x4c /* 'L' */: + case 0x4d /* 'M' */: + case 0x4e /* 'N' */: + case 0x4f /* 'O' */: + case 0x50 /* 'P' */: + case 0x51 /* 'Q' */: + case 0x52 /* 'R' */: + case 0x53 /* 'S' */: + case 0x54 /* 'T' */: + case 0x55 /* 'U' */: + case 0x56 /* 'V' */: + case 0x57 /* 'W' */: + case 0x58 /* 'X' */: + case 0x59 /* 'Y' */: + case 0x5a /* 'Z' */: { + matchRange('A', 'Z'); + break; + } + case 0x5f /* '_' */: { + match('_' /* charlit */); + break; + } + default: { + throw ANTLR_USE_NAMESPACE(antlr) NoViableAltForCharException( + LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )* + for (;;) { + switch (LA(1)) { + case 0x61 /* 'a' */: + case 0x62 /* 'b' */: + case 0x63 /* 'c' */: + case 0x64 /* 'd' */: + case 0x65 /* 'e' */: + case 0x66 /* 'f' */: + case 0x67 /* 'g' */: + case 0x68 /* 'h' */: + case 0x69 /* 'i' */: + case 0x6a /* 'j' */: + case 0x6b /* 'k' */: + case 0x6c /* 'l' */: + case 0x6d /* 'm' */: + case 0x6e /* 'n' */: + case 0x6f /* 'o' */: + case 0x70 /* 'p' */: + case 0x71 /* 'q' */: + case 0x72 /* 'r' */: + case 0x73 /* 's' */: + case 0x74 /* 't' */: + case 0x75 /* 'u' */: + case 0x76 /* 'v' */: + case 0x77 /* 'w' */: + case 0x78 /* 'x' */: + case 0x79 /* 'y' */: + case 0x7a /* 'z' */: { + matchRange('a', 'z'); + break; + } + case 0x41 /* 'A' */: + case 0x42 /* 'B' */: + case 0x43 /* 'C' */: + case 0x44 /* 'D' */: + case 0x45 /* 'E' */: + case 0x46 /* 'F' */: + case 0x47 /* 'G' */: + case 0x48 /* 'H' */: + case 0x49 /* 'I' */: + case 0x4a /* 'J' */: + case 0x4b /* 'K' */: + case 0x4c /* 'L' */: + case 0x4d /* 'M' */: + case 0x4e /* 'N' */: + case 0x4f /* 'O' */: + case 0x50 /* 'P' */: + case 0x51 /* 'Q' */: + case 0x52 /* 'R' */: + case 0x53 /* 'S' */: + case 0x54 /* 'T' */: + case 0x55 /* 'U' */: + case 0x56 /* 'V' */: + case 0x57 /* 'W' */: + case 0x58 /* 'X' */: + case 0x59 /* 'Y' */: + case 0x5a /* 'Z' */: { + matchRange('A', 'Z'); + break; + } + case 0x5f /* '_' */: { + match('_' /* charlit */); + break; + } + case 0x30 /* '0' */: + case 0x31 /* '1' */: + case 0x32 /* '2' */: + case 0x33 /* '3' */: + case 0x34 /* '4' */: + case 0x35 /* '5' */: + case 0x36 /* '6' */: + case 0x37 /* '7' */: + case 0x38 /* '8' */: + case 0x39 /* '9' */: { + matchRange('0', '9'); + break; + } + default: { goto _loop756; } + } + } + _loop756:; + } // ( ... )* + _ttype = testLiteralsTable(_ttype); + if (_createToken && _token == ANTLR_USE_NAMESPACE(antlr) nullToken && + _ttype != ANTLR_USE_NAMESPACE(antlr) Token::SKIP) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length() - _begin)); + } + _returnToken = _token; + _saveIndex = 0; +} + +const unsigned long CPPLexer::_tokenSet_0_data_[] = { + 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; +// . 0 1 2 3 4 5 6 7 8 9 +const ANTLR_USE_NAMESPACE(antlr) BitSet CPPLexer::_tokenSet_0(_tokenSet_0_data_, + 10); +const unsigned long CPPLexer::_tokenSet_1_data_[] = { + 0UL, 0UL, 2281701374UL, 134217726UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}; +// A B C D E F G H I J K L M N O P Q R S T U V W X Y Z _ a b c d e f g +// h i j k l m n o p q r s t u v w x y z +const ANTLR_USE_NAMESPACE(antlr) BitSet CPPLexer::_tokenSet_1(_tokenSet_1_data_, + 10); +const unsigned long CPPLexer::_tokenSet_2_data_[] = { + 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, + 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, + 0UL, 0UL, 0UL, 0UL, + 0UL, 0UL, 0UL, 0UL}; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 +// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! +// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C +// D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c d +// e f g h i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 +// 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 +// 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 0x9d 0x9e +// 0x9f 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 0xab 0xac +// 0xad 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 0xb9 0xba +// 0xbb 0xbc 0xbd 0xbe 0xbf 0xc0 +const ANTLR_USE_NAMESPACE(antlr) BitSet CPPLexer::_tokenSet_2(_tokenSet_2_data_, + 16); +const unsigned long CPPLexer::_tokenSet_3_data_[] =
<TRUNCATED>
