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