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

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