ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
Revision: 1969
Committed: Wed Feb 26 14:14:50 2014 UTC (11 years, 2 months ago) by gezelter
File size: 50772 byte(s)
Log Message: 
Fixes to deal with deprecation of MPI C++ bindings.  We've reverted back to the
C calls.

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date