ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
Revision: 1390
Committed: Wed Nov 25 20:02:06 2009 UTC (15 years, 11 months ago) by gezelter
File size: 50589 byte(s)
Log Message: 
Almost all of the changes necessary to create OpenMD out of our old
project (OOPSE-4)

File Contents

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