ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
Revision: 1360
Committed: Mon Sep 7 16:31:51 2009 UTC (15 years, 7 months ago) by cli2
File size: 50588 byte(s)
Log Message: 
Added new restraint infrastructure
Added MolecularRestraints
Added ObjectRestraints
Added RestraintStamp
Updated thermodynamic integration to use ObjectRestraints
Added Quaternion mathematics for twist swing decompositions
Significantly updated RestWriter and RestReader to use dump-like files
Added selections for x, y, and z coordinates of atoms
Removed monolithic Restraints class
Fixed a few bugs in gradients of Euler angles in DirectionalAtom and RigidBody
Added some rotational capabilities to prinicpalAxisCalculator

File Contents

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