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

File Contents

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