ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
Revision: 1277
Committed: Mon Jul 14 12:35:58 2008 UTC (17 years, 3 months ago) by gezelter
File size: 50536 byte(s)
Log Message: 
Changes for implementing Amber force field:  Added Inversions and
worked on BaseAtomTypes so that they'd function with the fortran side.

File Contents

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