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

File Contents

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