ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
Revision: 2046
Committed: Tue Dec 2 22:11:04 2014 UTC (10 years, 5 months ago) by gezelter
File size: 51566 byte(s)
Log Message: 
Fixed some broken comments for use with Doxygen.
Made changes to allow topology-based force-field overrides in include files.
Fixed a calculation of box quadrupole moments for molecules with point dipoles.

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date