- Main Page
- Namespaces
- Classes
- Files
- Related Pages

# /Users/fpy/titan-1-5-MBARI/Mers/Solvers/SAT/GATSAT/TestSuiteLexer.cpp

    00001 /* $ANTLR 2.7.5 (20050128): "TestSuite.g" -> "TestSuiteLexer.cpp"$ */
    00002 #include "TestSuiteLexer.hpp"
    00003 #include <antlr/CharBuffer.hpp>
    00004 #include <antlr/TokenStreamException.hpp>
    00005 #include <antlr/TokenStreamIOException.hpp>
    00006 #include <antlr/TokenStreamRecognitionException.hpp>
    00007 #include <antlr/CharStreamException.hpp>
    00008 #include <antlr/CharStreamIOException.hpp>
    00009 #include <antlr/NoViableAltForCharException.hpp>
    00010
    00011 #line 47 "TestSuite.g"
    00012
    00014
    00015 #include <Mers/Models/Base/BaseModel.h>
    00016 #include <Mers/Models/Base/BaseModelValue.h>
    00017 #include <Mers/Models/Base/BaseModelValueArray.h>
    00018 #include <Mers/Models/Base/BaseModelVariable.h>
    00019 #include <Mers/Models/Base/BaseModelVariableArray.h>
    00020 #include <Mers/Models/Base/BaseModelSentence.h>
    00021 #include <Mers/Models/Base/BaseModelClause.h>
    00022 #include <Mers/Models/Base/BaseModelAssignment.h>
    00023 #include <Mers/Utils/Containers/IntegerArray.h>
    00024 #include <Mers/Solvers/SAT/GATSAT/GatsatFactory.h>
    00025 #include <Mers/Solvers/SAT/GATSAT/NUGatsatFactory.h>
    00026 #include <Mers/Solvers/SAT/GATSAT/GATSAT.h>
    00027 #include <Mers/Solvers/SAT/AssignmentTesterInterface.h>
    00028 #include <Mers/Generators/AssignmentGeneratorInterface.h>
    00029
    00031
    00032 using Mers::Solvers::SAT::GATSAT::GatsatFactory;
    00033 using Mers::Solvers::SAT::GATSAT::GATSAT;
    00034 using Mers::Solvers::SAT::GATSAT::NUGatsatFactory;
    00035 using Mers::Solvers::SAT::AssignmentTesterInterface;
    00036 using Mers::Generators::AssignmentGeneratorInterface;
    00037 using Mers::Models::Base::BaseModel;
    00038 using Mers::Models::Base::BaseModelValue;
    00039 using Mers::Models::Base::BaseModelValueArray;
    00040 using Mers::Models::Base::BaseModelVariable;
    00041 using Mers::Models::Base::BaseModelVariableArray;
    00042 using Mers::Models::Base::BaseModelSentence;
    00043 using Mers::Models::Base::BaseModelClause;
    00044 using Mers::Models::Base::BaseModelClauseArray;
    00045 using Mers::Models::Base::BaseModelAssignment;
    00046 using Mers::Utils::Containers::IntegerArray;
    00047 using std::vector;
    00048 using std::string;
    00049 using std::cerr;
    00050 using std::cout;
    00051 using std::endl;
    00052
    00054
    00055 // Extract the characters from the object that ANTLR uses.
    00056 #define CHARS_OF(T) ((T)->getText().c_str())
    00057
    00059
    00060 #line 61 "TestSuiteLexer.cpp"
    00061 ANTLR_BEGIN_NAMESPACE(Mers)
    00062 ANTLR_BEGIN_NAMESPACE(Solvers)
    00063 ANTLR_BEGIN_NAMESPACE(SAT)
    00064 ANTLR_BEGIN_NAMESPACE(GATSAT)
    00065 #line 1 "TestSuite.g"
    00066 #line 63 "TestSuiteLexer.cpp"
    00067 TestSuiteLexer::TestSuiteLexer(ANTLR_USE_NAMESPACE(std)istream& in)
    00068         : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true)
    00069 {
    00070         initLiterals();
    00071 }
    00072
    00073 TestSuiteLexer::TestSuiteLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
    00074         : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
    00075 {
    00076         initLiterals();
    00077 }
    00078
    00079 TestSuiteLexer::TestSuiteLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
    00080         : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true)
    00081 {
    00082         initLiterals();
    00083 }
    00084
    00085 void TestSuiteLexer::initLiterals()
    00086 {
    00087         literals["NonSearch"] = 8;
    00088         literals["Search"] = 7;
    00089         literals["Constraints"] = 9;
    00090 }
    00091
    00092 ANTLR_USE_NAMESPACE(antlr)RefToken TestSuiteLexer::nextToken()
    00093 {
    00094         ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
    00095         for (;;) {
    00096                 ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
    00097                 int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
    00098                 resetText();
    00099                 try {   // for lexical and char stream error handling
    00100                         switch ( LA(1)) {
    00101                         case 0x5b /* '[' */ :
    00102                         {
    00103                                 mLBRACKET(true);
    00104                                 theRetToken=_returnToken;
    00105                                 break;
    00106                         }
    00107                         case 0x5d /* ']' */ :
    00108                         {
    00109                                 mRBRACKET(true);
    00110                                 theRetToken=_returnToken;
    00111                                 break;
    00112                         }
    00113                         case 0x3d /* '=' */ :
    00114                         {
    00115                                 mEQUALS(true);
    00116                                 theRetToken=_returnToken;
    00117                                 break;
    00118                         }
    00119                         case 0x21 /* '!' */ :
    00120                         {
    00121                                 mNOT(true);
    00122                                 theRetToken=_returnToken;
    00123                                 break;
    00124                         }
    00125                         case 0x2e /* '.' */ :
    00126                         case 0x30 /* '0' */ :
    00127                         case 0x31 /* '1' */ :
    00128                         case 0x32 /* '2' */ :
    00129                         case 0x33 /* '3' */ :
    00130                         case 0x34 /* '4' */ :
    00131                         case 0x35 /* '5' */ :
    00132                         case 0x36 /* '6' */ :
    00133                         case 0x37 /* '7' */ :
    00134                         case 0x38 /* '8' */ :
    00135                         case 0x39 /* '9' */ :
    00136                         {
    00137                                 mFLOAT(true);
    00138                                 theRetToken=_returnToken;
    00139                                 break;
    00140                         }
    00141                         case 0x41 /* 'A' */ :
    00142                         case 0x42 /* 'B' */ :
    00143                         case 0x43 /* 'C' */ :
    00144                         case 0x44 /* 'D' */ :
    00145                         case 0x45 /* 'E' */ :
    00146                         case 0x46 /* 'F' */ :
    00147                         case 0x47 /* 'G' */ :
    00148                         case 0x48 /* 'H' */ :
    00149                         case 0x49 /* 'I' */ :
    00150                         case 0x4a /* 'J' */ :
    00151                         case 0x4b /* 'K' */ :
    00152                         case 0x4c /* 'L' */ :
    00153                         case 0x4d /* 'M' */ :
    00154                         case 0x4e /* 'N' */ :
    00155                         case 0x4f /* 'O' */ :
    00156                         case 0x50 /* 'P' */ :
    00157                         case 0x51 /* 'Q' */ :
    00158                         case 0x52 /* 'R' */ :
    00159                         case 0x53 /* 'S' */ :
    00160                         case 0x54 /* 'T' */ :
    00161                         case 0x55 /* 'U' */ :
    00162                         case 0x56 /* 'V' */ :
    00163                         case 0x57 /* 'W' */ :
    00164                         case 0x58 /* 'X' */ :
    00165                         case 0x59 /* 'Y' */ :
    00166                         case 0x5a /* 'Z' */ :
    00167                         case 0x5f /* '_' */ :
    00168                         case 0x61 /* 'a' */ :
    00169                         case 0x62 /* 'b' */ :
    00170                         case 0x63 /* 'c' */ :
    00171                         case 0x64 /* 'd' */ :
    00172                         case 0x65 /* 'e' */ :
    00173                         case 0x66 /* 'f' */ :
    00174                         case 0x67 /* 'g' */ :
    00175                         case 0x68 /* 'h' */ :
    00176                         case 0x69 /* 'i' */ :
    00177                         case 0x6a /* 'j' */ :
    00178                         case 0x6b /* 'k' */ :
    00179                         case 0x6c /* 'l' */ :
    00180                         case 0x6d /* 'm' */ :
    00181                         case 0x6e /* 'n' */ :
    00182                         case 0x6f /* 'o' */ :
    00183                         case 0x70 /* 'p' */ :
    00184                         case 0x71 /* 'q' */ :
    00185                         case 0x72 /* 'r' */ :
    00186                         case 0x73 /* 's' */ :
    00187                         case 0x74 /* 't' */ :
    00188                         case 0x75 /* 'u' */ :
    00189                         case 0x76 /* 'v' */ :
    00190                         case 0x77 /* 'w' */ :
    00191                         case 0x78 /* 'x' */ :
    00192                         case 0x79 /* 'y' */ :
    00193                         case 0x7a /* 'z' */ :
    00194                         {
    00195                                 mNAME(true);
    00196                                 theRetToken=_returnToken;
    00197                                 break;
    00198                         }
    00199                         case 0x9 /* '\t' */ :
    00200                         case 0x20 /* ' ' */ :
    00201                         {
    00202                                 mWHITESPACE(true);
    00203                                 theRetToken=_returnToken;
    00204                                 break;
    00205                         }
    00206                         case 0xa /* '\n' */ :
    00207                         case 0xd /* '\r' */ :
    00208                         {
    00209                                 mNEWLINE(true);
    00210                                 theRetToken=_returnToken;
    00211                                 break;
    00212                         }
    00213                         default:
    00214                         {
    00215                                 if (LA(1)==EOF_CHAR)
    00216                                 {
    00217                                         uponEOF();
    00218                                         _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
    00219                                 }
    00220                                 else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
    00221                         }
    00222                         }
    00223                         if ( !_returnToken )
    00224                                 goto tryAgain; // found SKIP token
    00225
    00226                         _ttype = _returnToken->getType();
    00227                         _ttype = testLiteralsTable(_ttype);
    00228                         _returnToken->setType(_ttype);
    00229                         return _returnToken;
    00230                 }
    00231                 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
    00232                                 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
    00233                 }
    00234                 catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
    00235                         throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
    00236                 }
    00237                 catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
    00238                         throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
    00239                 }
    00240 tryAgain:;
    00241         }
    00242 }
    00243
    00244 void TestSuiteLexer::mLBRACKET(bool _createToken) {
    00245         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00246         _ttype = LBRACKET;
    00247         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00248
    00249         {
    00250         match('[' /* charlit */ );
    00251         }
    00252         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00253            _token = makeToken(_ttype);
    00254            _token->setText(text.substr(_begin, text.length()-_begin));
    00255         }
    00256         _returnToken = _token;
    00257         _saveIndex=0;
    00258 }
    00259
    00260 void TestSuiteLexer::mRBRACKET(bool _createToken) {
    00261         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00262         _ttype = RBRACKET;
    00263         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00264
    00265         {
    00266         match(']' /* charlit */ );
    00267         }
    00268         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00269            _token = makeToken(_ttype);
    00270            _token->setText(text.substr(_begin, text.length()-_begin));
    00271         }
    00272         _returnToken = _token;
    00273         _saveIndex=0;
    00274 }
    00275
    00276 void TestSuiteLexer::mEQUALS(bool _createToken) {
    00277         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00278         _ttype = EQUALS;
    00279         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00280
    00281         {
    00282         match('=' /* charlit */ );
    00283         }
    00284         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00285            _token = makeToken(_ttype);
    00286            _token->setText(text.substr(_begin, text.length()-_begin));
    00287         }
    00288         _returnToken = _token;
    00289         _saveIndex=0;
    00290 }
    00291
    00292 void TestSuiteLexer::mNOT(bool _createToken) {
    00293         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00294         _ttype = NOT;
    00295         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00296
    00297         {
    00298         match('!' /* charlit */ );
    00299         }
    00300         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00301            _token = makeToken(_ttype);
    00302            _token->setText(text.substr(_begin, text.length()-_begin));
    00303         }
    00304         _returnToken = _token;
    00305         _saveIndex=0;
    00306 }
    00307
    00308 void TestSuiteLexer::mFLOAT(bool _createToken) {
    00309         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00310         _ttype = FLOAT;
    00311         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00312
    00313         {
    00314         switch ( LA(1)) {
    00315         case 0x30 /* '0' */ :
    00316         case 0x31 /* '1' */ :
    00317         case 0x32 /* '2' */ :
    00318         case 0x33 /* '3' */ :
    00319         case 0x34 /* '4' */ :
    00320         case 0x35 /* '5' */ :
    00321         case 0x36 /* '6' */ :
    00322         case 0x37 /* '7' */ :
    00323         case 0x38 /* '8' */ :
    00324         case 0x39 /* '9' */ :
    00325         {
    00326                 mNUMBER(false);
    00327                 {
    00328                 if ((LA(1) == 0x2e /* '.' */ )) {
    00329                         match('.' /* charlit */ );
    00330                         {
    00331                         if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
    00332                                 mNUMBER(false);
    00333                         }
    00334                         else {
    00335                         }
    00336
    00337                         }
    00338                 }
    00339                 else {
    00340                 }
    00341
    00342                 }
    00343                 break;
    00344         }
    00345         case 0x2e /* '.' */ :
    00346         {
    00347                 match('.' /* charlit */ );
    00348                 mNUMBER(false);
    00349                 break;
    00350         }
    00351         default:
    00352         {
    00353                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
    00354         }
    00355         }
    00356         }
    00357         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00358            _token = makeToken(_ttype);
    00359            _token->setText(text.substr(_begin, text.length()-_begin));
    00360         }
    00361         _returnToken = _token;
    00362         _saveIndex=0;
    00363 }
    00364
    00365 void TestSuiteLexer::mNUMBER(bool _createToken) {
    00366         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00367         _ttype = NUMBER;
    00368         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00369
    00370         { // ( ... )+
    00371         int _cnt63=0;
    00372         for (;;) {
    00373                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
    00374                         matchRange('0','9');
    00375                 }
    00376                 else {
    00377                         if ( _cnt63>=1 ) { goto _loop63; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
    00378                 }
    00379
    00380                 _cnt63++;
    00381         }
    00382         _loop63:;
    00383         }  // ( ... )+
    00384         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00385            _token = makeToken(_ttype);
    00386            _token->setText(text.substr(_begin, text.length()-_begin));
    00387         }
    00388         _returnToken = _token;
    00389         _saveIndex=0;
    00390 }
    00391
    00392 void TestSuiteLexer::mNAME(bool _createToken) {
    00393         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00394         _ttype = NAME;
    00395         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00396
    00397         {
    00398         switch ( LA(1)) {
    00399         case 0x61 /* 'a' */ :
    00400         case 0x62 /* 'b' */ :
    00401         case 0x63 /* 'c' */ :
    00402         case 0x64 /* 'd' */ :
    00403         case 0x65 /* 'e' */ :
    00404         case 0x66 /* 'f' */ :
    00405         case 0x67 /* 'g' */ :
    00406         case 0x68 /* 'h' */ :
    00407         case 0x69 /* 'i' */ :
    00408         case 0x6a /* 'j' */ :
    00409         case 0x6b /* 'k' */ :
    00410         case 0x6c /* 'l' */ :
    00411         case 0x6d /* 'm' */ :
    00412         case 0x6e /* 'n' */ :
    00413         case 0x6f /* 'o' */ :
    00414         case 0x70 /* 'p' */ :
    00415         case 0x71 /* 'q' */ :
    00416         case 0x72 /* 'r' */ :
    00417         case 0x73 /* 's' */ :
    00418         case 0x74 /* 't' */ :
    00419         case 0x75 /* 'u' */ :
    00420         case 0x76 /* 'v' */ :
    00421         case 0x77 /* 'w' */ :
    00422         case 0x78 /* 'x' */ :
    00423         case 0x79 /* 'y' */ :
    00424         case 0x7a /* 'z' */ :
    00425         {
    00426                 matchRange('a','z');
    00427                 break;
    00428         }
    00429         case 0x41 /* 'A' */ :
    00430         case 0x42 /* 'B' */ :
    00431         case 0x43 /* 'C' */ :
    00432         case 0x44 /* 'D' */ :
    00433         case 0x45 /* 'E' */ :
    00434         case 0x46 /* 'F' */ :
    00435         case 0x47 /* 'G' */ :
    00436         case 0x48 /* 'H' */ :
    00437         case 0x49 /* 'I' */ :
    00438         case 0x4a /* 'J' */ :
    00439         case 0x4b /* 'K' */ :
    00440         case 0x4c /* 'L' */ :
    00441         case 0x4d /* 'M' */ :
    00442         case 0x4e /* 'N' */ :
    00443         case 0x4f /* 'O' */ :
    00444         case 0x50 /* 'P' */ :
    00445         case 0x51 /* 'Q' */ :
    00446         case 0x52 /* 'R' */ :
    00447         case 0x53 /* 'S' */ :
    00448         case 0x54 /* 'T' */ :
    00449         case 0x55 /* 'U' */ :
    00450         case 0x56 /* 'V' */ :
    00451         case 0x57 /* 'W' */ :
    00452         case 0x58 /* 'X' */ :
    00453         case 0x59 /* 'Y' */ :
    00454         case 0x5a /* 'Z' */ :
    00455         {
    00456                 matchRange('A','Z');
    00457                 break;
    00458         }
    00459         case 0x5f /* '_' */ :
    00460         {
    00461                 match('_' /* charlit */ );
    00462                 break;
    00463         }
    00464         default:
    00465         {
    00466                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
    00467         }
    00468         }
    00469         }
    00470         { // ( ... )*
    00471         for (;;) {
    00472                 switch ( LA(1)) {
    00473                 case 0x61 /* 'a' */ :
    00474                 case 0x62 /* 'b' */ :
    00475                 case 0x63 /* 'c' */ :
    00476                 case 0x64 /* 'd' */ :
    00477                 case 0x65 /* 'e' */ :
    00478                 case 0x66 /* 'f' */ :
    00479                 case 0x67 /* 'g' */ :
    00480                 case 0x68 /* 'h' */ :
    00481                 case 0x69 /* 'i' */ :
    00482                 case 0x6a /* 'j' */ :
    00483                 case 0x6b /* 'k' */ :
    00484                 case 0x6c /* 'l' */ :
    00485                 case 0x6d /* 'm' */ :
    00486                 case 0x6e /* 'n' */ :
    00487                 case 0x6f /* 'o' */ :
    00488                 case 0x70 /* 'p' */ :
    00489                 case 0x71 /* 'q' */ :
    00490                 case 0x72 /* 'r' */ :
    00491                 case 0x73 /* 's' */ :
    00492                 case 0x74 /* 't' */ :
    00493                 case 0x75 /* 'u' */ :
    00494                 case 0x76 /* 'v' */ :
    00495                 case 0x77 /* 'w' */ :
    00496                 case 0x78 /* 'x' */ :
    00497                 case 0x79 /* 'y' */ :
    00498                 case 0x7a /* 'z' */ :
    00499                 {
    00500                         matchRange('a','z');
    00501                         break;
    00502                 }
    00503                 case 0x41 /* 'A' */ :
    00504                 case 0x42 /* 'B' */ :
    00505                 case 0x43 /* 'C' */ :
    00506                 case 0x44 /* 'D' */ :
    00507                 case 0x45 /* 'E' */ :
    00508                 case 0x46 /* 'F' */ :
    00509                 case 0x47 /* 'G' */ :
    00510                 case 0x48 /* 'H' */ :
    00511                 case 0x49 /* 'I' */ :
    00512                 case 0x4a /* 'J' */ :
    00513                 case 0x4b /* 'K' */ :
    00514                 case 0x4c /* 'L' */ :
    00515                 case 0x4d /* 'M' */ :
    00516                 case 0x4e /* 'N' */ :
    00517                 case 0x4f /* 'O' */ :
    00518                 case 0x50 /* 'P' */ :
    00519                 case 0x51 /* 'Q' */ :
    00520                 case 0x52 /* 'R' */ :
    00521                 case 0x53 /* 'S' */ :
    00522                 case 0x54 /* 'T' */ :
    00523                 case 0x55 /* 'U' */ :
    00524                 case 0x56 /* 'V' */ :
    00525                 case 0x57 /* 'W' */ :
    00526                 case 0x58 /* 'X' */ :
    00527                 case 0x59 /* 'Y' */ :
    00528                 case 0x5a /* 'Z' */ :
    00529                 {
    00530                         matchRange('A','Z');
    00531                         break;
    00532                 }
    00533                 case 0x30 /* '0' */ :
    00534                 case 0x31 /* '1' */ :
    00535                 case 0x32 /* '2' */ :
    00536                 case 0x33 /* '3' */ :
    00537                 case 0x34 /* '4' */ :
    00538                 case 0x35 /* '5' */ :
    00539                 case 0x36 /* '6' */ :
    00540                 case 0x37 /* '7' */ :
    00541                 case 0x38 /* '8' */ :
    00542                 case 0x39 /* '9' */ :
    00543                 {
    00544                         matchRange('0','9');
    00545                         break;
    00546                 }
    00547                 case 0x5f /* '_' */ :
    00548                 {
    00549                         match('_' /* charlit */ );
    00550                         break;
    00551                 }
    00552                 default:
    00553                 {
    00554                         goto _loop67;
    00555                 }
    00556                 }
    00557         }
    00558         _loop67:;
    00559         } // ( ... )*
    00560         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00561            _token = makeToken(_ttype);
    00562            _token->setText(text.substr(_begin, text.length()-_begin));
    00563         }
    00564         _returnToken = _token;
    00565         _saveIndex=0;
    00566 }
    00567
    00568 void TestSuiteLexer::mWHITESPACE(bool _createToken) {
    00569         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00570         _ttype = WHITESPACE;
    00571         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00572
    00573         mWS(false);
    00574 #line 545 "TestSuite.g"
    00575
    00576         // Ignore this token.
    00577         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
    00578
    00579 #line 576 "TestSuiteLexer.cpp"
    00580         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00581            _token = makeToken(_ttype);
    00582            _token->setText(text.substr(_begin, text.length()-_begin));
    00583         }
    00584         _returnToken = _token;
    00585         _saveIndex=0;
    00586 }
    00587
    00588 void TestSuiteLexer::mWS(bool _createToken) {
    00589         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00590         _ttype = WS;
    00591         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00592
    00593         { // ( ... )+
    00594         int _cnt77=0;
    00595         for (;;) {
    00596                 switch ( LA(1)) {
    00597                 case 0x20 /* ' ' */ :
    00598                 {
    00599                         match(' ' /* charlit */ );
    00600                         break;
    00601                 }
    00602                 case 0x9 /* '\t' */ :
    00603                 {
    00604                         match('\t' /* charlit */ );
    00605                         break;
    00606                 }
    00607                 default:
    00608                 {
    00609                         if ( _cnt77>=1 ) { goto _loop77; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
    00610                 }
    00611                 }
    00612                 _cnt77++;
    00613         }
    00614         _loop77:;
    00615         }  // ( ... )+
    00616         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00617            _token = makeToken(_ttype);
    00618            _token->setText(text.substr(_begin, text.length()-_begin));
    00619         }
    00620         _returnToken = _token;
    00621         _saveIndex=0;
    00622 }
    00623
    00624 void TestSuiteLexer::mNEWLINE(bool _createToken) {
    00625         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
    00626         _ttype = NEWLINE;
    00627         ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
    00628
    00629         { // ( ... )+
    00630         int _cnt74=0;
    00631         for (;;) {
    00632                 if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
    00633                         {
    00634                         switch ( LA(1)) {
    00635                         case 0xd /* '\r' */ :
    00636                         {
    00637                                 match('\r' /* charlit */ );
    00638                                 {
    00639                                 if ((LA(1) == 0xa /* '\n' */ ) && (true)) {
    00640                                         match('\n' /* charlit */ );
    00641                                 }
    00642                                 else {
    00643                                 }
    00644
    00645                                 }
    00646 #line 557 "TestSuite.g"
    00647                                 newline();
    00648 #line 645 "TestSuiteLexer.cpp"
    00649                                 break;
    00650                         }
    00651                         case 0xa /* '\n' */ :
    00652                         {
    00653                                 match('\n' /* charlit */ );
    00654 #line 558 "TestSuite.g"
    00655                                 newline();
    00656 #line 653 "TestSuiteLexer.cpp"
    00657                                 break;
    00658                         }
    00659                         default:
    00660                         {
    00661                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
    00662                         }
    00663                         }
    00664                         }
    00665                         {
    00666                         if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0x20 /* ' ' */ )) {
    00667                                 mWS(false);
    00668                         }
    00669                         else {
    00670                         }
    00671
    00672                         }
    00673                 }
    00674                 else {
    00675                         if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
    00676                 }
    00677
    00678                 _cnt74++;
    00679         }
    00680         _loop74:;
    00681         }  // ( ... )+
    00682         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
    00683            _token = makeToken(_ttype);
    00684            _token->setText(text.substr(_begin, text.length()-_begin));
    00685         }
    00686         _returnToken = _token;
    00687         _saveIndex=0;
    00688 }
    00689
    00690
    00691
    00692 ANTLR_END_NAMESPACE
    00693 ANTLR_END_NAMESPACE
    00694 ANTLR_END_NAMESPACE
    00695 ANTLR_END_NAMESPACE