ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDLexer.cpp
Revision: 2513
Committed: Fri Dec 16 02:57:00 2005 UTC (18 years, 6 months ago) by tim
File size: 50116 byte(s)
Log Message: 
replace grammar for numerical parsing

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 0x41 /* 'A' */ :
153 case 0x42 /* 'B' */ :
154 case 0x43 /* 'C' */ :
155 case 0x44 /* 'D' */ :
156 case 0x45 /* 'E' */ :
157 case 0x46 /* 'F' */ :
158 case 0x47 /* 'G' */ :
159 case 0x48 /* 'H' */ :
160 case 0x49 /* 'I' */ :
161 case 0x4a /* 'J' */ :
162 case 0x4b /* 'K' */ :
163 case 0x4c /* 'L' */ :
164 case 0x4d /* 'M' */ :
165 case 0x4e /* 'N' */ :
166 case 0x4f /* 'O' */ :
167 case 0x50 /* 'P' */ :
168 case 0x51 /* 'Q' */ :
169 case 0x52 /* 'R' */ :
170 case 0x53 /* 'S' */ :
171 case 0x54 /* 'T' */ :
172 case 0x55 /* 'U' */ :
173 case 0x56 /* 'V' */ :
174 case 0x57 /* 'W' */ :
175 case 0x58 /* 'X' */ :
176 case 0x59 /* 'Y' */ :
177 case 0x5a /* 'Z' */ :
178 case 0x5f /* '_' */ :
179 case 0x61 /* 'a' */ :
180 case 0x62 /* 'b' */ :
181 case 0x63 /* 'c' */ :
182 case 0x64 /* 'd' */ :
183 case 0x65 /* 'e' */ :
184 case 0x66 /* 'f' */ :
185 case 0x67 /* 'g' */ :
186 case 0x68 /* 'h' */ :
187 case 0x69 /* 'i' */ :
188 case 0x6a /* 'j' */ :
189 case 0x6b /* 'k' */ :
190 case 0x6c /* 'l' */ :
191 case 0x6d /* 'm' */ :
192 case 0x6e /* 'n' */ :
193 case 0x6f /* 'o' */ :
194 case 0x70 /* 'p' */ :
195 case 0x71 /* 'q' */ :
196 case 0x72 /* 'r' */ :
197 case 0x73 /* 's' */ :
198 case 0x74 /* 't' */ :
199 case 0x75 /* 'u' */ :
200 case 0x76 /* 'v' */ :
201 case 0x77 /* 'w' */ :
202 case 0x78 /* 'x' */ :
203 case 0x79 /* 'y' */ :
204 case 0x7a /* 'z' */ :
205 {
206 mID(true);
207 theRetToken=_returnToken;
208 break;
209 }
210 case 0x2b /* '+' */ :
211 case 0x2d /* '-' */ :
212 case 0x2e /* '.' */ :
213 case 0x30 /* '0' */ :
214 case 0x31 /* '1' */ :
215 case 0x32 /* '2' */ :
216 case 0x33 /* '3' */ :
217 case 0x34 /* '4' */ :
218 case 0x35 /* '5' */ :
219 case 0x36 /* '6' */ :
220 case 0x37 /* '7' */ :
221 case 0x38 /* '8' */ :
222 case 0x39 /* '9' */ :
223 {
224 mNUM_INT(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 218 "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 223 "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 226 "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 233 "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 236 "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 242 "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 249 "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 255 "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 260 "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 262 "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 _cnt124=0;
812 for (;;) {
813 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
814 matchRange('0','9');
815 }
816 else {
817 if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
818 }
819
820 _cnt124++;
821 }
822 _loop124:;
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 302 "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::mVocabulary(bool _createToken) {
1085 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1086 _ttype = Vocabulary;
1087 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1088
1089 matchRange('\3',static_cast<unsigned char>('\377'));
1090 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1091 _token = makeToken(_ttype);
1092 _token->setText(text.substr(_begin, text.length()-_begin));
1093 }
1094 _returnToken = _token;
1095 _saveIndex=0;
1096 }
1097
1098 void MDLexer::mID(bool _createToken) {
1099 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1100 _ttype = ID;
1101 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1102
1103 {
1104 switch ( LA(1)) {
1105 case 0x61 /* 'a' */ :
1106 case 0x62 /* 'b' */ :
1107 case 0x63 /* 'c' */ :
1108 case 0x64 /* 'd' */ :
1109 case 0x65 /* 'e' */ :
1110 case 0x66 /* 'f' */ :
1111 case 0x67 /* 'g' */ :
1112 case 0x68 /* 'h' */ :
1113 case 0x69 /* 'i' */ :
1114 case 0x6a /* 'j' */ :
1115 case 0x6b /* 'k' */ :
1116 case 0x6c /* 'l' */ :
1117 case 0x6d /* 'm' */ :
1118 case 0x6e /* 'n' */ :
1119 case 0x6f /* 'o' */ :
1120 case 0x70 /* 'p' */ :
1121 case 0x71 /* 'q' */ :
1122 case 0x72 /* 'r' */ :
1123 case 0x73 /* 's' */ :
1124 case 0x74 /* 't' */ :
1125 case 0x75 /* 'u' */ :
1126 case 0x76 /* 'v' */ :
1127 case 0x77 /* 'w' */ :
1128 case 0x78 /* 'x' */ :
1129 case 0x79 /* 'y' */ :
1130 case 0x7a /* 'z' */ :
1131 {
1132 matchRange('a','z');
1133 break;
1134 }
1135 case 0x41 /* 'A' */ :
1136 case 0x42 /* 'B' */ :
1137 case 0x43 /* 'C' */ :
1138 case 0x44 /* 'D' */ :
1139 case 0x45 /* 'E' */ :
1140 case 0x46 /* 'F' */ :
1141 case 0x47 /* 'G' */ :
1142 case 0x48 /* 'H' */ :
1143 case 0x49 /* 'I' */ :
1144 case 0x4a /* 'J' */ :
1145 case 0x4b /* 'K' */ :
1146 case 0x4c /* 'L' */ :
1147 case 0x4d /* 'M' */ :
1148 case 0x4e /* 'N' */ :
1149 case 0x4f /* 'O' */ :
1150 case 0x50 /* 'P' */ :
1151 case 0x51 /* 'Q' */ :
1152 case 0x52 /* 'R' */ :
1153 case 0x53 /* 'S' */ :
1154 case 0x54 /* 'T' */ :
1155 case 0x55 /* 'U' */ :
1156 case 0x56 /* 'V' */ :
1157 case 0x57 /* 'W' */ :
1158 case 0x58 /* 'X' */ :
1159 case 0x59 /* 'Y' */ :
1160 case 0x5a /* 'Z' */ :
1161 {
1162 matchRange('A','Z');
1163 break;
1164 }
1165 case 0x5f /* '_' */ :
1166 {
1167 match('_' /* charlit */ );
1168 break;
1169 }
1170 default:
1171 {
1172 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1173 }
1174 }
1175 }
1176 { // ( ... )*
1177 for (;;) {
1178 switch ( LA(1)) {
1179 case 0x61 /* 'a' */ :
1180 case 0x62 /* 'b' */ :
1181 case 0x63 /* 'c' */ :
1182 case 0x64 /* 'd' */ :
1183 case 0x65 /* 'e' */ :
1184 case 0x66 /* 'f' */ :
1185 case 0x67 /* 'g' */ :
1186 case 0x68 /* 'h' */ :
1187 case 0x69 /* 'i' */ :
1188 case 0x6a /* 'j' */ :
1189 case 0x6b /* 'k' */ :
1190 case 0x6c /* 'l' */ :
1191 case 0x6d /* 'm' */ :
1192 case 0x6e /* 'n' */ :
1193 case 0x6f /* 'o' */ :
1194 case 0x70 /* 'p' */ :
1195 case 0x71 /* 'q' */ :
1196 case 0x72 /* 'r' */ :
1197 case 0x73 /* 's' */ :
1198 case 0x74 /* 't' */ :
1199 case 0x75 /* 'u' */ :
1200 case 0x76 /* 'v' */ :
1201 case 0x77 /* 'w' */ :
1202 case 0x78 /* 'x' */ :
1203 case 0x79 /* 'y' */ :
1204 case 0x7a /* 'z' */ :
1205 {
1206 matchRange('a','z');
1207 break;
1208 }
1209 case 0x41 /* 'A' */ :
1210 case 0x42 /* 'B' */ :
1211 case 0x43 /* 'C' */ :
1212 case 0x44 /* 'D' */ :
1213 case 0x45 /* 'E' */ :
1214 case 0x46 /* 'F' */ :
1215 case 0x47 /* 'G' */ :
1216 case 0x48 /* 'H' */ :
1217 case 0x49 /* 'I' */ :
1218 case 0x4a /* 'J' */ :
1219 case 0x4b /* 'K' */ :
1220 case 0x4c /* 'L' */ :
1221 case 0x4d /* 'M' */ :
1222 case 0x4e /* 'N' */ :
1223 case 0x4f /* 'O' */ :
1224 case 0x50 /* 'P' */ :
1225 case 0x51 /* 'Q' */ :
1226 case 0x52 /* 'R' */ :
1227 case 0x53 /* 'S' */ :
1228 case 0x54 /* 'T' */ :
1229 case 0x55 /* 'U' */ :
1230 case 0x56 /* 'V' */ :
1231 case 0x57 /* 'W' */ :
1232 case 0x58 /* 'X' */ :
1233 case 0x59 /* 'Y' */ :
1234 case 0x5a /* 'Z' */ :
1235 {
1236 matchRange('A','Z');
1237 break;
1238 }
1239 case 0x5f /* '_' */ :
1240 {
1241 match('_' /* charlit */ );
1242 break;
1243 }
1244 case 0x30 /* '0' */ :
1245 case 0x31 /* '1' */ :
1246 case 0x32 /* '2' */ :
1247 case 0x33 /* '3' */ :
1248 case 0x34 /* '4' */ :
1249 case 0x35 /* '5' */ :
1250 case 0x36 /* '6' */ :
1251 case 0x37 /* '7' */ :
1252 case 0x38 /* '8' */ :
1253 case 0x39 /* '9' */ :
1254 {
1255 matchRange('0','9');
1256 break;
1257 }
1258 default:
1259 {
1260 goto _loop120;
1261 }
1262 }
1263 }
1264 _loop120:;
1265 } // ( ... )*
1266 _ttype = testLiteralsTable(_ttype);
1267 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1268 _token = makeToken(_ttype);
1269 _token->setText(text.substr(_begin, text.length()-_begin));
1270 }
1271 _returnToken = _token;
1272 _saveIndex=0;
1273 }
1274
1275 void MDLexer::mHEX_DIGIT(bool _createToken) {
1276 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1277 _ttype = HEX_DIGIT;
1278 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1279
1280 {
1281 switch ( LA(1)) {
1282 case 0x30 /* '0' */ :
1283 case 0x31 /* '1' */ :
1284 case 0x32 /* '2' */ :
1285 case 0x33 /* '3' */ :
1286 case 0x34 /* '4' */ :
1287 case 0x35 /* '5' */ :
1288 case 0x36 /* '6' */ :
1289 case 0x37 /* '7' */ :
1290 case 0x38 /* '8' */ :
1291 case 0x39 /* '9' */ :
1292 {
1293 matchRange('0','9');
1294 break;
1295 }
1296 case 0x41 /* 'A' */ :
1297 case 0x42 /* 'B' */ :
1298 case 0x43 /* 'C' */ :
1299 case 0x44 /* 'D' */ :
1300 case 0x45 /* 'E' */ :
1301 case 0x46 /* 'F' */ :
1302 {
1303 matchRange('A','F');
1304 break;
1305 }
1306 case 0x61 /* 'a' */ :
1307 case 0x62 /* 'b' */ :
1308 case 0x63 /* 'c' */ :
1309 case 0x64 /* 'd' */ :
1310 case 0x65 /* 'e' */ :
1311 case 0x66 /* 'f' */ :
1312 {
1313 matchRange('a','f');
1314 break;
1315 }
1316 default:
1317 {
1318 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1319 }
1320 }
1321 }
1322 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1323 _token = makeToken(_ttype);
1324 _token->setText(text.substr(_begin, text.length()-_begin));
1325 }
1326 _returnToken = _token;
1327 _saveIndex=0;
1328 }
1329
1330 void MDLexer::mNUM_INT(bool _createToken) {
1331 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1332 _ttype = NUM_INT;
1333 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1334 ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1335 ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1336 ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1337 ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1338 #line 395 "MDParser.g"
1339
1340 bool isDecimal = false;
1341 ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1342
1343 #line 1344 "MDLexer.cpp"
1344
1345 {
1346 switch ( LA(1)) {
1347 case 0x2b /* '+' */ :
1348 {
1349 match('+' /* charlit */ );
1350 break;
1351 }
1352 case 0x2d /* '-' */ :
1353 {
1354 match('-' /* charlit */ );
1355 break;
1356 }
1357 case 0x2e /* '.' */ :
1358 case 0x30 /* '0' */ :
1359 case 0x31 /* '1' */ :
1360 case 0x32 /* '2' */ :
1361 case 0x33 /* '3' */ :
1362 case 0x34 /* '4' */ :
1363 case 0x35 /* '5' */ :
1364 case 0x36 /* '6' */ :
1365 case 0x37 /* '7' */ :
1366 case 0x38 /* '8' */ :
1367 case 0x39 /* '9' */ :
1368 {
1369 break;
1370 }
1371 default:
1372 {
1373 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1374 }
1375 }
1376 }
1377 {
1378 switch ( LA(1)) {
1379 case 0x2e /* '.' */ :
1380 {
1381 match('.' /* charlit */ );
1382 if ( inputState->guessing==0 ) {
1383 #line 402 "MDParser.g"
1384 _ttype = DOT;
1385 #line 1386 "MDLexer.cpp"
1386 }
1387 {
1388 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1389 { // ( ... )+
1390 int _cnt132=0;
1391 for (;;) {
1392 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1393 matchRange('0','9');
1394 }
1395 else {
1396 if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1397 }
1398
1399 _cnt132++;
1400 }
1401 _loop132:;
1402 } // ( ... )+
1403 {
1404 if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) {
1405 mEXPONENT(false);
1406 }
1407 else {
1408 }
1409
1410 }
1411 {
1412 if ((_tokenSet_6.member(LA(1)))) {
1413 mFLOAT_SUFFIX(true);
1414 f1=_returnToken;
1415 if ( inputState->guessing==0 ) {
1416 #line 403 "MDParser.g"
1417 t=f1;
1418 #line 1419 "MDLexer.cpp"
1419 }
1420 }
1421 else {
1422 }
1423
1424 }
1425 if ( inputState->guessing==0 ) {
1426 #line 404 "MDParser.g"
1427
1428 if ( t &&
1429 (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1430 t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1431 _ttype = NUM_FLOAT;
1432 }
1433 else {
1434 _ttype = NUM_DOUBLE; // assume double
1435 }
1436
1437 #line 1438 "MDLexer.cpp"
1438 }
1439 }
1440 else {
1441 }
1442
1443 }
1444 break;
1445 }
1446 case 0x30 /* '0' */ :
1447 case 0x31 /* '1' */ :
1448 case 0x32 /* '2' */ :
1449 case 0x33 /* '3' */ :
1450 case 0x34 /* '4' */ :
1451 case 0x35 /* '5' */ :
1452 case 0x36 /* '6' */ :
1453 case 0x37 /* '7' */ :
1454 case 0x38 /* '8' */ :
1455 case 0x39 /* '9' */ :
1456 {
1457 {
1458 switch ( LA(1)) {
1459 case 0x30 /* '0' */ :
1460 {
1461 match('0' /* charlit */ );
1462 if ( inputState->guessing==0 ) {
1463 #line 416 "MDParser.g"
1464 isDecimal = true;
1465 #line 1466 "MDLexer.cpp"
1466 }
1467 {
1468 if ((LA(1) == 0x58 /* 'X' */ || LA(1) == 0x78 /* 'x' */ )) {
1469 {
1470 switch ( LA(1)) {
1471 case 0x78 /* 'x' */ :
1472 {
1473 match('x' /* charlit */ );
1474 break;
1475 }
1476 case 0x58 /* 'X' */ :
1477 {
1478 match('X' /* charlit */ );
1479 break;
1480 }
1481 default:
1482 {
1483 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1484 }
1485 }
1486 }
1487 { // ( ... )+
1488 int _cnt139=0;
1489 for (;;) {
1490 if ((_tokenSet_7.member(LA(1))) && (true) && (true)) {
1491 mHEX_DIGIT(false);
1492 }
1493 else {
1494 if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1495 }
1496
1497 _cnt139++;
1498 }
1499 _loop139:;
1500 } // ( ... )+
1501 }
1502 else {
1503 bool synPredMatched144 = false;
1504 if ((((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1505 int _m144 = mark();
1506 synPredMatched144 = true;
1507 inputState->guessing++;
1508 try {
1509 {
1510 { // ( ... )+
1511 int _cnt142=0;
1512 for (;;) {
1513 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1514 matchRange('0','9');
1515 }
1516 else {
1517 if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1518 }
1519
1520 _cnt142++;
1521 }
1522 _loop142:;
1523 } // ( ... )+
1524 {
1525 switch ( LA(1)) {
1526 case 0x2e /* '.' */ :
1527 {
1528 match('.' /* charlit */ );
1529 break;
1530 }
1531 case 0x45 /* 'E' */ :
1532 case 0x65 /* 'e' */ :
1533 {
1534 mEXPONENT(false);
1535 break;
1536 }
1537 case 0x44 /* 'D' */ :
1538 case 0x46 /* 'F' */ :
1539 case 0x64 /* 'd' */ :
1540 case 0x66 /* 'f' */ :
1541 {
1542 mFLOAT_SUFFIX(false);
1543 break;
1544 }
1545 default:
1546 {
1547 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1548 }
1549 }
1550 }
1551 }
1552 }
1553 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1554 synPredMatched144 = false;
1555 }
1556 rewind(_m144);
1557 inputState->guessing--;
1558 }
1559 if ( synPredMatched144 ) {
1560 { // ( ... )+
1561 int _cnt146=0;
1562 for (;;) {
1563 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1564 matchRange('0','9');
1565 }
1566 else {
1567 if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1568 }
1569
1570 _cnt146++;
1571 }
1572 _loop146:;
1573 } // ( ... )+
1574 }
1575 else if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1576 { // ( ... )+
1577 int _cnt148=0;
1578 for (;;) {
1579 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ ))) {
1580 matchRange('0','7');
1581 }
1582 else {
1583 if ( _cnt148>=1 ) { goto _loop148; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1584 }
1585
1586 _cnt148++;
1587 }
1588 _loop148:;
1589 } // ( ... )+
1590 }
1591 else {
1592 }
1593 }
1594 }
1595 break;
1596 }
1597 case 0x31 /* '1' */ :
1598 case 0x32 /* '2' */ :
1599 case 0x33 /* '3' */ :
1600 case 0x34 /* '4' */ :
1601 case 0x35 /* '5' */ :
1602 case 0x36 /* '6' */ :
1603 case 0x37 /* '7' */ :
1604 case 0x38 /* '8' */ :
1605 case 0x39 /* '9' */ :
1606 {
1607 {
1608 matchRange('1','9');
1609 }
1610 { // ( ... )*
1611 for (;;) {
1612 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1613 matchRange('0','9');
1614 }
1615 else {
1616 goto _loop151;
1617 }
1618
1619 }
1620 _loop151:;
1621 } // ( ... )*
1622 if ( inputState->guessing==0 ) {
1623 #line 433 "MDParser.g"
1624 isDecimal=true;
1625 #line 1626 "MDLexer.cpp"
1626 }
1627 break;
1628 }
1629 default:
1630 {
1631 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1632 }
1633 }
1634 }
1635 {
1636 if ((LA(1) == 0x4c /* 'L' */ || LA(1) == 0x6c /* 'l' */ )) {
1637 {
1638 switch ( LA(1)) {
1639 case 0x6c /* 'l' */ :
1640 {
1641 match('l' /* charlit */ );
1642 break;
1643 }
1644 case 0x4c /* 'L' */ :
1645 {
1646 match('L' /* charlit */ );
1647 break;
1648 }
1649 default:
1650 {
1651 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1652 }
1653 }
1654 }
1655 if ( inputState->guessing==0 ) {
1656 #line 435 "MDParser.g"
1657 _ttype = NUM_LONG;
1658 #line 1659 "MDLexer.cpp"
1659 }
1660 }
1661 else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) {
1662 {
1663 switch ( LA(1)) {
1664 case 0x2e /* '.' */ :
1665 {
1666 match('.' /* charlit */ );
1667 { // ( ... )*
1668 for (;;) {
1669 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1670 matchRange('0','9');
1671 }
1672 else {
1673 goto _loop156;
1674 }
1675
1676 }
1677 _loop156:;
1678 } // ( ... )*
1679 {
1680 if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) {
1681 mEXPONENT(false);
1682 }
1683 else {
1684 }
1685
1686 }
1687 {
1688 if ((_tokenSet_6.member(LA(1)))) {
1689 mFLOAT_SUFFIX(true);
1690 f2=_returnToken;
1691 if ( inputState->guessing==0 ) {
1692 #line 439 "MDParser.g"
1693 t=f2;
1694 #line 1695 "MDLexer.cpp"
1695 }
1696 }
1697 else {
1698 }
1699
1700 }
1701 break;
1702 }
1703 case 0x45 /* 'E' */ :
1704 case 0x65 /* 'e' */ :
1705 {
1706 mEXPONENT(false);
1707 {
1708 if ((_tokenSet_6.member(LA(1)))) {
1709 mFLOAT_SUFFIX(true);
1710 f3=_returnToken;
1711 if ( inputState->guessing==0 ) {
1712 #line 440 "MDParser.g"
1713 t=f3;
1714 #line 1715 "MDLexer.cpp"
1715 }
1716 }
1717 else {
1718 }
1719
1720 }
1721 break;
1722 }
1723 case 0x44 /* 'D' */ :
1724 case 0x46 /* 'F' */ :
1725 case 0x64 /* 'd' */ :
1726 case 0x66 /* 'f' */ :
1727 {
1728 mFLOAT_SUFFIX(true);
1729 f4=_returnToken;
1730 if ( inputState->guessing==0 ) {
1731 #line 441 "MDParser.g"
1732 t=f4;
1733 #line 1734 "MDLexer.cpp"
1734 }
1735 break;
1736 }
1737 default:
1738 {
1739 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1740 }
1741 }
1742 }
1743 if ( inputState->guessing==0 ) {
1744 #line 443 "MDParser.g"
1745
1746 if ( t &&
1747 (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1748 t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1749 _ttype = NUM_FLOAT;
1750 }
1751 else {
1752 _ttype = NUM_DOUBLE; // assume double
1753 }
1754
1755 #line 1756 "MDLexer.cpp"
1756 }
1757 }
1758 else {
1759 }
1760
1761 }
1762 break;
1763 }
1764 default:
1765 {
1766 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1767 }
1768 }
1769 }
1770 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1771 _token = makeToken(_ttype);
1772 _token->setText(text.substr(_begin, text.length()-_begin));
1773 }
1774 _returnToken = _token;
1775 _saveIndex=0;
1776 }
1777
1778 void MDLexer::mEXPONENT(bool _createToken) {
1779 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1780 _ttype = EXPONENT;
1781 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1782
1783 {
1784 switch ( LA(1)) {
1785 case 0x65 /* 'e' */ :
1786 {
1787 match('e' /* charlit */ );
1788 break;
1789 }
1790 case 0x45 /* 'E' */ :
1791 {
1792 match('E' /* charlit */ );
1793 break;
1794 }
1795 default:
1796 {
1797 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1798 }
1799 }
1800 }
1801 {
1802 switch ( LA(1)) {
1803 case 0x2b /* '+' */ :
1804 {
1805 match('+' /* charlit */ );
1806 break;
1807 }
1808 case 0x2d /* '-' */ :
1809 {
1810 match('-' /* charlit */ );
1811 break;
1812 }
1813 case 0x30 /* '0' */ :
1814 case 0x31 /* '1' */ :
1815 case 0x32 /* '2' */ :
1816 case 0x33 /* '3' */ :
1817 case 0x34 /* '4' */ :
1818 case 0x35 /* '5' */ :
1819 case 0x36 /* '6' */ :
1820 case 0x37 /* '7' */ :
1821 case 0x38 /* '8' */ :
1822 case 0x39 /* '9' */ :
1823 {
1824 break;
1825 }
1826 default:
1827 {
1828 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1829 }
1830 }
1831 }
1832 { // ( ... )+
1833 int _cnt164=0;
1834 for (;;) {
1835 if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
1836 matchRange('0','9');
1837 }
1838 else {
1839 if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1840 }
1841
1842 _cnt164++;
1843 }
1844 _loop164:;
1845 } // ( ... )+
1846 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1847 _token = makeToken(_ttype);
1848 _token->setText(text.substr(_begin, text.length()-_begin));
1849 }
1850 _returnToken = _token;
1851 _saveIndex=0;
1852 }
1853
1854 void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1855 int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1856 _ttype = FLOAT_SUFFIX;
1857 ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1858
1859 switch ( LA(1)) {
1860 case 0x66 /* 'f' */ :
1861 {
1862 match('f' /* charlit */ );
1863 break;
1864 }
1865 case 0x46 /* 'F' */ :
1866 {
1867 match('F' /* charlit */ );
1868 break;
1869 }
1870 case 0x64 /* 'd' */ :
1871 {
1872 match('d' /* charlit */ );
1873 break;
1874 }
1875 case 0x44 /* 'D' */ :
1876 {
1877 match('D' /* charlit */ );
1878 break;
1879 }
1880 default:
1881 {
1882 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1883 }
1884 }
1885 if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1886 _token = makeToken(_ttype);
1887 _token->setText(text.substr(_begin, text.length()-_begin));
1888 }
1889 _returnToken = _token;
1890 _saveIndex=0;
1891 }
1892
1893
1894 const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1896 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f !
1897 // \" # $ % & \' ( ) + , - . / 0 1 2
1898 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1899 const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1901 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f !
1902 // \" # $ % & \' ( ) * + , - . / 0 1 2
1903 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1904 const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905 // \" \' 0 1 2
1906 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1907 const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1909 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f !
1910 // # $ % & \' ( ) * + , - . / 0 1 2
1911 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1912 const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1913 // \' 0 1 2
1914 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1915 const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1917 // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1918 // 0x1f ! \" # $ % & ( ) * + , - . / 0 1 2
1919 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1920 const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1922 const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923 // 0 1 2
1924 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1925 const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926 // .
1927 const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1928