ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/mdParser/MDLexer.cpp
Revision: 2509
Committed: Wed Dec 14 18:02:28 2005 UTC (18 years, 6 months ago) by tim
File size: 48999 byte(s)
Log Message: 
fix a nasty negative integer parsing problem by refining the grammar

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