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

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date