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

File Contents

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