]> 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-59754.80.3.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"
07691282
A		 15#include <libDER/libDER.h>
16#include <libDER/asn1Types.h>
b1ab9ed8
A		 17#include <security_utilities/cfutilities.h>
18#include <security_utilities/hashing.h>
19#include <security_cdsa_utilities/cssmdata.h> // OID coding
07691282 20#include <Security/SecCertificate.h>
b1ab9ed8
A		 21using namespace CodeSigning;
22typedef Requirement::Maker Maker;
23
07691282
A		 24extern "C" {
25
26/* Decode a choice of UTCTime or GeneralizedTime to a CFAbsoluteTime. Return
27an absoluteTime if the date was valid and properly decoded. Return
28NULL_TIME otherwise. */
29CFAbsoluteTime SecAbsoluteTimeFromDateContent(DERTag tag, const uint8_t *bytes,
30 size_t length);
31
32}
33
34
b1ab9ed8
A		 35ANTLR_BEGIN_NAMESPACE(Security_CodeSigning)
36RequirementLexer::RequirementLexer(std::istream& in)
37 : antlr::CharScanner(new antlr::CharBuffer(in),true)
38{
39 initLiterals();
40}
41
42RequirementLexer::RequirementLexer(antlr::InputBuffer& ib)
43 : antlr::CharScanner(ib,true)
44{
45 initLiterals();
46}
47
48RequirementLexer::RequirementLexer(const antlr::LexerSharedInputState& state)
49 : antlr::CharScanner(state,true)
50{
51 initLiterals();
52}
53
54void RequirementLexer::initLiterals()
55{
b54c578e 56 literals["certificate"] = 27;
5c19dc3a 57 literals["always"] = 15;
b1ab9ed8
A		 58 literals["host"] = 6;
59 literals["guest"] = 5;
5c19dc3a 60 literals["cdhash"] = 20;
b54c578e 61 literals["entitlement"] = 31;
b1ab9ed8 62 literals["library"] = 8;
b54c578e
A		 63 literals["timestamp"] = 53;
64 literals["legacy"] = 23;
5c19dc3a 65 literals["never"] = 17;
b54c578e 66 literals["cert"] = 28;
b1ab9ed8 67 literals["plugin"] = 9;
b54c578e 68 literals["absent"] = 33;
5c19dc3a 69 literals["or"] = 10;
b54c578e
A		 70 literals["leaf"] = 45;
71 literals["info"] = 30;
b1ab9ed8 72 literals["designated"] = 7;
b54c578e
A		 73 literals["apple"] = 25;
74 literals["trusted"] = 29;
5c19dc3a 75 literals["true"] = 16;
79b9da22 76 literals["notarized"] = 22;
5c19dc3a 77 literals["and"] = 11;
b54c578e 78 literals["root"] = 46;
5c19dc3a 79 literals["platform"] = 21;
b54c578e 80 literals["anchor"] = 24;
5c19dc3a 81 literals["false"] = 18;
b54c578e 82 literals["generic"] = 26;
5c19dc3a 83 literals["identifier"] = 19;
b54c578e 84 literals["exists"] = 32;
b1ab9ed8
A		 85}
86
87antlr::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 }
258tryAgain:;
259 }
260}
261
262void 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 {
07691282 414 goto _loop49;
b1ab9ed8
A		 415 }
416 }
417 }
07691282 418 _loop49:;
b1ab9ed8
A		 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
429void 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 {
07691282 519 goto _loop53;
b1ab9ed8
A		 520 }
521
522 }
07691282 523 _loop53:;
b1ab9ed8
A		 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
534void 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 { // ( ... )+
07691282 540 int _cnt71=0;
b1ab9ed8
A		 541 for (;;) {
542 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
543 matchRange('0','9');
544 }
545 else {
07691282 546 if ( _cnt71>=1 ) { goto _loop71; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
b1ab9ed8
A		 547 }
548
07691282 549 _cnt71++;
b1ab9ed8 550 }
07691282 551 _loop71:;
b1ab9ed8
A		 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
561void 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 { // ( ... )+
07691282 569 int _cnt56=0;
b1ab9ed8
A		 570 for (;;) {
571 if ((LA(1) == 0x2f /* '/' */ )) {
572 match("/");
573 mIDENT(false);
574 }
575 else {
07691282 576 if ( _cnt56>=1 ) { goto _loop56; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
b1ab9ed8
A		 577 }
578
07691282 579 _cnt56++;
b1ab9ed8 580 }
07691282 581 _loop56:;
b1ab9ed8
A		 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
591void 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 { // ( ... )+
07691282 603 int _cnt59=0;
b1ab9ed8
A		 604 for (;;) {
605 if ((_tokenSet_1.member(LA(1)))) {
606 mHEX(false);
607 }
608 else {
07691282 609 if ( _cnt59>=1 ) { goto _loop59; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
b1ab9ed8
A		 610 }
611
07691282 612 _cnt59++;
b1ab9ed8 613 }
07691282 614 _loop59:;
b1ab9ed8
A		 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
627void 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
680void 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 { // ( ... )+
07691282 692 int _cnt62=0;
b1ab9ed8
A		 693 for (;;) {
694 if ((_tokenSet_1.member(LA(1)))) {
695 mHEX(false);
696 }
697 else {
07691282 698 if ( _cnt62>=1 ) { goto _loop62; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
b1ab9ed8
A		 699 }
700
07691282 701 _cnt62++;
b1ab9ed8 702 }
07691282 703 _loop62:;
b1ab9ed8
A		 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
713void 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 (;;) {
dbe77505 723 if ((LA(1) == 0x5c /* '\\' */ )) {
b1ab9ed8
A		 724 {
725 _saveIndex = text.length();
726 match('\\' /* charlit */ );
727 text.erase(_saveIndex);
728 match('\"' /* charlit */ );
729 }
b1ab9ed8 730 }
dbe77505 731 else if ((_tokenSet_2.member(LA(1)))) {
b1ab9ed8
A		 732 {
733 {
734 match(_tokenSet_2);
735 }
736 }
b1ab9ed8 737 }
dbe77505 738 else {
07691282 739 goto _loop68;
b1ab9ed8 740 }
dbe77505 741
b1ab9ed8 742 }
07691282 743 _loop68:;
b1ab9ed8
A		 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
756void 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
770void 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
784void 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
798void 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
812void 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
826void 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
840void 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
854void 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
868void 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
882void 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
896void 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
910void 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
924void 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
938void 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
952void 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
966void 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
980void 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
994void 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 { // ( ... )+
07691282 1000 int _cnt92=0;
b1ab9ed8
A		 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 {
07691282 1021 if ( _cnt92>=1 ) { goto _loop92; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
b1ab9ed8
A		 1022 }
1023 }
07691282 1024 _cnt92++;
b1ab9ed8 1025 }
07691282 1026 _loop92:;
b1ab9ed8
A		 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
1037void 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 {
07691282 1049 goto _loop95;
b1ab9ed8
A		 1050 }
1051
1052 }
07691282 1053 _loop95:;
b1ab9ed8
A		 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
1064void 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 {
07691282 1086 goto _loop101;
b1ab9ed8
A		 1087 }
1088
1089 }
07691282 1090 _loop101:;
b1ab9ed8
A		 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
1102void 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 {
07691282 1114 goto _loop104;
b1ab9ed8
A		 1115 }
1116
1117 }
07691282 1118 _loop104:;
b1ab9ed8
A		 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
dbe77505
A		 1130const unsigned long RequirementLexer::_tokenSet_0_data_[] = { 0UL, 0UL, 134217726UL, 134217726UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1131const antlr::BitSet RequirementLexer::_tokenSet_0(_tokenSet_0_data_,10);
1132const unsigned long RequirementLexer::_tokenSet_1_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
5c19dc3a 1133// 0 1 2 3 4 5 6 7 8 9
dbe77505
A		 1134const antlr::BitSet RequirementLexer::_tokenSet_1(_tokenSet_1_data_,10);
1135const unsigned long RequirementLexer::_tokenSet_2_data_[] = { 4294967295UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967292UL, 2097151UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
b1ab9ed8
A		 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
b54c578e 1138// 0x1f ! # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =
dbe77505
A		 1139const antlr::BitSet RequirementLexer::_tokenSet_2(_tokenSet_2_data_,16);
1140const unsigned long RequirementLexer::_tokenSet_3_data_[] = { 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967292UL, 2097151UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
b1ab9ed8
A		 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
b54c578e 1143// ! \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =
dbe77505
A		 1144const antlr::BitSet RequirementLexer::_tokenSet_3(_tokenSet_3_data_,16);
1145const unsigned long RequirementLexer::_tokenSet_4_data_[] = { 4294967295UL, 4294934527UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967292UL, 2097151UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
b1ab9ed8
A		 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
b54c578e 1148// 0x1f ! \" # $ % & \' ( ) * + , - . 0 1 2 3 4 5 6 7 8 9 : ; < =
dbe77505
A		 1149const antlr::BitSet RequirementLexer::_tokenSet_4(_tokenSet_4_data_,16);
1150const unsigned long RequirementLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967292UL, 2097151UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
b1ab9ed8
A		 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
b54c578e 1153// 0x1f ! \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =
dbe77505 1154const antlr::BitSet RequirementLexer::_tokenSet_5(_tokenSet_5_data_,16);
b1ab9ed8
A		 1155
1156ANTLR_END_NAMESPACE
mirror of Security