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