OSX/libsecurity_codesigning/lib/RequirementLexer.cpp

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