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

File Contents

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