libsecurity_codesigning/lib/RequirementLexer.cpp

   1 /* $ANTLR 2.7.7 (20120228): "requirements.grammar" -> "RequirementLexer.cpp"$ */
   2 #include "RequirementLexer.hpp"
   3 #include <antlr/CharBuffer.hpp>
   4 #include <antlr/TokenStreamException.hpp>
   5 #include <antlr/TokenStreamIOException.hpp>
   6 #include <antlr/TokenStreamRecognitionException.hpp>
   7 #include <antlr/CharStreamException.hpp>
   8 #include <antlr/CharStreamIOException.hpp>
   9 #include <antlr/NoViableAltForCharException.hpp>
  10
  11
  12 #include "requirement.h"
  13 #include "reqmaker.h"
  14 #include "csutilities.h"
  15 #include <security_utilities/cfutilities.h>
  16 #include <security_utilities/hashing.h>
  17 #include <security_cdsa_utilities/cssmdata.h>   // OID coding
  18 using namespace CodeSigning;
  19 typedef Requirement::Maker Maker;
  20
  21 ANTLR_BEGIN_NAMESPACE(Security_CodeSigning)
  22 RequirementLexer::RequirementLexer(std::istream& in)
  23         : antlr::CharScanner(new antlr::CharBuffer(in),true)
  24 {
  25         initLiterals();
  26 }
  27
  28 RequirementLexer::RequirementLexer(antlr::InputBuffer& ib)
  29         : antlr::CharScanner(ib,true)
  30 {
  31         initLiterals();
  32 }
  33
  34 RequirementLexer::RequirementLexer(const antlr::LexerSharedInputState& state)
  35         : antlr::CharScanner(state,true)
  36 {
  37         initLiterals();
  38 }
  39
  40 void RequirementLexer::initLiterals()
  41 {
  42         literals["certificate"] = 25;
  43         literals["always"] = 16;
  44         literals["host"] = 6;
  45         literals["guest"] = 5;
  46         literals["cdhash"] = 21;
  47         literals["entitlement"] = 29;
  48         literals["library"] = 8;
  49         literals["never"] = 18;
  50         literals["cert"] = 26;
  51         literals["plugin"] = 9;
  52         literals["or"] = 11;
  53         literals["leaf"] = 42;
  54         literals["info"] = 28;
  55         literals["designated"] = 7;
  56         literals["apple"] = 23;
  57         literals["trusted"] = 27;
  58         literals["true"] = 17;
  59         literals["and"] = 12;
  60         literals["root"] = 43;
  61         literals["anchor"] = 22;
  62         literals["false"] = 19;
  63         literals["generic"] = 24;
  64         literals["identifier"] = 20;
  65         literals["exists"] = 30;
  66 }
  67
  68 antlr::RefToken RequirementLexer::nextToken()
  69 {
  70         antlr::RefToken theRetToken;
  71         for (;;) {
  72                 antlr::RefToken theRetToken;
  73                 int _ttype = antlr::Token::INVALID_TYPE;
  74                 resetText();
  75                 try {   // for lexical and char stream error handling
  76                         switch ( LA(1)) {
  77                         case 0x22 /* '\"' */ :
  78                         {
  79                                 mSTRING(true);
  80                                 theRetToken=_returnToken;
  81                                 break;
  82                         }
  83                         case 0x3b /* ';' */ :
  84                         {
  85                                 mSEMI(true);
  86                                 theRetToken=_returnToken;
  87                                 break;
  88                         }
  89                         case 0x28 /* '(' */ :
  90                         {
  91                                 mLPAREN(true);
  92                                 theRetToken=_returnToken;
  93                                 break;
  94                         }
  95                         case 0x29 /* ')' */ :
  96                         {
  97                                 mRPAREN(true);
  98                                 theRetToken=_returnToken;
  99                                 break;
 100                         }
 101                         case 0x5b /* '[' */ :
 102                         {
 103                                 mLBRACK(true);
 104                                 theRetToken=_returnToken;
 105                                 break;
 106                         }
 107                         case 0x5d /* ']' */ :
 108                         {
 109                                 mRBRACK(true);
 110                                 theRetToken=_returnToken;
 111                                 break;
 112                         }
 113                         case 0x2c /* ',' */ :
 114                         {
 115                                 mCOMMA(true);
 116                                 theRetToken=_returnToken;
 117                                 break;
 118                         }
 119                         case 0x7e /* '~' */ :
 120                         {
 121                                 mSUBS(true);
 122                                 theRetToken=_returnToken;
 123                                 break;
 124                         }
 125                         case 0x2d /* '-' */ :
 126                         {
 127                                 mNEG(true);
 128                                 theRetToken=_returnToken;
 129                                 break;
 130                         }
 131                         case 0x21 /* '!' */ :
 132                         {
 133                                 mNOT(true);
 134                                 theRetToken=_returnToken;
 135                                 break;
 136                         }
 137                         case 0x2a /* '*' */ :
 138                         {
 139                                 mSTAR(true);
 140                                 theRetToken=_returnToken;
 141                                 break;
 142                         }
 143                         case 0x9 /* '\t' */ :
 144                         case 0xa /* '\n' */ :
 145                         case 0x20 /* ' ' */ :
 146                         {
 147                                 mWS(true);
 148                                 theRetToken=_returnToken;
 149                                 break;
 150                         }
 151                         case 0x23 /* '#' */ :
 152                         {
 153                                 mSHELLCOMMENT(true);
 154                                 theRetToken=_returnToken;
 155                                 break;
 156                         }
 157                         default:
 158                                 if ((LA(1) == 0x2f /* '/' */ ) && (_tokenSet_0.member(LA(2)))) {
 159                                         mPATHNAME(true);
 160                                         theRetToken=_returnToken;
 161                                 }
 162                                 else if ((LA(1) == 0x48 /* 'H' */ ) && (LA(2) == 0x22 /* '\"' */ )) {
 163                                         mHASHCONSTANT(true);
 164                                         theRetToken=_returnToken;
 165                                 }
 166                                 else if ((LA(1) == 0x30 /* '0' */ ) && (LA(2) == 0x78 /* 'x' */ )) {
 167                                         mHEXCONSTANT(true);
 168                                         theRetToken=_returnToken;
 169                                 }
 170                                 else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3e /* '>' */ )) {
 171                                         mARROW(true);
 172                                         theRetToken=_returnToken;
 173                                 }
 174                                 else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) {
 175                                         mLE(true);
 176                                         theRetToken=_returnToken;
 177                                 }
 178                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) {
 179                                         mGE(true);
 180                                         theRetToken=_returnToken;
 181                                 }
 182                                 else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3d /* '=' */ )) {
 183                                         mEQQL(true);
 184                                         theRetToken=_returnToken;
 185                                 }
 186                                 else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
 187                                         mC_COMMENT(true);
 188                                         theRetToken=_returnToken;
 189                                 }
 190                                 else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) {
 191                                         mCPP_COMMENT(true);
 192                                         theRetToken=_returnToken;
 193                                 }
 194                                 else if ((_tokenSet_0.member(LA(1))) && (true)) {
 195                                         mDOTKEY(true);
 196                                         theRetToken=_returnToken;
 197                                 }
 198                                 else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true)) {
 199                                         mINTEGER(true);
 200                                         theRetToken=_returnToken;
 201                                 }
 202                                 else if ((LA(1) == 0x3c /* '<' */ ) && (true)) {
 203                                         mLESS(true);
 204                                         theRetToken=_returnToken;
 205                                 }
 206                                 else if ((LA(1) == 0x3e /* '>' */ ) && (true)) {
 207                                         mGT(true);
 208                                         theRetToken=_returnToken;
 209                                 }
 210                                 else if ((LA(1) == 0x3d /* '=' */ ) && (true)) {
 211                                         mEQL(true);
 212                                         theRetToken=_returnToken;
 213                                 }
 214                         else {
 215                                 if (LA(1)==EOF_CHAR)
 216                                 {
 217                                         uponEOF();
 218                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
 219                                 }
 220                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
 221                         }
 222                         }
 223                         if ( !_returnToken )
 224                                 goto tryAgain; // found SKIP token
 225
 226                         _ttype = _returnToken->getType();
 227                         _returnToken->setType(_ttype);
 228                         return _returnToken;
 229                 }
 230                 catch (antlr::RecognitionException& e) {
 231                                 throw antlr::TokenStreamRecognitionException(e);
 232                 }
 233                 catch (antlr::CharStreamIOException& csie) {
 234                         throw antlr::TokenStreamIOException(csie.io);
 235                 }
 236                 catch (antlr::CharStreamException& cse) {
 237                         throw antlr::TokenStreamException(cse.getMessage());
 238                 }
 239 tryAgain:;
 240         }
 241 }
 242
 243 void RequirementLexer::mIDENT(bool _createToken) {
 244         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 245         _ttype = IDENT;
 246         std::string::size_type _saveIndex;
 247
 248         {
 249         switch ( LA(1)) {
 250         case 0x41 /* 'A' */ :
 251         case 0x42 /* 'B' */ :
 252         case 0x43 /* 'C' */ :
 253         case 0x44 /* 'D' */ :
 254         case 0x45 /* 'E' */ :
 255         case 0x46 /* 'F' */ :
 256         case 0x47 /* 'G' */ :
 257         case 0x48 /* 'H' */ :
 258         case 0x49 /* 'I' */ :
 259         case 0x4a /* 'J' */ :
 260         case 0x4b /* 'K' */ :
 261         case 0x4c /* 'L' */ :
 262         case 0x4d /* 'M' */ :
 263         case 0x4e /* 'N' */ :
 264         case 0x4f /* 'O' */ :
 265         case 0x50 /* 'P' */ :
 266         case 0x51 /* 'Q' */ :
 267         case 0x52 /* 'R' */ :
 268         case 0x53 /* 'S' */ :
 269         case 0x54 /* 'T' */ :
 270         case 0x55 /* 'U' */ :
 271         case 0x56 /* 'V' */ :
 272         case 0x57 /* 'W' */ :
 273         case 0x58 /* 'X' */ :
 274         case 0x59 /* 'Y' */ :
 275         case 0x5a /* 'Z' */ :
 276         {
 277                 matchRange('A','Z');
 278                 break;
 279         }
 280         case 0x61 /* 'a' */ :
 281         case 0x62 /* 'b' */ :
 282         case 0x63 /* 'c' */ :
 283         case 0x64 /* 'd' */ :
 284         case 0x65 /* 'e' */ :
 285         case 0x66 /* 'f' */ :
 286         case 0x67 /* 'g' */ :
 287         case 0x68 /* 'h' */ :
 288         case 0x69 /* 'i' */ :
 289         case 0x6a /* 'j' */ :
 290         case 0x6b /* 'k' */ :
 291         case 0x6c /* 'l' */ :
 292         case 0x6d /* 'm' */ :
 293         case 0x6e /* 'n' */ :
 294         case 0x6f /* 'o' */ :
 295         case 0x70 /* 'p' */ :
 296         case 0x71 /* 'q' */ :
 297         case 0x72 /* 'r' */ :
 298         case 0x73 /* 's' */ :
 299         case 0x74 /* 't' */ :
 300         case 0x75 /* 'u' */ :
 301         case 0x76 /* 'v' */ :
 302         case 0x77 /* 'w' */ :
 303         case 0x78 /* 'x' */ :
 304         case 0x79 /* 'y' */ :
 305         case 0x7a /* 'z' */ :
 306         {
 307                 matchRange('a','z');
 308                 break;
 309         }
 310         default:
 311         {
 312                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
 313         }
 314         }
 315         }
 316         { // ( ... )*
 317         for (;;) {
 318                 switch ( LA(1)) {
 319                 case 0x41 /* 'A' */ :
 320                 case 0x42 /* 'B' */ :
 321                 case 0x43 /* 'C' */ :
 322                 case 0x44 /* 'D' */ :
 323                 case 0x45 /* 'E' */ :
 324                 case 0x46 /* 'F' */ :
 325                 case 0x47 /* 'G' */ :
 326                 case 0x48 /* 'H' */ :
 327                 case 0x49 /* 'I' */ :
 328                 case 0x4a /* 'J' */ :
 329                 case 0x4b /* 'K' */ :
 330                 case 0x4c /* 'L' */ :
 331                 case 0x4d /* 'M' */ :
 332                 case 0x4e /* 'N' */ :
 333                 case 0x4f /* 'O' */ :
 334                 case 0x50 /* 'P' */ :
 335                 case 0x51 /* 'Q' */ :
 336                 case 0x52 /* 'R' */ :
 337                 case 0x53 /* 'S' */ :
 338                 case 0x54 /* 'T' */ :
 339                 case 0x55 /* 'U' */ :
 340                 case 0x56 /* 'V' */ :
 341                 case 0x57 /* 'W' */ :
 342                 case 0x58 /* 'X' */ :
 343                 case 0x59 /* 'Y' */ :
 344                 case 0x5a /* 'Z' */ :
 345                 {
 346                         matchRange('A','Z');
 347                         break;
 348                 }
 349                 case 0x61 /* 'a' */ :
 350                 case 0x62 /* 'b' */ :
 351                 case 0x63 /* 'c' */ :
 352                 case 0x64 /* 'd' */ :
 353                 case 0x65 /* 'e' */ :
 354                 case 0x66 /* 'f' */ :
 355                 case 0x67 /* 'g' */ :
 356                 case 0x68 /* 'h' */ :
 357                 case 0x69 /* 'i' */ :
 358                 case 0x6a /* 'j' */ :
 359                 case 0x6b /* 'k' */ :
 360                 case 0x6c /* 'l' */ :
 361                 case 0x6d /* 'm' */ :
 362                 case 0x6e /* 'n' */ :
 363                 case 0x6f /* 'o' */ :
 364                 case 0x70 /* 'p' */ :
 365                 case 0x71 /* 'q' */ :
 366                 case 0x72 /* 'r' */ :
 367                 case 0x73 /* 's' */ :
 368                 case 0x74 /* 't' */ :
 369                 case 0x75 /* 'u' */ :
 370                 case 0x76 /* 'v' */ :
 371                 case 0x77 /* 'w' */ :
 372                 case 0x78 /* 'x' */ :
 373                 case 0x79 /* 'y' */ :
 374                 case 0x7a /* 'z' */ :
 375                 {
 376                         matchRange('a','z');
 377                         break;
 378                 }
 379                 case 0x30 /* '0' */ :
 380                 case 0x31 /* '1' */ :
 381                 case 0x32 /* '2' */ :
 382                 case 0x33 /* '3' */ :
 383                 case 0x34 /* '4' */ :
 384                 case 0x35 /* '5' */ :
 385                 case 0x36 /* '6' */ :
 386                 case 0x37 /* '7' */ :
 387                 case 0x38 /* '8' */ :
 388                 case 0x39 /* '9' */ :
 389                 {
 390                         matchRange('0','9');
 391                         break;
 392                 }
 393                 default:
 394                 {
 395                         goto _loop46;
 396                 }
 397                 }
 398         }
 399         _loop46:;
 400         } // ( ... )*
 401         _ttype = testLiteralsTable(text.substr(_begin, text.length()-_begin),_ttype);
 402         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 403            _token = makeToken(_ttype);
 404            _token->setText(text.substr(_begin, text.length()-_begin));
 405         }
 406         _returnToken = _token;
 407         _saveIndex=0;
 408 }
 409
 410 void RequirementLexer::mDOTKEY(bool _createToken) {
 411         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 412         _ttype = DOTKEY;
 413         std::string::size_type _saveIndex;
 414
 415         mIDENT(false);
 416         { // ( ... )*
 417         for (;;) {
 418                 if ((LA(1) == 0x2e /* '.' */ )) {
 419                         match(".");
 420                         {
 421                         switch ( LA(1)) {
 422                         case 0x41 /* 'A' */ :
 423                         case 0x42 /* 'B' */ :
 424                         case 0x43 /* 'C' */ :
 425                         case 0x44 /* 'D' */ :
 426                         case 0x45 /* 'E' */ :
 427                         case 0x46 /* 'F' */ :
 428                         case 0x47 /* 'G' */ :
 429                         case 0x48 /* 'H' */ :
 430                         case 0x49 /* 'I' */ :
 431                         case 0x4a /* 'J' */ :
 432                         case 0x4b /* 'K' */ :
 433                         case 0x4c /* 'L' */ :
 434                         case 0x4d /* 'M' */ :
 435                         case 0x4e /* 'N' */ :
 436                         case 0x4f /* 'O' */ :
 437                         case 0x50 /* 'P' */ :
 438                         case 0x51 /* 'Q' */ :
 439                         case 0x52 /* 'R' */ :
 440                         case 0x53 /* 'S' */ :
 441                         case 0x54 /* 'T' */ :
 442                         case 0x55 /* 'U' */ :
 443                         case 0x56 /* 'V' */ :
 444                         case 0x57 /* 'W' */ :
 445                         case 0x58 /* 'X' */ :
 446                         case 0x59 /* 'Y' */ :
 447                         case 0x5a /* 'Z' */ :
 448                         case 0x61 /* 'a' */ :
 449                         case 0x62 /* 'b' */ :
 450                         case 0x63 /* 'c' */ :
 451                         case 0x64 /* 'd' */ :
 452                         case 0x65 /* 'e' */ :
 453                         case 0x66 /* 'f' */ :
 454                         case 0x67 /* 'g' */ :
 455                         case 0x68 /* 'h' */ :
 456                         case 0x69 /* 'i' */ :
 457                         case 0x6a /* 'j' */ :
 458                         case 0x6b /* 'k' */ :
 459                         case 0x6c /* 'l' */ :
 460                         case 0x6d /* 'm' */ :
 461                         case 0x6e /* 'n' */ :
 462                         case 0x6f /* 'o' */ :
 463                         case 0x70 /* 'p' */ :
 464                         case 0x71 /* 'q' */ :
 465                         case 0x72 /* 'r' */ :
 466                         case 0x73 /* 's' */ :
 467                         case 0x74 /* 't' */ :
 468                         case 0x75 /* 'u' */ :
 469                         case 0x76 /* 'v' */ :
 470                         case 0x77 /* 'w' */ :
 471                         case 0x78 /* 'x' */ :
 472                         case 0x79 /* 'y' */ :
 473                         case 0x7a /* 'z' */ :
 474                         {
 475                                 mIDENT(false);
 476                                 break;
 477                         }
 478                         case 0x30 /* '0' */ :
 479                         case 0x31 /* '1' */ :
 480                         case 0x32 /* '2' */ :
 481                         case 0x33 /* '3' */ :
 482                         case 0x34 /* '4' */ :
 483                         case 0x35 /* '5' */ :
 484                         case 0x36 /* '6' */ :
 485                         case 0x37 /* '7' */ :
 486                         case 0x38 /* '8' */ :
 487                         case 0x39 /* '9' */ :
 488                         {
 489                                 mINTEGER(false);
 490                                 break;
 491                         }
 492                         default:
 493                         {
 494                                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
 495                         }
 496                         }
 497                         }
 498                 }
 499                 else {
 500                         goto _loop50;
 501                 }
 502
 503         }
 504         _loop50:;
 505         } // ( ... )*
 506         _ttype = testLiteralsTable(_ttype);
 507         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 508            _token = makeToken(_ttype);
 509            _token->setText(text.substr(_begin, text.length()-_begin));
 510         }
 511         _returnToken = _token;
 512         _saveIndex=0;
 513 }
 514
 515 void RequirementLexer::mINTEGER(bool _createToken) {
 516         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 517         _ttype = INTEGER;
 518         std::string::size_type _saveIndex;
 519
 520         { // ( ... )+
 521         int _cnt68=0;
 522         for (;;) {
 523                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
 524                         matchRange('0','9');
 525                 }
 526                 else {
 527                         if ( _cnt68>=1 ) { goto _loop68; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
 528                 }
 529
 530                 _cnt68++;
 531         }
 532         _loop68:;
 533         }  // ( ... )+
 534         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 535            _token = makeToken(_ttype);
 536            _token->setText(text.substr(_begin, text.length()-_begin));
 537         }
 538         _returnToken = _token;
 539         _saveIndex=0;
 540 }
 541
 542 void RequirementLexer::mPATHNAME(bool _createToken) {
 543         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 544         _ttype = PATHNAME;
 545         std::string::size_type _saveIndex;
 546
 547         match("/");
 548         mIDENT(false);
 549         { // ( ... )+
 550         int _cnt53=0;
 551         for (;;) {
 552                 if ((LA(1) == 0x2f /* '/' */ )) {
 553                         match("/");
 554                         mIDENT(false);
 555                 }
 556                 else {
 557                         if ( _cnt53>=1 ) { goto _loop53; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
 558                 }
 559
 560                 _cnt53++;
 561         }
 562         _loop53:;
 563         }  // ( ... )+
 564         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 565            _token = makeToken(_ttype);
 566            _token->setText(text.substr(_begin, text.length()-_begin));
 567         }
 568         _returnToken = _token;
 569         _saveIndex=0;
 570 }
 571
 572 void RequirementLexer::mHASHCONSTANT(bool _createToken) {
 573         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 574         _ttype = HASHCONSTANT;
 575         std::string::size_type _saveIndex;
 576
 577         _saveIndex = text.length();
 578         match('H' /* charlit */ );
 579         text.erase(_saveIndex);
 580         _saveIndex = text.length();
 581         match('\"' /* charlit */ );
 582         text.erase(_saveIndex);
 583         { // ( ... )+
 584         int _cnt56=0;
 585         for (;;) {
 586                 if ((_tokenSet_1.member(LA(1)))) {
 587                         mHEX(false);
 588                 }
 589                 else {
 590                         if ( _cnt56>=1 ) { goto _loop56; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
 591                 }
 592
 593                 _cnt56++;
 594         }
 595         _loop56:;
 596         }  // ( ... )+
 597         _saveIndex = text.length();
 598         match('\"' /* charlit */ );
 599         text.erase(_saveIndex);
 600         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 601            _token = makeToken(_ttype);
 602            _token->setText(text.substr(_begin, text.length()-_begin));
 603         }
 604         _returnToken = _token;
 605         _saveIndex=0;
 606 }
 607
 608 void RequirementLexer::mHEX(bool _createToken) {
 609         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 610         _ttype = HEX;
 611         std::string::size_type _saveIndex;
 612
 613         switch ( LA(1)) {
 614         case 0x30 /* '0' */ :
 615         case 0x31 /* '1' */ :
 616         case 0x32 /* '2' */ :
 617         case 0x33 /* '3' */ :
 618         case 0x34 /* '4' */ :
 619         case 0x35 /* '5' */ :
 620         case 0x36 /* '6' */ :
 621         case 0x37 /* '7' */ :
 622         case 0x38 /* '8' */ :
 623         case 0x39 /* '9' */ :
 624         {
 625                 matchRange('0','9');
 626                 break;
 627         }
 628         case 0x61 /* 'a' */ :
 629         case 0x62 /* 'b' */ :
 630         case 0x63 /* 'c' */ :
 631         case 0x64 /* 'd' */ :
 632         case 0x65 /* 'e' */ :
 633         case 0x66 /* 'f' */ :
 634         {
 635                 matchRange('a','f');
 636                 break;
 637         }
 638         case 0x41 /* 'A' */ :
 639         case 0x42 /* 'B' */ :
 640         case 0x43 /* 'C' */ :
 641         case 0x44 /* 'D' */ :
 642         case 0x45 /* 'E' */ :
 643         case 0x46 /* 'F' */ :
 644         {
 645                 matchRange('A','F');
 646                 break;
 647         }
 648         default:
 649         {
 650                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
 651         }
 652         }
 653         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 654            _token = makeToken(_ttype);
 655            _token->setText(text.substr(_begin, text.length()-_begin));
 656         }
 657         _returnToken = _token;
 658         _saveIndex=0;
 659 }
 660
 661 void RequirementLexer::mHEXCONSTANT(bool _createToken) {
 662         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 663         _ttype = HEXCONSTANT;
 664         std::string::size_type _saveIndex;
 665
 666         _saveIndex = text.length();
 667         match('0' /* charlit */ );
 668         text.erase(_saveIndex);
 669         _saveIndex = text.length();
 670         match('x' /* charlit */ );
 671         text.erase(_saveIndex);
 672         { // ( ... )+
 673         int _cnt59=0;
 674         for (;;) {
 675                 if ((_tokenSet_1.member(LA(1)))) {
 676                         mHEX(false);
 677                 }
 678                 else {
 679                         if ( _cnt59>=1 ) { goto _loop59; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
 680                 }
 681
 682                 _cnt59++;
 683         }
 684         _loop59:;
 685         }  // ( ... )+
 686         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 687            _token = makeToken(_ttype);
 688            _token->setText(text.substr(_begin, text.length()-_begin));
 689         }
 690         _returnToken = _token;
 691         _saveIndex=0;
 692 }
 693
 694 void RequirementLexer::mSTRING(bool _createToken) {
 695         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 696         _ttype = STRING;
 697         std::string::size_type _saveIndex;
 698
 699         _saveIndex = text.length();
 700         match('\"' /* charlit */ );
 701         text.erase(_saveIndex);
 702         { // ( ... )*
 703         for (;;) {
 704                 switch ( LA(1)) {
 705                 case 0x5c /* '\\' */ :
 706                 {
 707                         {
 708                         _saveIndex = text.length();
 709                         match('\\' /* charlit */ );
 710                         text.erase(_saveIndex);
 711                         match('\"' /* charlit */ );
 712                         }
 713                         break;
 714                 }
 715                 case 0x0 /* '\0' */ :
 716                 case 0x1 /* '\1' */ :
 717                 case 0x2 /* '\2' */ :
 718                 case 0x3 /* '\3' */ :
 719                 case 0x4 /* '\4' */ :
 720                 case 0x5 /* '\5' */ :
 721                 case 0x6 /* '\6' */ :
 722                 case 0x7 /* '\7' */ :
 723                 case 0x8 /* '\10' */ :
 724                 case 0x9 /* '\t' */ :
 725                 case 0xa /* '\n' */ :
 726                 case 0xb /* '\13' */ :
 727                 case 0xc /* '\14' */ :
 728                 case 0xd /* '\r' */ :
 729                 case 0xe /* '\16' */ :
 730                 case 0xf /* '\17' */ :
 731                 case 0x10 /* '\20' */ :
 732                 case 0x11 /* '\21' */ :
 733                 case 0x12 /* '\22' */ :
 734                 case 0x13 /* '\23' */ :
 735                 case 0x14 /* '\24' */ :
 736                 case 0x15 /* '\25' */ :
 737                 case 0x16 /* '\26' */ :
 738                 case 0x17 /* '\27' */ :
 739                 case 0x18 /* '\30' */ :
 740                 case 0x19 /* '\31' */ :
 741                 case 0x1a /* '\32' */ :
 742                 case 0x1b /* '\33' */ :
 743                 case 0x1c /* '\34' */ :
 744                 case 0x1d /* '\35' */ :
 745                 case 0x1e /* '\36' */ :
 746                 case 0x1f /* '\37' */ :
 747                 case 0x20 /* ' ' */ :
 748                 case 0x21 /* '!' */ :
 749                 case 0x23 /* '#' */ :
 750                 case 0x24 /* '$' */ :
 751                 case 0x25 /* '%' */ :
 752                 case 0x26 /* '&' */ :
 753                 case 0x27 /* '\'' */ :
 754                 case 0x28 /* '(' */ :
 755                 case 0x29 /* ')' */ :
 756                 case 0x2a /* '*' */ :
 757                 case 0x2b /* '+' */ :
 758                 case 0x2c /* ',' */ :
 759                 case 0x2d /* '-' */ :
 760                 case 0x2e /* '.' */ :
 761                 case 0x2f /* '/' */ :
 762                 case 0x30 /* '0' */ :
 763                 case 0x31 /* '1' */ :
 764                 case 0x32 /* '2' */ :
 765                 case 0x33 /* '3' */ :
 766                 case 0x34 /* '4' */ :
 767                 case 0x35 /* '5' */ :
 768                 case 0x36 /* '6' */ :
 769                 case 0x37 /* '7' */ :
 770                 case 0x38 /* '8' */ :
 771                 case 0x39 /* '9' */ :
 772                 case 0x3a /* ':' */ :
 773                 case 0x3b /* ';' */ :
 774                 case 0x3c /* '<' */ :
 775                 case 0x3d /* '=' */ :
 776                 case 0x3e /* '>' */ :
 777                 case 0x3f /* '?' */ :
 778                 case 0x40 /* '@' */ :
 779                 case 0x41 /* 'A' */ :
 780                 case 0x42 /* 'B' */ :
 781                 case 0x43 /* 'C' */ :
 782                 case 0x44 /* 'D' */ :
 783                 case 0x45 /* 'E' */ :
 784                 case 0x46 /* 'F' */ :
 785                 case 0x47 /* 'G' */ :
 786                 case 0x48 /* 'H' */ :
 787                 case 0x49 /* 'I' */ :
 788                 case 0x4a /* 'J' */ :
 789                 case 0x4b /* 'K' */ :
 790                 case 0x4c /* 'L' */ :
 791                 case 0x4d /* 'M' */ :
 792                 case 0x4e /* 'N' */ :
 793                 case 0x4f /* 'O' */ :
 794                 case 0x50 /* 'P' */ :
 795                 case 0x51 /* 'Q' */ :
 796                 case 0x52 /* 'R' */ :
 797                 case 0x53 /* 'S' */ :
 798                 case 0x54 /* 'T' */ :
 799                 case 0x55 /* 'U' */ :
 800                 case 0x56 /* 'V' */ :
 801                 case 0x57 /* 'W' */ :
 802                 case 0x58 /* 'X' */ :
 803                 case 0x59 /* 'Y' */ :
 804                 case 0x5a /* 'Z' */ :
 805                 case 0x5b /* '[' */ :
 806                 case 0x5d /* ']' */ :
 807                 case 0x5e /* '^' */ :
 808                 case 0x5f /* '_' */ :
 809                 case 0x60 /* '`' */ :
 810                 case 0x61 /* 'a' */ :
 811                 case 0x62 /* 'b' */ :
 812                 case 0x63 /* 'c' */ :
 813                 case 0x64 /* 'd' */ :
 814                 case 0x65 /* 'e' */ :
 815                 case 0x66 /* 'f' */ :
 816                 case 0x67 /* 'g' */ :
 817                 case 0x68 /* 'h' */ :
 818                 case 0x69 /* 'i' */ :
 819                 case 0x6a /* 'j' */ :
 820                 case 0x6b /* 'k' */ :
 821                 case 0x6c /* 'l' */ :
 822                 case 0x6d /* 'm' */ :
 823                 case 0x6e /* 'n' */ :
 824                 case 0x6f /* 'o' */ :
 825                 case 0x70 /* 'p' */ :
 826                 case 0x71 /* 'q' */ :
 827                 case 0x72 /* 'r' */ :
 828                 case 0x73 /* 's' */ :
 829                 case 0x74 /* 't' */ :
 830                 case 0x75 /* 'u' */ :
 831                 case 0x76 /* 'v' */ :
 832                 case 0x77 /* 'w' */ :
 833                 case 0x78 /* 'x' */ :
 834                 case 0x79 /* 'y' */ :
 835                 case 0x7a /* 'z' */ :
 836                 case 0x7b /* '{' */ :
 837                 case 0x7c /* '|' */ :
 838                 case 0x7d /* '}' */ :
 839                 case 0x7e /* '~' */ :
 840                 case 0x7f:
 841                 {
 842                         {
 843                         {
 844                         match(_tokenSet_2);
 845                         }
 846                         }
 847                         break;
 848                 }
 849                 default:
 850                 {
 851                         goto _loop65;
 852                 }
 853                 }
 854         }
 855         _loop65:;
 856         } // ( ... )*
 857         _saveIndex = text.length();
 858         match('\"' /* charlit */ );
 859         text.erase(_saveIndex);
 860         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 861            _token = makeToken(_ttype);
 862            _token->setText(text.substr(_begin, text.length()-_begin));
 863         }
 864         _returnToken = _token;
 865         _saveIndex=0;
 866 }
 867
 868 void RequirementLexer::mARROW(bool _createToken) {
 869         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 870         _ttype = ARROW;
 871         std::string::size_type _saveIndex;
 872
 873         match("=>");
 874         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 875            _token = makeToken(_ttype);
 876            _token->setText(text.substr(_begin, text.length()-_begin));
 877         }
 878         _returnToken = _token;
 879         _saveIndex=0;
 880 }
 881
 882 void RequirementLexer::mSEMI(bool _createToken) {
 883         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 884         _ttype = SEMI;
 885         std::string::size_type _saveIndex;
 886
 887         match(';' /* charlit */ );
 888         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 889            _token = makeToken(_ttype);
 890            _token->setText(text.substr(_begin, text.length()-_begin));
 891         }
 892         _returnToken = _token;
 893         _saveIndex=0;
 894 }
 895
 896 void RequirementLexer::mLPAREN(bool _createToken) {
 897         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 898         _ttype = LPAREN;
 899         std::string::size_type _saveIndex;
 900
 901         match('(' /* charlit */ );
 902         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 903            _token = makeToken(_ttype);
 904            _token->setText(text.substr(_begin, text.length()-_begin));
 905         }
 906         _returnToken = _token;
 907         _saveIndex=0;
 908 }
 909
 910 void RequirementLexer::mRPAREN(bool _createToken) {
 911         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 912         _ttype = RPAREN;
 913         std::string::size_type _saveIndex;
 914
 915         match(')' /* charlit */ );
 916         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 917            _token = makeToken(_ttype);
 918            _token->setText(text.substr(_begin, text.length()-_begin));
 919         }
 920         _returnToken = _token;
 921         _saveIndex=0;
 922 }
 923
 924 void RequirementLexer::mLBRACK(bool _createToken) {
 925         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 926         _ttype = LBRACK;
 927         std::string::size_type _saveIndex;
 928
 929         match('[' /* charlit */ );
 930         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 931            _token = makeToken(_ttype);
 932            _token->setText(text.substr(_begin, text.length()-_begin));
 933         }
 934         _returnToken = _token;
 935         _saveIndex=0;
 936 }
 937
 938 void RequirementLexer::mRBRACK(bool _createToken) {
 939         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 940         _ttype = RBRACK;
 941         std::string::size_type _saveIndex;
 942
 943         match(']' /* charlit */ );
 944         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 945            _token = makeToken(_ttype);
 946            _token->setText(text.substr(_begin, text.length()-_begin));
 947         }
 948         _returnToken = _token;
 949         _saveIndex=0;
 950 }
 951
 952 void RequirementLexer::mLESS(bool _createToken) {
 953         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 954         _ttype = LESS;
 955         std::string::size_type _saveIndex;
 956
 957         match('<' /* charlit */ );
 958         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 959            _token = makeToken(_ttype);
 960            _token->setText(text.substr(_begin, text.length()-_begin));
 961         }
 962         _returnToken = _token;
 963         _saveIndex=0;
 964 }
 965
 966 void RequirementLexer::mGT(bool _createToken) {
 967         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 968         _ttype = GT;
 969         std::string::size_type _saveIndex;
 970
 971         match('>' /* charlit */ );
 972         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 973            _token = makeToken(_ttype);
 974            _token->setText(text.substr(_begin, text.length()-_begin));
 975         }
 976         _returnToken = _token;
 977         _saveIndex=0;
 978 }
 979
 980 void RequirementLexer::mLE(bool _createToken) {
 981         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 982         _ttype = LE;
 983         std::string::size_type _saveIndex;
 984
 985         match("<=");
 986         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
 987            _token = makeToken(_ttype);
 988            _token->setText(text.substr(_begin, text.length()-_begin));
 989         }
 990         _returnToken = _token;
 991         _saveIndex=0;
 992 }
 993
 994 void RequirementLexer::mGE(bool _createToken) {
 995         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
 996         _ttype = GE;
 997         std::string::size_type _saveIndex;
 998
 999         match(">=");
1000         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1001            _token = makeToken(_ttype);
1002            _token->setText(text.substr(_begin, text.length()-_begin));
1003         }
1004         _returnToken = _token;
1005         _saveIndex=0;
1006 }
1007
1008 void RequirementLexer::mCOMMA(bool _createToken) {
1009         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1010         _ttype = COMMA;
1011         std::string::size_type _saveIndex;
1012
1013         match(',' /* charlit */ );
1014         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1015            _token = makeToken(_ttype);
1016            _token->setText(text.substr(_begin, text.length()-_begin));
1017         }
1018         _returnToken = _token;
1019         _saveIndex=0;
1020 }
1021
1022 void RequirementLexer::mEQL(bool _createToken) {
1023         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1024         _ttype = EQL;
1025         std::string::size_type _saveIndex;
1026
1027         match('=' /* charlit */ );
1028         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1029            _token = makeToken(_ttype);
1030            _token->setText(text.substr(_begin, text.length()-_begin));
1031         }
1032         _returnToken = _token;
1033         _saveIndex=0;
1034 }
1035
1036 void RequirementLexer::mEQQL(bool _createToken) {
1037         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1038         _ttype = EQQL;
1039         std::string::size_type _saveIndex;
1040
1041         match("==");
1042         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1043            _token = makeToken(_ttype);
1044            _token->setText(text.substr(_begin, text.length()-_begin));
1045         }
1046         _returnToken = _token;
1047         _saveIndex=0;
1048 }
1049
1050 void RequirementLexer::mSUBS(bool _createToken) {
1051         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1052         _ttype = SUBS;
1053         std::string::size_type _saveIndex;
1054
1055         match('~' /* charlit */ );
1056         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1057            _token = makeToken(_ttype);
1058            _token->setText(text.substr(_begin, text.length()-_begin));
1059         }
1060         _returnToken = _token;
1061         _saveIndex=0;
1062 }
1063
1064 void RequirementLexer::mNEG(bool _createToken) {
1065         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1066         _ttype = NEG;
1067         std::string::size_type _saveIndex;
1068
1069         match('-' /* charlit */ );
1070         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1071            _token = makeToken(_ttype);
1072            _token->setText(text.substr(_begin, text.length()-_begin));
1073         }
1074         _returnToken = _token;
1075         _saveIndex=0;
1076 }
1077
1078 void RequirementLexer::mNOT(bool _createToken) {
1079         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1080         _ttype = NOT;
1081         std::string::size_type _saveIndex;
1082
1083         match('!' /* charlit */ );
1084         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1085            _token = makeToken(_ttype);
1086            _token->setText(text.substr(_begin, text.length()-_begin));
1087         }
1088         _returnToken = _token;
1089         _saveIndex=0;
1090 }
1091
1092 void RequirementLexer::mSTAR(bool _createToken) {
1093         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1094         _ttype = STAR;
1095         std::string::size_type _saveIndex;
1096
1097         match('*' /* charlit */ );
1098         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1099            _token = makeToken(_ttype);
1100            _token->setText(text.substr(_begin, text.length()-_begin));
1101         }
1102         _returnToken = _token;
1103         _saveIndex=0;
1104 }
1105
1106 void RequirementLexer::mWS(bool _createToken) {
1107         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1108         _ttype = WS;
1109         std::string::size_type _saveIndex;
1110
1111         { // ( ... )+
1112         int _cnt89=0;
1113         for (;;) {
1114                 switch ( LA(1)) {
1115                 case 0x20 /* ' ' */ :
1116                 {
1117                         match(' ' /* charlit */ );
1118                         break;
1119                 }
1120                 case 0xa /* '\n' */ :
1121                 {
1122                         match('\n' /* charlit */ );
1123                         newline();
1124                         break;
1125                 }
1126                 case 0x9 /* '\t' */ :
1127                 {
1128                         match('\t' /* charlit */ );
1129                         break;
1130                 }
1131                 default:
1132                 {
1133                         if ( _cnt89>=1 ) { goto _loop89; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1134                 }
1135                 }
1136                 _cnt89++;
1137         }
1138         _loop89:;
1139         }  // ( ... )+
1140         _ttype = antlr::Token::SKIP;
1141         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1142            _token = makeToken(_ttype);
1143            _token->setText(text.substr(_begin, text.length()-_begin));
1144         }
1145         _returnToken = _token;
1146         _saveIndex=0;
1147 }
1148
1149 void RequirementLexer::mSHELLCOMMENT(bool _createToken) {
1150         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1151         _ttype = SHELLCOMMENT;
1152         std::string::size_type _saveIndex;
1153
1154         match('#' /* charlit */ );
1155         { // ( ... )*
1156         for (;;) {
1157                 if ((_tokenSet_3.member(LA(1)))) {
1158                         matchNot('\n' /* charlit */ );
1159                 }
1160                 else {
1161                         goto _loop92;
1162                 }
1163
1164         }
1165         _loop92:;
1166         } // ( ... )*
1167         _ttype = antlr::Token::SKIP;
1168         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1169            _token = makeToken(_ttype);
1170            _token->setText(text.substr(_begin, text.length()-_begin));
1171         }
1172         _returnToken = _token;
1173         _saveIndex=0;
1174 }
1175
1176 void RequirementLexer::mC_COMMENT(bool _createToken) {
1177         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1178         _ttype = C_COMMENT;
1179         std::string::size_type _saveIndex;
1180
1181         match("/*");
1182         { // ( ... )*
1183         for (;;) {
1184                 if ((LA(1) == 0x2a /* '*' */ ) && (_tokenSet_4.member(LA(2)))) {
1185                         {
1186                         match('*' /* charlit */ );
1187                         {
1188                         matchNot('/' /* charlit */ );
1189                         }
1190                         }
1191                 }
1192                 else if ((_tokenSet_5.member(LA(1)))) {
1193                         {
1194                         matchNot('*' /* charlit */ );
1195                         }
1196                 }
1197                 else {
1198                         goto _loop98;
1199                 }
1200
1201         }
1202         _loop98:;
1203         } // ( ... )*
1204         match("*/");
1205         _ttype = antlr::Token::SKIP;
1206         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1207            _token = makeToken(_ttype);
1208            _token->setText(text.substr(_begin, text.length()-_begin));
1209         }
1210         _returnToken = _token;
1211         _saveIndex=0;
1212 }
1213
1214 void RequirementLexer::mCPP_COMMENT(bool _createToken) {
1215         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
1216         _ttype = CPP_COMMENT;
1217         std::string::size_type _saveIndex;
1218
1219         match("//");
1220         { // ( ... )*
1221         for (;;) {
1222                 if ((_tokenSet_3.member(LA(1)))) {
1223                         matchNot('\n' /* charlit */ );
1224                 }
1225                 else {
1226                         goto _loop101;
1227                 }
1228
1229         }
1230         _loop101:;
1231         } // ( ... )*
1232         _ttype = antlr::Token::SKIP;
1233         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
1234            _token = makeToken(_ttype);
1235            _token->setText(text.substr(_begin, text.length()-_begin));
1236         }
1237         _returnToken = _token;
1238         _saveIndex=0;
1239 }
1240
1241
1242 const unsigned long RequirementLexer::_tokenSet_0_data_[] = { 0UL, 0UL, 134217726UL, 134217726UL, 0UL, 0UL, 0UL, 0UL };
1243 const antlr::BitSet RequirementLexer::_tokenSet_0(_tokenSet_0_data_,8);
1244 const unsigned long RequirementLexer::_tokenSet_1_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL };
1245 // 0 1 2 3 4 5 6 7 8
1246 const antlr::BitSet RequirementLexer::_tokenSet_1(_tokenSet_1_data_,8);
1247 const unsigned long RequirementLexer::_tokenSet_2_data_[] = { 4294967295UL, 4294967291UL, 4026531839UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
1248 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1249 // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1250 // 0x1f   ! # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1251 const antlr::BitSet RequirementLexer::_tokenSet_2(_tokenSet_2_data_,8);
1252 const unsigned long RequirementLexer::_tokenSet_3_data_[] = { 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
1253 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xd 0xe 0xf 0x10 0x11
1254 // 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f
1255 //   ! \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1256 const antlr::BitSet RequirementLexer::_tokenSet_3(_tokenSet_3_data_,8);
1257 const unsigned long RequirementLexer::_tokenSet_4_data_[] = { 4294967295UL, 4294934527UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
1258 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1259 // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1260 // 0x1f   ! \" # $ % & \' ( ) * + , - . 0 1 2 3 4 5 6 7 8
1261 const antlr::BitSet RequirementLexer::_tokenSet_4(_tokenSet_4_data_,8);
1262 const unsigned long RequirementLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294966271UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
1263 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1264 // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1265 // 0x1f   ! \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8
1266 const antlr::BitSet RequirementLexer::_tokenSet_5(_tokenSet_5_data_,8);
1267
1268 ANTLR_END_NAMESPACE