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