ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDLexer.cpp
Revision: 1731
Committed: Thu May 31 12:25:30 2012 UTC (12 years, 11 months ago) by gezelter
File size: 50681 byte(s)
Log Message: 
Reorganized source directories, added RNEMD and flucQ blocks for
options parsing.

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date