ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
Revision: 2040
Committed: Thu Nov 13 17:49:44 2014 UTC (10 years, 5 months ago) by gezelter
File size: 50846 byte(s)
Log Message: 
Added a vcorr2spectrum script to simplify the task of computing spectra

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

Properties

Name Value
svn:keywords Author Id Revision Date