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

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date