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