ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDLexer.cpp
Revision: 1746
Committed: Wed Jun 6 02:18:54 2012 UTC (12 years, 10 months ago) by gezelter
File size: 50724 byte(s)
Log Message: 
added a minimizer parsing block

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

Properties

Name Value
svn:keywords Author Id Revision Date