ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDLexer.cpp
Revision: 2469
Committed: Fri Dec 2 15:38:03 2005 UTC (18 years, 7 months ago) by tim
File size: 49653 byte(s)
Log Message: 
End of the Link --> List
Return of the Oject-Oriented
replace yacc/lex parser with antlr parser

File Contents

# Content
1 /* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
2 #include "MDLexer.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 #line 1 "MDParser.g"
12 #line 13 "MDLexer.cpp"
13 MDLexer::MDLexer(ANTLR_USE_NAMESPACE(std)istream& in)
14 : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true)
15 {
16 initLiterals();
17 }
18
19 MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
20 : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
21 {
22 initLiterals();
23 }
24
25 MDLexer::MDLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
26 : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true)
27 {
28 initLiterals();
29 }
30
31 void MDLexer::initLiterals()
32 {
33 literals["members"] = 14;
34 literals["position"] = 15;
35 literals["torsion"] = 10;
36 literals["component"] = 4;
37 literals["rigidBody"] = 11;
38 literals["zconstraint"] = 6;
39 literals["cutoffGroup"] = 12;
40 literals["bend"] = 9;
41 literals["orientation"] = 16;
42 literals["fragment"] = 13;
43 literals["bond"] = 8;
44 literals["molecule"] = 5;
45 literals["atom"] = 7;
46 }
47
48 ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
49 {
50 ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
51 for (;;) {
52 ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
53 int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
54 resetText();
55 try { // for lexical and char stream error handling
56 switch ( LA(1)) {
57 case 0x3d /* '=' */ :
58 {
59 mASSIGNEQUAL(true);
60 theRetToken=_returnToken;
61 break;
62 }
63 case 0x3a /* ':' */ :
64 {
65 mCOLON(true);
66 theRetToken=_returnToken;
67 break;
68 }
69 case 0x2c /* ',' */ :
70 {
71 mCOMMA(true);
72 theRetToken=_returnToken;
73 break;
74 }
75 case 0x3f /* '?' */ :
76 {
77 mQUESTIONMARK(true);
78 theRetToken=_returnToken;
79 break;
80 }
81 case 0x3b /* ';' */ :
82 {
83 mSEMICOLON(true);
84 theRetToken=_returnToken;
85 break;
86 }
87 case 0x28 /* '(' */ :
88 {
89 mLPAREN(true);
90 theRetToken=_returnToken;
91 break;
92 }
93 case 0x29 /* ')' */ :
94 {
95 mRPAREN(true);
96 theRetToken=_returnToken;
97 break;
98 }
99 case 0x5b /* '[' */ :
100 {
101 mLBRACKET(true);
102 theRetToken=_returnToken;
103 break;
104 }
105 case 0x5d /* ']' */ :
106 {
107 mRBRACKET(true);
108 theRetToken=_returnToken;
109 break;
110 }
111 case 0x7b /* '{' */ :
112 {
113 mLCURLY(true);
114 theRetToken=_returnToken;
115 break;
116 }
117 case 0x7d /* '}' */ :
118 {
119 mRCURLY(true);
120 theRetToken=_returnToken;
121 break;
122 }
123 case 0x2b /* '+' */ :
124 {
125 mPLUS(true);
126 theRetToken=_returnToken;
127 break;
128 }
129 case 0x2d /* '-' */ :
130 {
131 mMINUS(true);
132 theRetToken=_returnToken;
133 break;
134 }
135 case 0x9 /* '\t' */ :
136 case 0xa /* '\n' */ :
137 case 0xc /* '\14' */ :
138 case 0xd /* '\r' */ :
139 case 0x20 /* ' ' */ :
140 case 0x5c /* '\\' */ :
141 {
142 mWhitespace(true);
143 theRetToken=_returnToken;
144 break;
145 }
146 case 0x23 /* '#' */ :
147 {
148 mPREPROC_DIRECTIVE(true);
149 theRetToken=_returnToken;
150 break;
151 }
152 case 0x22 /* '\"' */ :
153 {
154 mStringLiteral(true);
155 theRetToken=_returnToken;
156 break;
157 }
158 case 0x27 /* '\'' */ :
159 {
160 mCharLiteral(true);
161 theRetToken=_returnToken;
162 break;
163 }
164 case 0x2e /* '.' */ :
165 case 0x30 /* '0' */ :
166 case 0x31 /* '1' */ :
167 case 0x32 /* '2' */ :
168 case 0x33 /* '3' */ :
169 case 0x34 /* '4' */ :
170 case 0x35 /* '5' */ :
171 case 0x36 /* '6' */ :
172 case 0x37 /* '7' */ :
173 case 0x38 /* '8' */ :
174 case 0x39 /* '9' */ :
175 {
176 mNumber(true);
177 theRetToken=_returnToken;
178 break;
179 }
180 case 0x41 /* 'A' */ :
181 case 0x42 /* 'B' */ :
182 case 0x43 /* 'C' */ :
183 case 0x44 /* 'D' */ :
184 case 0x45 /* 'E' */ :
185 case 0x46 /* 'F' */ :
186 case 0x47 /* 'G' */ :
187 case 0x48 /* 'H' */ :
188 case 0x49 /* 'I' */ :
189 case 0x4a /* 'J' */ :
190 case 0x4b /* 'K' */ :
191 case 0x4c /* 'L' */ :
192 case 0x4d /* 'M' */ :
193 case 0x4e /* 'N' */ :
194 case 0x4f /* 'O' */ :
195 case 0x50 /* 'P' */ :
196 case 0x51 /* 'Q' */ :
197 case 0x52 /* 'R' */ :
198 case 0x53 /* 'S' */ :
199 case 0x54 /* 'T' */ :
200 case 0x55 /* 'U' */ :
201 case 0x56 /* 'V' */ :
202 case 0x57 /* 'W' */ :
203 case 0x58 /* 'X' */ :
204 case 0x59 /* 'Y' */ :
205 case 0x5a /* 'Z' */ :
206 case 0x5f /* '_' */ :
207 case 0x61 /* 'a' */ :
208 case 0x62 /* 'b' */ :
209 case 0x63 /* 'c' */ :
210 case 0x64 /* 'd' */ :
211 case 0x65 /* 'e' */ :
212 case 0x66 /* 'f' */ :
213 case 0x67 /* 'g' */ :
214 case 0x68 /* 'h' */ :
215 case 0x69 /* 'i' */ :
216 case 0x6a /* 'j' */ :
217 case 0x6b /* 'k' */ :
218 case 0x6c /* 'l' */ :
219 case 0x6d /* 'm' */ :
220 case 0x6e /* 'n' */ :
221 case 0x6f /* 'o' */ :
222 case 0x70 /* 'p' */ :
223 case 0x71 /* 'q' */ :
224 case 0x72 /* 'r' */ :
225 case 0x73 /* 's' */ :
226 case 0x74 /* 't' */ :
227 case 0x75 /* 'u' */ :
228 case 0x76 /* 'v' */ :
229 case 0x77 /* 'w' */ :
230 case 0x78 /* 'x' */ :
231 case 0x79 /* 'y' */ :
232 case 0x7a /* 'z' */ :
233 {
234 mID(true);
235 theRetToken=_returnToken;
236 break;
237 }
238 default:
239 if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
240 mComment(true);
241 theRetToken=_returnToken;
242 }
243 else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) {
244 mCPPComment(true);
245 theRetToken=_returnToken;
246 }
247 else {
248 if (LA(1)==EOF_CHAR)
249 {
250 uponEOF();
251 _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
252 }
253 else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
254 }
255 }
256 if ( !_returnToken )
257 goto tryAgain; // found SKIP token
258
259 _ttype = _returnToken->getType();
260 _returnToken->setType(_ttype);
261 return _returnToken;
262 }
263 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
264 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
265 }
266 catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
267 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
268 }
269 catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
270 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
271 }
272 tryAgain:;
273 }
274 }
275
276 void MDLexer::mASSIGNEQUAL(bool _createToken) {
277 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
278 _ttype = ASSIGNEQUAL;
279 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
280
281 match('=' /* charlit */ );
282 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
283 _token = makeToken(_ttype);
284 _token->setText(text.substr(_begin, text.length()-_begin));
285 }
286 _returnToken = _token;
287 _saveIndex=0;
288 }
289
290 void MDLexer::mCOLON(bool _createToken) {
291 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
292 _ttype = COLON;
293 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
294
295 match(':' /* charlit */ );
296 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
297 _token = makeToken(_ttype);
298 _token->setText(text.substr(_begin, text.length()-_begin));
299 }
300 _returnToken = _token;
301 _saveIndex=0;
302 }
303
304 void MDLexer::mCOMMA(bool _createToken) {
305 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
306 _ttype = COMMA;
307 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
308
309 match(',' /* charlit */ );
310 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
311 _token = makeToken(_ttype);
312 _token->setText(text.substr(_begin, text.length()-_begin));
313 }
314 _returnToken = _token;
315 _saveIndex=0;
316 }
317
318 void MDLexer::mQUESTIONMARK(bool _createToken) {
319 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
320 _ttype = QUESTIONMARK;
321 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
322
323 match('?' /* charlit */ );
324 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
325 _token = makeToken(_ttype);
326 _token->setText(text.substr(_begin, text.length()-_begin));
327 }
328 _returnToken = _token;
329 _saveIndex=0;
330 }
331
332 void MDLexer::mSEMICOLON(bool _createToken) {
333 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
334 _ttype = SEMICOLON;
335 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
336
337 match(';' /* charlit */ );
338 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
339 _token = makeToken(_ttype);
340 _token->setText(text.substr(_begin, text.length()-_begin));
341 }
342 _returnToken = _token;
343 _saveIndex=0;
344 }
345
346 void MDLexer::mLPAREN(bool _createToken) {
347 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
348 _ttype = LPAREN;
349 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
350
351 match('(' /* charlit */ );
352 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
353 _token = makeToken(_ttype);
354 _token->setText(text.substr(_begin, text.length()-_begin));
355 }
356 _returnToken = _token;
357 _saveIndex=0;
358 }
359
360 void MDLexer::mRPAREN(bool _createToken) {
361 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
362 _ttype = RPAREN;
363 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
364
365 match(')' /* charlit */ );
366 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
367 _token = makeToken(_ttype);
368 _token->setText(text.substr(_begin, text.length()-_begin));
369 }
370 _returnToken = _token;
371 _saveIndex=0;
372 }
373
374 void MDLexer::mLBRACKET(bool _createToken) {
375 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
376 _ttype = LBRACKET;
377 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
378
379 match('[' /* charlit */ );
380 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
381 _token = makeToken(_ttype);
382 _token->setText(text.substr(_begin, text.length()-_begin));
383 }
384 _returnToken = _token;
385 _saveIndex=0;
386 }
387
388 void MDLexer::mRBRACKET(bool _createToken) {
389 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
390 _ttype = RBRACKET;
391 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
392
393 match(']' /* charlit */ );
394 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
395 _token = makeToken(_ttype);
396 _token->setText(text.substr(_begin, text.length()-_begin));
397 }
398 _returnToken = _token;
399 _saveIndex=0;
400 }
401
402 void MDLexer::mLCURLY(bool _createToken) {
403 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
404 _ttype = LCURLY;
405 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
406
407 match('{' /* charlit */ );
408 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
409 _token = makeToken(_ttype);
410 _token->setText(text.substr(_begin, text.length()-_begin));
411 }
412 _returnToken = _token;
413 _saveIndex=0;
414 }
415
416 void MDLexer::mRCURLY(bool _createToken) {
417 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
418 _ttype = RCURLY;
419 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
420
421 match('}' /* charlit */ );
422 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
423 _token = makeToken(_ttype);
424 _token->setText(text.substr(_begin, text.length()-_begin));
425 }
426 _returnToken = _token;
427 _saveIndex=0;
428 }
429
430 void MDLexer::mPLUS(bool _createToken) {
431 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
432 _ttype = PLUS;
433 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
434
435 match('+' /* charlit */ );
436 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
437 _token = makeToken(_ttype);
438 _token->setText(text.substr(_begin, text.length()-_begin));
439 }
440 _returnToken = _token;
441 _saveIndex=0;
442 }
443
444 void MDLexer::mMINUS(bool _createToken) {
445 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
446 _ttype = MINUS;
447 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
448
449 match('-' /* charlit */ );
450 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
451 _token = makeToken(_ttype);
452 _token->setText(text.substr(_begin, text.length()-_begin));
453 }
454 _returnToken = _token;
455 _saveIndex=0;
456 }
457
458 void MDLexer::mWhitespace(bool _createToken) {
459 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
460 _ttype = Whitespace;
461 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
462
463 {
464 switch ( LA(1)) {
465 case 0x9 /* '\t' */ :
466 case 0xc /* '\14' */ :
467 case 0x20 /* ' ' */ :
468 {
469 {
470 switch ( LA(1)) {
471 case 0x20 /* ' ' */ :
472 {
473 match(' ' /* charlit */ );
474 break;
475 }
476 case 0x9 /* '\t' */ :
477 {
478 match('\t' /* charlit */ );
479 break;
480 }
481 case 0xc /* '\14' */ :
482 {
483 match('\14' /* charlit */ );
484 break;
485 }
486 default:
487 {
488 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
489 }
490 }
491 }
492 break;
493 }
494 case 0xa /* '\n' */ :
495 case 0xd /* '\r' */ :
496 {
497 {
498 if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
499 match('\r' /* charlit */ );
500 match('\n' /* charlit */ );
501 }
502 else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
503 match('\r' /* charlit */ );
504 }
505 else if ((LA(1) == 0xa /* '\n' */ )) {
506 match('\n' /* charlit */ );
507 }
508 else {
509 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
510 }
511
512 }
513 if ( inputState->guessing==0 ) {
514 #line 262 "MDParser.g"
515 newline();
516 #line 517 "MDLexer.cpp"
517 }
518 break;
519 }
520 case 0x5c /* '\\' */ :
521 {
522 {
523 if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
524 match('\\' /* charlit */ );
525 match('\r' /* charlit */ );
526 match('\n' /* charlit */ );
527 }
528 else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
529 match('\\' /* charlit */ );
530 match('\r' /* charlit */ );
531 }
532 else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
533 match('\\' /* charlit */ );
534 match('\n' /* charlit */ );
535 }
536 else {
537 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
538 }
539
540 }
541 if ( inputState->guessing==0 ) {
542 #line 267 "MDParser.g"
543 printf("CPP_parser.g continuation line detected\n");
544 deferredNewline();
545 #line 546 "MDLexer.cpp"
546 }
547 break;
548 }
549 default:
550 {
551 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
552 }
553 }
554 }
555 if ( inputState->guessing==0 ) {
556 #line 270 "MDParser.g"
557 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
558 #line 559 "MDLexer.cpp"
559 }
560 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
561 _token = makeToken(_ttype);
562 _token->setText(text.substr(_begin, text.length()-_begin));
563 }
564 _returnToken = _token;
565 _saveIndex=0;
566 }
567
568 void MDLexer::mComment(bool _createToken) {
569 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
570 _ttype = Comment;
571 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
572
573 match("/*");
574 { // ( ... )*
575 for (;;) {
576 if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */ && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */ && LA(3) <= 0xff)))&&(LA(2) != '/')) {
577 match('*' /* charlit */ );
578 }
579 else if ((LA(1) == 0xa /* '\n' */ || LA(1) == 0xd /* '\r' */ )) {
580 mEndOfLine(false);
581 if ( inputState->guessing==0 ) {
582 #line 277 "MDParser.g"
583 deferredNewline();
584 #line 585 "MDLexer.cpp"
585 }
586 }
587 else if ((_tokenSet_0.member(LA(1)))) {
588 {
589 match(_tokenSet_0);
590 }
591 }
592 else {
593 goto _loop81;
594 }
595
596 }
597 _loop81:;
598 } // ( ... )*
599 match("*/");
600 if ( inputState->guessing==0 ) {
601 #line 280 "MDParser.g"
602 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
603 #line 604 "MDLexer.cpp"
604 }
605 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
606 _token = makeToken(_ttype);
607 _token->setText(text.substr(_begin, text.length()-_begin));
608 }
609 _returnToken = _token;
610 _saveIndex=0;
611 }
612
613 void MDLexer::mEndOfLine(bool _createToken) {
614 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
615 _ttype = EndOfLine;
616 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
617
618 {
619 if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
620 match("\r\n");
621 }
622 else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
623 match('\r' /* charlit */ );
624 }
625 else if ((LA(1) == 0xa /* '\n' */ )) {
626 match('\n' /* charlit */ );
627 }
628 else {
629 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
630 }
631
632 }
633 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
634 _token = makeToken(_ttype);
635 _token->setText(text.substr(_begin, text.length()-_begin));
636 }
637 _returnToken = _token;
638 _saveIndex=0;
639 }
640
641 void MDLexer::mCPPComment(bool _createToken) {
642 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
643 _ttype = CPPComment;
644 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
645
646 match("//");
647 { // ( ... )*
648 for (;;) {
649 if ((_tokenSet_1.member(LA(1)))) {
650 {
651 match(_tokenSet_1);
652 }
653 }
654 else {
655 goto _loop85;
656 }
657
658 }
659 _loop85:;
660 } // ( ... )*
661 mEndOfLine(false);
662 if ( inputState->guessing==0 ) {
663 #line 286 "MDParser.g"
664 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
665 #line 666 "MDLexer.cpp"
666 }
667 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
668 _token = makeToken(_ttype);
669 _token->setText(text.substr(_begin, text.length()-_begin));
670 }
671 _returnToken = _token;
672 _saveIndex=0;
673 }
674
675 void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
676 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
677 _ttype = PREPROC_DIRECTIVE;
678 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
679
680 match('#' /* charlit */ );
681 mLineDirective(false);
682 if ( inputState->guessing==0 ) {
683 #line 293 "MDParser.g"
684 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
685 #line 686 "MDLexer.cpp"
686 }
687 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(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
695 void MDLexer::mLineDirective(bool _createToken) {
696 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
697 _ttype = LineDirective;
698 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
699 ANTLR_USE_NAMESPACE(antlr)RefToken n;
700 ANTLR_USE_NAMESPACE(antlr)RefToken sl;
701
702 if ( inputState->guessing==0 ) {
703 #line 299 "MDParser.g"
704
705 deferredLineCount = 0;
706
707 #line 708 "MDLexer.cpp"
708 }
709 {
710 switch ( LA(1)) {
711 case 0x6c /* 'l' */ :
712 {
713 match("line");
714 break;
715 }
716 case 0x9 /* '\t' */ :
717 case 0xc /* '\14' */ :
718 case 0x20 /* ' ' */ :
719 {
720 break;
721 }
722 default:
723 {
724 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
725 }
726 }
727 }
728 { // ( ... )+
729 int _cnt90=0;
730 for (;;) {
731 if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) {
732 mSpace(false);
733 }
734 else {
735 if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
736 }
737
738 _cnt90++;
739 }
740 _loop90:;
741 } // ( ... )+
742 mDecimal(true);
743 n=_returnToken;
744 if ( inputState->guessing==0 ) {
745 #line 304 "MDParser.g"
746 setLine(oopse::lexi_cast<int>(n->getText()) - 1);
747 #line 748 "MDLexer.cpp"
748 }
749 { // ( ... )+
750 int _cnt92=0;
751 for (;;) {
752 if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) {
753 mSpace(false);
754 }
755 else {
756 if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
757 }
758
759 _cnt92++;
760 }
761 _loop92:;
762 } // ( ... )+
763 {
764 mStringLiteral(true);
765 sl=_returnToken;
766 }
767 if ( inputState->guessing==0 ) {
768 #line 306 "MDParser.g"
769 std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
770 #line 771 "MDLexer.cpp"
771 }
772 { // ( ... )*
773 for (;;) {
774 if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) {
775 { // ( ... )+
776 int _cnt96=0;
777 for (;;) {
778 if ((LA(1) == 0x9 /* '\t' */ || LA(1) == 0xc /* '\14' */ || LA(1) == 0x20 /* ' ' */ )) {
779 mSpace(false);
780 }
781 else {
782 if ( _cnt96>=1 ) { goto _loop96; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
783 }
784
785 _cnt96++;
786 }
787 _loop96:;
788 } // ( ... )+
789 mDecimal(false);
790 }
791 else {
792 goto _loop97;
793 }
794
795 }
796 _loop97:;
797 } // ( ... )*
798 mEndOfLine(false);
799 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
800 _token = makeToken(_ttype);
801 _token->setText(text.substr(_begin, text.length()-_begin));
802 }
803 _returnToken = _token;
804 _saveIndex=0;
805 }
806
807 void MDLexer::mSpace(bool _createToken) {
808 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
809 _ttype = Space;
810 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
811
812 {
813 switch ( LA(1)) {
814 case 0x20 /* ' ' */ :
815 {
816 match(' ' /* charlit */ );
817 break;
818 }
819 case 0x9 /* '\t' */ :
820 {
821 match('\t' /* charlit */ );
822 break;
823 }
824 case 0xc /* '\14' */ :
825 {
826 match('\14' /* charlit */ );
827 break;
828 }
829 default:
830 {
831 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
832 }
833 }
834 }
835 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
836 _token = makeToken(_ttype);
837 _token->setText(text.substr(_begin, text.length()-_begin));
838 }
839 _returnToken = _token;
840 _saveIndex=0;
841 }
842
843 void MDLexer::mDecimal(bool _createToken) {
844 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
845 _ttype = Decimal;
846 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
847
848 { // ( ... )+
849 int _cnt122=0;
850 for (;;) {
851 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
852 matchRange('0','9');
853 }
854 else {
855 if ( _cnt122>=1 ) { goto _loop122; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
856 }
857
858 _cnt122++;
859 }
860 _loop122:;
861 } // ( ... )+
862 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(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
870 void MDLexer::mStringLiteral(bool _createToken) {
871 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
872 _ttype = StringLiteral;
873 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
874
875 match('\"' /* charlit */ );
876 { // ( ... )*
877 for (;;) {
878 if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
879 mEscape(false);
880 }
881 else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ || LA(2) == 0xd /* '\r' */ )) {
882 {
883 if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
884 match("\\\r\n");
885 }
886 else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
887 match("\\\r");
888 }
889 else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
890 match("\\\n");
891 }
892 else {
893 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
894 }
895
896 }
897 if ( inputState->guessing==0 ) {
898 #line 346 "MDParser.g"
899 deferredNewline();
900 #line 901 "MDLexer.cpp"
901 }
902 }
903 else if ((_tokenSet_3.member(LA(1)))) {
904 {
905 match(_tokenSet_3);
906 }
907 }
908 else {
909 goto _loop107;
910 }
911
912 }
913 _loop107:;
914 } // ( ... )*
915 match('\"' /* charlit */ );
916 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
917 _token = makeToken(_ttype);
918 _token->setText(text.substr(_begin, text.length()-_begin));
919 }
920 _returnToken = _token;
921 _saveIndex=0;
922 }
923
924 void MDLexer::mCharLiteral(bool _createToken) {
925 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
926 _ttype = CharLiteral;
927 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
928
929 match('\'' /* charlit */ );
930 {
931 if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
932 mEscape(false);
933 }
934 else if ((_tokenSet_5.member(LA(1))) && (LA(2) == 0x27 /* '\'' */ ) && (true)) {
935 {
936 match(_tokenSet_5);
937 }
938 }
939 else {
940 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
941 }
942
943 }
944 match('\'' /* charlit */ );
945 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(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
953 void MDLexer::mEscape(bool _createToken) {
954 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
955 _ttype = Escape;
956 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
957
958 match('\\' /* charlit */ );
959 {
960 switch ( LA(1)) {
961 case 0x61 /* 'a' */ :
962 {
963 match('a' /* charlit */ );
964 break;
965 }
966 case 0x62 /* 'b' */ :
967 {
968 match('b' /* charlit */ );
969 break;
970 }
971 case 0x66 /* 'f' */ :
972 {
973 match('f' /* charlit */ );
974 break;
975 }
976 case 0x6e /* 'n' */ :
977 {
978 match('n' /* charlit */ );
979 break;
980 }
981 case 0x72 /* 'r' */ :
982 {
983 match('r' /* charlit */ );
984 break;
985 }
986 case 0x74 /* 't' */ :
987 {
988 match('t' /* charlit */ );
989 break;
990 }
991 case 0x76 /* 'v' */ :
992 {
993 match('v' /* charlit */ );
994 break;
995 }
996 case 0x22 /* '\"' */ :
997 {
998 match('\"' /* charlit */ );
999 break;
1000 }
1001 case 0x27 /* '\'' */ :
1002 {
1003 match('\'' /* charlit */ );
1004 break;
1005 }
1006 case 0x5c /* '\\' */ :
1007 {
1008 match('\\' /* charlit */ );
1009 break;
1010 }
1011 case 0x3f /* '?' */ :
1012 {
1013 match('?' /* charlit */ );
1014 break;
1015 }
1016 case 0x30 /* '0' */ :
1017 case 0x31 /* '1' */ :
1018 case 0x32 /* '2' */ :
1019 case 0x33 /* '3' */ :
1020 {
1021 {
1022 matchRange('0','3');
1023 }
1024 {
1025 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1026 mDigit(false);
1027 {
1028 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1029 mDigit(false);
1030 }
1031 else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
1032 }
1033 else {
1034 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1035 }
1036
1037 }
1038 }
1039 else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
1040 }
1041 else {
1042 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1043 }
1044
1045 }
1046 break;
1047 }
1048 case 0x34 /* '4' */ :
1049 case 0x35 /* '5' */ :
1050 case 0x36 /* '6' */ :
1051 case 0x37 /* '7' */ :
1052 {
1053 {
1054 matchRange('4','7');
1055 }
1056 {
1057 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1058 mDigit(false);
1059 }
1060 else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
1061 }
1062 else {
1063 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1064 }
1065
1066 }
1067 break;
1068 }
1069 case 0x78 /* 'x' */ :
1070 {
1071 match('x' /* charlit */ );
1072 { // ( ... )+
1073 int _cnt118=0;
1074 for (;;) {
1075 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1076 mDigit(false);
1077 }
1078 else if (((LA(1) >= 0x61 /* 'a' */ && LA(1) <= 0x66 /* 'f' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1079 matchRange('a','f');
1080 }
1081 else if (((LA(1) >= 0x41 /* 'A' */ && LA(1) <= 0x46 /* 'F' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1082 matchRange('A','F');
1083 }
1084 else {
1085 if ( _cnt118>=1 ) { goto _loop118; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1086 }
1087
1088 _cnt118++;
1089 }
1090 _loop118:;
1091 } // ( ... )+
1092 break;
1093 }
1094 default:
1095 {
1096 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1097 }
1098 }
1099 }
1100 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(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
1108 void MDLexer::mDigit(bool _createToken) {
1109 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1110 _ttype = Digit;
1111 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1112
1113 matchRange('0','9');
1114 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1115 _token = makeToken(_ttype);
1116 _token->setText(text.substr(_begin, text.length()-_begin));
1117 }
1118 _returnToken = _token;
1119 _saveIndex=0;
1120 }
1121
1122 void MDLexer::mLongSuffix(bool _createToken) {
1123 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1124 _ttype = LongSuffix;
1125 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1126
1127 switch ( LA(1)) {
1128 case 0x6c /* 'l' */ :
1129 {
1130 match('l' /* charlit */ );
1131 break;
1132 }
1133 case 0x4c /* 'L' */ :
1134 {
1135 match('L' /* charlit */ );
1136 break;
1137 }
1138 default:
1139 {
1140 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1141 }
1142 }
1143 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(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
1151 void MDLexer::mUnsignedSuffix(bool _createToken) {
1152 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1153 _ttype = UnsignedSuffix;
1154 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1155
1156 switch ( LA(1)) {
1157 case 0x75 /* 'u' */ :
1158 {
1159 match('u' /* charlit */ );
1160 break;
1161 }
1162 case 0x55 /* 'U' */ :
1163 {
1164 match('U' /* charlit */ );
1165 break;
1166 }
1167 default:
1168 {
1169 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1170 }
1171 }
1172 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1173 _token = makeToken(_ttype);
1174 _token->setText(text.substr(_begin, text.length()-_begin));
1175 }
1176 _returnToken = _token;
1177 _saveIndex=0;
1178 }
1179
1180 void MDLexer::mFloatSuffix(bool _createToken) {
1181 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1182 _ttype = FloatSuffix;
1183 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1184
1185 switch ( LA(1)) {
1186 case 0x66 /* 'f' */ :
1187 {
1188 match('f' /* charlit */ );
1189 break;
1190 }
1191 case 0x46 /* 'F' */ :
1192 {
1193 match('F' /* charlit */ );
1194 break;
1195 }
1196 default:
1197 {
1198 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1199 }
1200 }
1201 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1202 _token = makeToken(_ttype);
1203 _token->setText(text.substr(_begin, text.length()-_begin));
1204 }
1205 _returnToken = _token;
1206 _saveIndex=0;
1207 }
1208
1209 void MDLexer::mExponent(bool _createToken) {
1210 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1211 _ttype = Exponent;
1212 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1213
1214 {
1215 switch ( LA(1)) {
1216 case 0x65 /* 'e' */ :
1217 {
1218 match('e' /* charlit */ );
1219 break;
1220 }
1221 case 0x45 /* 'E' */ :
1222 {
1223 match('E' /* charlit */ );
1224 break;
1225 }
1226 case 0x64 /* 'd' */ :
1227 {
1228 match('d' /* charlit */ );
1229 break;
1230 }
1231 case 0x44 /* 'D' */ :
1232 {
1233 match('D' /* charlit */ );
1234 break;
1235 }
1236 default:
1237 {
1238 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1239 }
1240 }
1241 }
1242 {
1243 switch ( LA(1)) {
1244 case 0x2b /* '+' */ :
1245 {
1246 match('+' /* charlit */ );
1247 break;
1248 }
1249 case 0x2d /* '-' */ :
1250 {
1251 match('-' /* charlit */ );
1252 break;
1253 }
1254 case 0x30 /* '0' */ :
1255 case 0x31 /* '1' */ :
1256 case 0x32 /* '2' */ :
1257 case 0x33 /* '3' */ :
1258 case 0x34 /* '4' */ :
1259 case 0x35 /* '5' */ :
1260 case 0x36 /* '6' */ :
1261 case 0x37 /* '7' */ :
1262 case 0x38 /* '8' */ :
1263 case 0x39 /* '9' */ :
1264 {
1265 break;
1266 }
1267 default:
1268 {
1269 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1270 }
1271 }
1272 }
1273 { // ( ... )+
1274 int _cnt130=0;
1275 for (;;) {
1276 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1277 mDigit(false);
1278 }
1279 else {
1280 if ( _cnt130>=1 ) { goto _loop130; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1281 }
1282
1283 _cnt130++;
1284 }
1285 _loop130:;
1286 } // ( ... )+
1287 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1288 _token = makeToken(_ttype);
1289 _token->setText(text.substr(_begin, text.length()-_begin));
1290 }
1291 _returnToken = _token;
1292 _saveIndex=0;
1293 }
1294
1295 void MDLexer::mVocabulary(bool _createToken) {
1296 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1297 _ttype = Vocabulary;
1298 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1299
1300 matchRange('\3',static_cast<unsigned char>('\377'));
1301 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1302 _token = makeToken(_ttype);
1303 _token->setText(text.substr(_begin, text.length()-_begin));
1304 }
1305 _returnToken = _token;
1306 _saveIndex=0;
1307 }
1308
1309 void MDLexer::mNumber(bool _createToken) {
1310 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1311 _ttype = Number;
1312 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1313
1314 bool synPredMatched137 = false;
1315 if ((((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_6.member(LA(2))) && (true))) {
1316 int _m137 = mark();
1317 synPredMatched137 = true;
1318 inputState->guessing++;
1319 try {
1320 {
1321 { // ( ... )+
1322 int _cnt135=0;
1323 for (;;) {
1324 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1325 mDigit(false);
1326 }
1327 else {
1328 if ( _cnt135>=1 ) { goto _loop135; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1329 }
1330
1331 _cnt135++;
1332 }
1333 _loop135:;
1334 } // ( ... )+
1335 {
1336 switch ( LA(1)) {
1337 case 0x2e /* '.' */ :
1338 {
1339 match('.' /* charlit */ );
1340 break;
1341 }
1342 case 0x65 /* 'e' */ :
1343 {
1344 match('e' /* charlit */ );
1345 break;
1346 }
1347 case 0x45 /* 'E' */ :
1348 {
1349 match('E' /* charlit */ );
1350 break;
1351 }
1352 case 0x64 /* 'd' */ :
1353 {
1354 match('d' /* charlit */ );
1355 break;
1356 }
1357 case 0x44 /* 'D' */ :
1358 {
1359 match('D' /* charlit */ );
1360 break;
1361 }
1362 default:
1363 {
1364 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1365 }
1366 }
1367 }
1368 }
1369 }
1370 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1371 synPredMatched137 = false;
1372 }
1373 rewind(_m137);
1374 inputState->guessing--;
1375 }
1376 if ( synPredMatched137 ) {
1377 { // ( ... )+
1378 int _cnt139=0;
1379 for (;;) {
1380 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1381 mDigit(false);
1382 }
1383 else {
1384 if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1385 }
1386
1387 _cnt139++;
1388 }
1389 _loop139:;
1390 } // ( ... )+
1391 {
1392 switch ( LA(1)) {
1393 case 0x2e /* '.' */ :
1394 {
1395 match('.' /* charlit */ );
1396 { // ( ... )*
1397 for (;;) {
1398 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1399 mDigit(false);
1400 }
1401 else {
1402 goto _loop142;
1403 }
1404
1405 }
1406 _loop142:;
1407 } // ( ... )*
1408 {
1409 if ((_tokenSet_7.member(LA(1)))) {
1410 mExponent(false);
1411 }
1412 else {
1413 }
1414
1415 }
1416 if ( inputState->guessing==0 ) {
1417 #line 451 "MDParser.g"
1418 _ttype = FLOATONE;
1419 #line 1420 "MDLexer.cpp"
1420 }
1421 break;
1422 }
1423 case 0x44 /* 'D' */ :
1424 case 0x45 /* 'E' */ :
1425 case 0x64 /* 'd' */ :
1426 case 0x65 /* 'e' */ :
1427 {
1428 mExponent(false);
1429 if ( inputState->guessing==0 ) {
1430 #line 452 "MDParser.g"
1431 _ttype = FLOATTWO;
1432 #line 1433 "MDLexer.cpp"
1433 }
1434 break;
1435 }
1436 default:
1437 {
1438 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1439 }
1440 }
1441 }
1442 {
1443 switch ( LA(1)) {
1444 case 0x46 /* 'F' */ :
1445 case 0x66 /* 'f' */ :
1446 {
1447 mFloatSuffix(false);
1448 break;
1449 }
1450 case 0x4c /* 'L' */ :
1451 case 0x6c /* 'l' */ :
1452 {
1453 mLongSuffix(false);
1454 break;
1455 }
1456 default:
1457 {
1458 }
1459 }
1460 }
1461 }
1462 else if ((LA(1) == 0x30 /* '0' */ ) && (LA(2) == 0x58 /* 'X' */ || LA(2) == 0x78 /* 'x' */ )) {
1463 match('0' /* charlit */ );
1464 {
1465 switch ( LA(1)) {
1466 case 0x78 /* 'x' */ :
1467 {
1468 match('x' /* charlit */ );
1469 break;
1470 }
1471 case 0x58 /* 'X' */ :
1472 {
1473 match('X' /* charlit */ );
1474 break;
1475 }
1476 default:
1477 {
1478 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1479 }
1480 }
1481 }
1482 { // ( ... )+
1483 int _cnt160=0;
1484 for (;;) {
1485 switch ( LA(1)) {
1486 case 0x61 /* 'a' */ :
1487 case 0x62 /* 'b' */ :
1488 case 0x63 /* 'c' */ :
1489 case 0x64 /* 'd' */ :
1490 case 0x65 /* 'e' */ :
1491 case 0x66 /* 'f' */ :
1492 {
1493 matchRange('a','f');
1494 break;
1495 }
1496 case 0x41 /* 'A' */ :
1497 case 0x42 /* 'B' */ :
1498 case 0x43 /* 'C' */ :
1499 case 0x44 /* 'D' */ :
1500 case 0x45 /* 'E' */ :
1501 case 0x46 /* 'F' */ :
1502 {
1503 matchRange('A','F');
1504 break;
1505 }
1506 case 0x30 /* '0' */ :
1507 case 0x31 /* '1' */ :
1508 case 0x32 /* '2' */ :
1509 case 0x33 /* '3' */ :
1510 case 0x34 /* '4' */ :
1511 case 0x35 /* '5' */ :
1512 case 0x36 /* '6' */ :
1513 case 0x37 /* '7' */ :
1514 case 0x38 /* '8' */ :
1515 case 0x39 /* '9' */ :
1516 {
1517 mDigit(false);
1518 break;
1519 }
1520 default:
1521 {
1522 if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1523 }
1524 }
1525 _cnt160++;
1526 }
1527 _loop160:;
1528 } // ( ... )+
1529 { // ( ... )*
1530 for (;;) {
1531 switch ( LA(1)) {
1532 case 0x4c /* 'L' */ :
1533 case 0x6c /* 'l' */ :
1534 {
1535 mLongSuffix(false);
1536 break;
1537 }
1538 case 0x55 /* 'U' */ :
1539 case 0x75 /* 'u' */ :
1540 {
1541 mUnsignedSuffix(false);
1542 break;
1543 }
1544 default:
1545 {
1546 goto _loop162;
1547 }
1548 }
1549 }
1550 _loop162:;
1551 } // ( ... )*
1552 if ( inputState->guessing==0 ) {
1553 #line 480 "MDParser.g"
1554 _ttype = HEXADECIMALINT;
1555 #line 1556 "MDLexer.cpp"
1556 }
1557 }
1558 else if ((LA(1) == 0x2e /* '.' */ )) {
1559 match('.' /* charlit */ );
1560 if ( inputState->guessing==0 ) {
1561 #line 458 "MDParser.g"
1562 _ttype = DOT;
1563 #line 1564 "MDLexer.cpp"
1564 }
1565 {
1566 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1567 { // ( ... )+
1568 int _cnt147=0;
1569 for (;;) {
1570 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1571 mDigit(false);
1572 }
1573 else {
1574 if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1575 }
1576
1577 _cnt147++;
1578 }
1579 _loop147:;
1580 } // ( ... )+
1581 {
1582 if ((_tokenSet_7.member(LA(1)))) {
1583 mExponent(false);
1584 }
1585 else {
1586 }
1587
1588 }
1589 if ( inputState->guessing==0 ) {
1590 #line 459 "MDParser.g"
1591 _ttype = FLOATONE;
1592 #line 1593 "MDLexer.cpp"
1593 }
1594 {
1595 switch ( LA(1)) {
1596 case 0x46 /* 'F' */ :
1597 case 0x66 /* 'f' */ :
1598 {
1599 mFloatSuffix(false);
1600 break;
1601 }
1602 case 0x4c /* 'L' */ :
1603 case 0x6c /* 'l' */ :
1604 {
1605 mLongSuffix(false);
1606 break;
1607 }
1608 default:
1609 {
1610 }
1611 }
1612 }
1613 }
1614 else {
1615 }
1616
1617 }
1618 }
1619 else if ((LA(1) == 0x30 /* '0' */ ) && (true) && (true)) {
1620 match('0' /* charlit */ );
1621 { // ( ... )*
1622 for (;;) {
1623 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ ))) {
1624 matchRange('0','7');
1625 }
1626 else {
1627 goto _loop151;
1628 }
1629
1630 }
1631 _loop151:;
1632 } // ( ... )*
1633 { // ( ... )*
1634 for (;;) {
1635 switch ( LA(1)) {
1636 case 0x4c /* 'L' */ :
1637 case 0x6c /* 'l' */ :
1638 {
1639 mLongSuffix(false);
1640 break;
1641 }
1642 case 0x55 /* 'U' */ :
1643 case 0x75 /* 'u' */ :
1644 {
1645 mUnsignedSuffix(false);
1646 break;
1647 }
1648 default:
1649 {
1650 goto _loop153;
1651 }
1652 }
1653 }
1654 _loop153:;
1655 } // ( ... )*
1656 if ( inputState->guessing==0 ) {
1657 #line 469 "MDParser.g"
1658 _ttype = OCTALINT;
1659 #line 1660 "MDLexer.cpp"
1660 }
1661 }
1662 else if (((LA(1) >= 0x31 /* '1' */ && LA(1) <= 0x39 /* '9' */ )) && (true) && (true)) {
1663 matchRange('1','9');
1664 { // ( ... )*
1665 for (;;) {
1666 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1667 mDigit(false);
1668 }
1669 else {
1670 goto _loop155;
1671 }
1672
1673 }
1674 _loop155:;
1675 } // ( ... )*
1676 { // ( ... )*
1677 for (;;) {
1678 switch ( LA(1)) {
1679 case 0x4c /* 'L' */ :
1680 case 0x6c /* 'l' */ :
1681 {
1682 mLongSuffix(false);
1683 break;
1684 }
1685 case 0x55 /* 'U' */ :
1686 case 0x75 /* 'u' */ :
1687 {
1688 mUnsignedSuffix(false);
1689 break;
1690 }
1691 default:
1692 {
1693 goto _loop157;
1694 }
1695 }
1696 }
1697 _loop157:;
1698 } // ( ... )*
1699 if ( inputState->guessing==0 ) {
1700 #line 474 "MDParser.g"
1701 _ttype = DECIMALINT;
1702 #line 1703 "MDLexer.cpp"
1703 }
1704 }
1705 else {
1706 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1707 }
1708
1709 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1710 _token = makeToken(_ttype);
1711 _token->setText(text.substr(_begin, text.length()-_begin));
1712 }
1713 _returnToken = _token;
1714 _saveIndex=0;
1715 }
1716
1717 void MDLexer::mID(bool _createToken) {
1718 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1719 _ttype = ID;
1720 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1721
1722 {
1723 switch ( LA(1)) {
1724 case 0x61 /* 'a' */ :
1725 case 0x62 /* 'b' */ :
1726 case 0x63 /* 'c' */ :
1727 case 0x64 /* 'd' */ :
1728 case 0x65 /* 'e' */ :
1729 case 0x66 /* 'f' */ :
1730 case 0x67 /* 'g' */ :
1731 case 0x68 /* 'h' */ :
1732 case 0x69 /* 'i' */ :
1733 case 0x6a /* 'j' */ :
1734 case 0x6b /* 'k' */ :
1735 case 0x6c /* 'l' */ :
1736 case 0x6d /* 'm' */ :
1737 case 0x6e /* 'n' */ :
1738 case 0x6f /* 'o' */ :
1739 case 0x70 /* 'p' */ :
1740 case 0x71 /* 'q' */ :
1741 case 0x72 /* 'r' */ :
1742 case 0x73 /* 's' */ :
1743 case 0x74 /* 't' */ :
1744 case 0x75 /* 'u' */ :
1745 case 0x76 /* 'v' */ :
1746 case 0x77 /* 'w' */ :
1747 case 0x78 /* 'x' */ :
1748 case 0x79 /* 'y' */ :
1749 case 0x7a /* 'z' */ :
1750 {
1751 matchRange('a','z');
1752 break;
1753 }
1754 case 0x41 /* 'A' */ :
1755 case 0x42 /* 'B' */ :
1756 case 0x43 /* 'C' */ :
1757 case 0x44 /* 'D' */ :
1758 case 0x45 /* 'E' */ :
1759 case 0x46 /* 'F' */ :
1760 case 0x47 /* 'G' */ :
1761 case 0x48 /* 'H' */ :
1762 case 0x49 /* 'I' */ :
1763 case 0x4a /* 'J' */ :
1764 case 0x4b /* 'K' */ :
1765 case 0x4c /* 'L' */ :
1766 case 0x4d /* 'M' */ :
1767 case 0x4e /* 'N' */ :
1768 case 0x4f /* 'O' */ :
1769 case 0x50 /* 'P' */ :
1770 case 0x51 /* 'Q' */ :
1771 case 0x52 /* 'R' */ :
1772 case 0x53 /* 'S' */ :
1773 case 0x54 /* 'T' */ :
1774 case 0x55 /* 'U' */ :
1775 case 0x56 /* 'V' */ :
1776 case 0x57 /* 'W' */ :
1777 case 0x58 /* 'X' */ :
1778 case 0x59 /* 'Y' */ :
1779 case 0x5a /* 'Z' */ :
1780 {
1781 matchRange('A','Z');
1782 break;
1783 }
1784 case 0x5f /* '_' */ :
1785 {
1786 match('_' /* charlit */ );
1787 break;
1788 }
1789 default:
1790 {
1791 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1792 }
1793 }
1794 }
1795 { // ( ... )*
1796 for (;;) {
1797 switch ( LA(1)) {
1798 case 0x61 /* 'a' */ :
1799 case 0x62 /* 'b' */ :
1800 case 0x63 /* 'c' */ :
1801 case 0x64 /* 'd' */ :
1802 case 0x65 /* 'e' */ :
1803 case 0x66 /* 'f' */ :
1804 case 0x67 /* 'g' */ :
1805 case 0x68 /* 'h' */ :
1806 case 0x69 /* 'i' */ :
1807 case 0x6a /* 'j' */ :
1808 case 0x6b /* 'k' */ :
1809 case 0x6c /* 'l' */ :
1810 case 0x6d /* 'm' */ :
1811 case 0x6e /* 'n' */ :
1812 case 0x6f /* 'o' */ :
1813 case 0x70 /* 'p' */ :
1814 case 0x71 /* 'q' */ :
1815 case 0x72 /* 'r' */ :
1816 case 0x73 /* 's' */ :
1817 case 0x74 /* 't' */ :
1818 case 0x75 /* 'u' */ :
1819 case 0x76 /* 'v' */ :
1820 case 0x77 /* 'w' */ :
1821 case 0x78 /* 'x' */ :
1822 case 0x79 /* 'y' */ :
1823 case 0x7a /* 'z' */ :
1824 {
1825 matchRange('a','z');
1826 break;
1827 }
1828 case 0x41 /* 'A' */ :
1829 case 0x42 /* 'B' */ :
1830 case 0x43 /* 'C' */ :
1831 case 0x44 /* 'D' */ :
1832 case 0x45 /* 'E' */ :
1833 case 0x46 /* 'F' */ :
1834 case 0x47 /* 'G' */ :
1835 case 0x48 /* 'H' */ :
1836 case 0x49 /* 'I' */ :
1837 case 0x4a /* 'J' */ :
1838 case 0x4b /* 'K' */ :
1839 case 0x4c /* 'L' */ :
1840 case 0x4d /* 'M' */ :
1841 case 0x4e /* 'N' */ :
1842 case 0x4f /* 'O' */ :
1843 case 0x50 /* 'P' */ :
1844 case 0x51 /* 'Q' */ :
1845 case 0x52 /* 'R' */ :
1846 case 0x53 /* 'S' */ :
1847 case 0x54 /* 'T' */ :
1848 case 0x55 /* 'U' */ :
1849 case 0x56 /* 'V' */ :
1850 case 0x57 /* 'W' */ :
1851 case 0x58 /* 'X' */ :
1852 case 0x59 /* 'Y' */ :
1853 case 0x5a /* 'Z' */ :
1854 {
1855 matchRange('A','Z');
1856 break;
1857 }
1858 case 0x5f /* '_' */ :
1859 {
1860 match('_' /* charlit */ );
1861 break;
1862 }
1863 case 0x30 /* '0' */ :
1864 case 0x31 /* '1' */ :
1865 case 0x32 /* '2' */ :
1866 case 0x33 /* '3' */ :
1867 case 0x34 /* '4' */ :
1868 case 0x35 /* '5' */ :
1869 case 0x36 /* '6' */ :
1870 case 0x37 /* '7' */ :
1871 case 0x38 /* '8' */ :
1872 case 0x39 /* '9' */ :
1873 {
1874 matchRange('0','9');
1875 break;
1876 }
1877 default:
1878 {
1879 goto _loop166;
1880 }
1881 }
1882 }
1883 _loop166:;
1884 } // ( ... )*
1885 _ttype = testLiteralsTable(_ttype);
1886 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1887 _token = makeToken(_ttype);
1888 _token->setText(text.substr(_begin, text.length()-_begin));
1889 }
1890 _returnToken = _token;
1891 _saveIndex=0;
1892 }
1893
1894
1895 const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1896 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1897 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f !
1898 // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7
1899 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1900 const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1901 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1902 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f !
1903 // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7
1904 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1905 const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1906 // \" \' 0 1 2 3 4 5 6 7
1907 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1908 const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1909 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1910 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f !
1911 // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7
1912 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1913 const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1914 // \' 0 1 2 3 4 5 6 7
1915 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1916 const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1918 // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1919 // 0x1f ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7
1920 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1921 const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 67059712UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1922 // . 0 1 2 3 4 5 6 7
1923 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1924 const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1925 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1926