ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDLexer.cpp
(Generate patch)

Comparing trunk/src/mdParser/MDLexer.cpp (file contents):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.4: "MDParser.g" -> "MDLexer.cpp"$ */
1 > /* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDLexer.cpp"$ */
2   #include "MDLexer.hpp"
3   #include <antlr/CharBuffer.hpp>
4   #include <antlr/TokenStreamException.hpp>
# Line 30 | Line 30 | void MDLexer::initLiterals()
30  
31   void MDLexer::initLiterals()
32   {
33 <        literals["torsion"] = 10;
34 <        literals["molecule"] = 5;
35 <        literals["inversion"] = 11;
36 <        literals["fragment"] = 14;
37 <        literals["bend"] = 9;
38 <        literals["orientation"] = 18;
39 <        literals["cutoffGroup"] = 13;
40 <        literals["zconstraint"] = 6;
41 <        literals["bond"] = 8;
42 <        literals["rigidBody"] = 12;
43 <        literals["center"] = 16;
33 >        literals["members"] = 16;
34 >        literals["position"] = 18;
35 >        literals["torsion"] = 11;
36          literals["component"] = 4;
37 <        literals["position"] = 17;
38 <        literals["atom"] = 7;
39 <        literals["members"] = 15;
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()
# Line 139 | Line 140 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
140                                  theRetToken=_returnToken;
141                                  break;
142                          }
143 <                        case 0x22 /* '"' */ :
143 >                        case 0x22 /* '\"' */ :
144                          {
145                                  mStringLiteral(true);
146                                  theRetToken=_returnToken;
# Line 266 | Line 267 | void MDLexer::mASSIGNEQUAL(bool _createToken) {
267   }
268  
269   void MDLexer::mASSIGNEQUAL(bool _createToken) {
270 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
270 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
271          _ttype = ASSIGNEQUAL;
272 <        int _saveIndex;
272 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
273          
274 <        match('=');
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));
# Line 280 | Line 281 | void MDLexer::mCOLON(bool _createToken) {
281   }
282  
283   void MDLexer::mCOLON(bool _createToken) {
284 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
284 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
285          _ttype = COLON;
286 <        int _saveIndex;
286 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
287          
288 <        match(':');
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));
# Line 294 | Line 295 | void MDLexer::mCOMMA(bool _createToken) {
295   }
296  
297   void MDLexer::mCOMMA(bool _createToken) {
298 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
298 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
299          _ttype = COMMA;
300 <        int _saveIndex;
300 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
301          
302 <        match(',');
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));
# Line 308 | Line 309 | void MDLexer::mQUESTIONMARK(bool _createToken) {
309   }
310  
311   void MDLexer::mQUESTIONMARK(bool _createToken) {
312 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
312 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
313          _ttype = QUESTIONMARK;
314 <        int _saveIndex;
314 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
315          
316 <        match('?');
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));
# Line 322 | Line 323 | void MDLexer::mSEMICOLON(bool _createToken) {
323   }
324  
325   void MDLexer::mSEMICOLON(bool _createToken) {
326 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
326 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
327          _ttype = SEMICOLON;
328 <        int _saveIndex;
328 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
329          
330 <        match(';');
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));
# Line 336 | Line 337 | void MDLexer::mLPAREN(bool _createToken) {
337   }
338  
339   void MDLexer::mLPAREN(bool _createToken) {
340 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
340 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
341          _ttype = LPAREN;
342 <        int _saveIndex;
342 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
343          
344 <        match('(');
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));
# Line 350 | Line 351 | void MDLexer::mRPAREN(bool _createToken) {
351   }
352  
353   void MDLexer::mRPAREN(bool _createToken) {
354 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
354 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
355          _ttype = RPAREN;
356 <        int _saveIndex;
356 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
357          
358 <        match(')');
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));
# Line 364 | Line 365 | void MDLexer::mLBRACKET(bool _createToken) {
365   }
366  
367   void MDLexer::mLBRACKET(bool _createToken) {
368 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
368 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
369          _ttype = LBRACKET;
370 <        int _saveIndex;
370 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
371          
372 <        match('[');
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));
# Line 378 | Line 379 | void MDLexer::mRBRACKET(bool _createToken) {
379   }
380  
381   void MDLexer::mRBRACKET(bool _createToken) {
382 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
382 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
383          _ttype = RBRACKET;
384 <        int _saveIndex;
384 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
385          
386 <        match(']');
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));
# Line 392 | Line 393 | void MDLexer::mLCURLY(bool _createToken) {
393   }
394  
395   void MDLexer::mLCURLY(bool _createToken) {
396 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
396 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
397          _ttype = LCURLY;
398 <        int _saveIndex;
398 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
399          
400 <        match('{');
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));
# Line 406 | Line 407 | void MDLexer::mRCURLY(bool _createToken) {
407   }
408  
409   void MDLexer::mRCURLY(bool _createToken) {
410 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
410 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
411          _ttype = RCURLY;
412 <        int _saveIndex;
412 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
413          
414 <        match('}');
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));
# Line 420 | Line 421 | void MDLexer::mWhitespace(bool _createToken) {
421   }
422  
423   void MDLexer::mWhitespace(bool _createToken) {
424 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
424 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
425          _ttype = Whitespace;
426 <        int _saveIndex;
426 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
427          
428          {
429          switch ( LA(1)) {
# Line 434 | Line 435 | void MDLexer::mWhitespace(bool _createToken) {
435                  switch ( LA(1)) {
436                  case 0x20 /* ' ' */ :
437                  {
438 <                        match(' ');
438 >                        match(' ' /* charlit */ );
439                          break;
440                  }
441                  case 0x9 /* '\t' */ :
442                  {
443 <                        match('\t');
443 >                        match('\t' /* charlit */ );
444                          break;
445                  }
446                  case 0xc /* '\14' */ :
447                  {
448 <                        match('\14');
448 >                        match('\14' /* charlit */ );
449                          break;
450                  }
451                  default:
# Line 460 | Line 461 | void MDLexer::mWhitespace(bool _createToken) {
461          {
462                  {
463                  if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
464 <                        match('\r');
465 <                        match('\n');
464 >                        match('\r' /* charlit */ );
465 >                        match('\n' /* charlit */ );
466                  }
467                  else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
468 <                        match('\r');
468 >                        match('\r' /* charlit */ );
469                  }
470                  else if ((LA(1) == 0xa /* '\n' */ )) {
471 <                        match('\n');
471 >                        match('\n' /* charlit */ );
472                  }
473                  else {
474                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 475 | Line 476 | void MDLexer::mWhitespace(bool _createToken) {
476                  
477                  }
478                  if ( inputState->guessing==0 ) {
479 < #line 227 "MDParser.g"
479 > #line 233 "MDParser.g"
480                          newline();
481 < #line 481 "MDLexer.cpp"
481 > #line 482 "MDLexer.cpp"
482                  }
483                  break;
484          }
# Line 485 | Line 486 | void MDLexer::mWhitespace(bool _createToken) {
486          {
487                  {
488                  if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
489 <                        match('\\');
490 <                        match('\r');
491 <                        match('\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('\\');
495 <                        match('\r');
494 >                        match('\\' /* charlit */ );
495 >                        match('\r' /* charlit */ );
496                  }
497                  else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
498 <                        match('\\');
499 <                        match('\n');
498 >                        match('\\' /* charlit */ );
499 >                        match('\n' /* charlit */ );
500                  }
501                  else {
502                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 503 | Line 504 | void MDLexer::mWhitespace(bool _createToken) {
504                  
505                  }
506                  if ( inputState->guessing==0 ) {
507 < #line 232 "MDParser.g"
507 > #line 238 "MDParser.g"
508                          printf("CPP_parser.g continuation line detected\n");
509                          deferredNewline();
510 < #line 510 "MDLexer.cpp"
510 > #line 511 "MDLexer.cpp"
511                  }
512                  break;
513          }
# Line 517 | Line 518 | void MDLexer::mWhitespace(bool _createToken) {
518          }
519          }
520          if ( inputState->guessing==0 ) {
521 < #line 235 "MDParser.g"
521 > #line 241 "MDParser.g"
522                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
523 < #line 523 "MDLexer.cpp"
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);
# Line 530 | Line 531 | void MDLexer::mComment(bool _createToken) {
531   }
532  
533   void MDLexer::mComment(bool _createToken) {
534 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
534 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
535          _ttype = Comment;
536 <        int _saveIndex;
536 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
537          
538          match("/*");
539          { // ( ... )*
540          for (;;) {
541 <                if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
542 <                        match('*');
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 242 "MDParser.g"
547 > #line 248 "MDParser.g"
548                                  deferredNewline();
549 < #line 549 "MDLexer.cpp"
549 > #line 550 "MDLexer.cpp"
550                          }
551                  }
552                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 554 | Line 555 | void MDLexer::mComment(bool _createToken) {
555                          }
556                  }
557                  else {
558 <                        goto _loop83;
558 >                        goto _loop86;
559                  }
560                  
561          }
562 <        _loop83:;
562 >        _loop86:;
563          } // ( ... )*
564          match("*/");
565          if ( inputState->guessing==0 ) {
566 < #line 245 "MDParser.g"
566 > #line 251 "MDParser.g"
567                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
568 < #line 568 "MDLexer.cpp"
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);
# Line 575 | Line 576 | void MDLexer::mEndOfLine(bool _createToken) {
576   }
577  
578   void MDLexer::mEndOfLine(bool _createToken) {
579 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
579 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
580          _ttype = EndOfLine;
581 <        int _saveIndex;
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');
588 >                match('\r' /* charlit */ );
589          }
590          else if ((LA(1) == 0xa /* '\n' */ )) {
591 <                match('\n');
591 >                match('\n' /* charlit */ );
592          }
593          else {
594                  throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 603 | Line 604 | void MDLexer::mCPPComment(bool _createToken) {
604   }
605  
606   void MDLexer::mCPPComment(bool _createToken) {
607 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
607 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
608          _ttype = CPPComment;
609 <        int _saveIndex;
609 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
610          
611          match("//");
612          { // ( ... )*
# Line 616 | Line 617 | void MDLexer::mCPPComment(bool _createToken) {
617                          }
618                  }
619                  else {
620 <                        goto _loop87;
620 >                        goto _loop90;
621                  }
622                  
623          }
624 <        _loop87:;
624 >        _loop90:;
625          } // ( ... )*
626          mEndOfLine(false);
627          if ( inputState->guessing==0 ) {
628 < #line 251 "MDParser.g"
628 > #line 257 "MDParser.g"
629                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
630 < #line 630 "MDLexer.cpp"
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);
# Line 637 | Line 638 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
638   }
639  
640   void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
641 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
641 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
642          _ttype = PREPROC_DIRECTIVE;
643 <        int _saveIndex;
643 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
644          
645 <        match('#');
645 >        match('#' /* charlit */ );
646          mLineDirective(false);
647          if ( inputState->guessing==0 ) {
648 < #line 258 "MDParser.g"
648 > #line 264 "MDParser.g"
649                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
650 < #line 650 "MDLexer.cpp"
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);
# Line 657 | Line 658 | void MDLexer::mLineDirective(bool _createToken) {
658   }
659  
660   void MDLexer::mLineDirective(bool _createToken) {
661 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
661 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
662          _ttype = LineDirective;
663 <        int _saveIndex;
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 264 "MDParser.g"
668 > #line 270 "MDParser.g"
669                  
670                  deferredLineCount = 0;
671                  
672 < #line 672 "MDLexer.cpp"
672 > #line 673 "MDLexer.cpp"
673          }
674          {
675          switch ( LA(1)) {
# Line 690 | Line 691 | void MDLexer::mLineDirective(bool _createToken) {
691          }
692          }
693          { // ( ... )+
694 <        int _cnt92=0;
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 ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
700 >                        if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
701                  }
702                  
703 <                _cnt92++;
703 >                _cnt95++;
704          }
705 <        _loop92:;
705 >        _loop95:;
706          }  // ( ... )+
707          mDecimal(true);
708          n=_returnToken;
709          if ( inputState->guessing==0 ) {
710 < #line 269 "MDParser.g"
711 <                setLine(oopse::lexi_cast<int>(n->getText()) - 1);
712 < #line 712 "MDLexer.cpp"
710 > #line 275 "MDParser.g"
711 >                setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
712 > #line 713 "MDLexer.cpp"
713          }
714          { // ( ... )+
715 <        int _cnt94=0;
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 ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
721 >                        if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
722                  }
723                  
724 <                _cnt94++;
724 >                _cnt97++;
725          }
726 <        _loop94:;
726 >        _loop97:;
727          }  // ( ... )+
728          {
729          mStringLiteral(true);
730          sl=_returnToken;
731          }
732          if ( inputState->guessing==0 ) {
733 < #line 271 "MDParser.g"
733 > #line 277 "MDParser.g"
734                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
735 < #line 735 "MDLexer.cpp"
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 _cnt98=0;
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 ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
747 >                                        if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
748                                  }
749                                  
750 <                                _cnt98++;
750 >                                _cnt101++;
751                          }
752 <                        _loop98:;
752 >                        _loop101:;
753                          }  // ( ... )+
754                          mDecimal(false);
755                  }
756                  else {
757 <                        goto _loop99;
757 >                        goto _loop102;
758                  }
759                  
760          }
761 <        _loop99:;
761 >        _loop102:;
762          } // ( ... )*
763          mEndOfLine(false);
764          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 769 | Line 770 | void MDLexer::mSpace(bool _createToken) {
770   }
771  
772   void MDLexer::mSpace(bool _createToken) {
773 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
773 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
774          _ttype = Space;
775 <        int _saveIndex;
775 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
776          
777          {
778          switch ( LA(1)) {
779          case 0x20 /* ' ' */ :
780          {
781 <                match(' ');
781 >                match(' ' /* charlit */ );
782                  break;
783          }
784          case 0x9 /* '\t' */ :
785          {
786 <                match('\t');
786 >                match('\t' /* charlit */ );
787                  break;
788          }
789          case 0xc /* '\14' */ :
790          {
791 <                match('\14');
791 >                match('\14' /* charlit */ );
792                  break;
793          }
794          default:
# Line 805 | Line 806 | void MDLexer::mDecimal(bool _createToken) {
806   }
807  
808   void MDLexer::mDecimal(bool _createToken) {
809 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
809 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
810          _ttype = Decimal;
811 <        int _saveIndex;
811 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
812          
813          { // ( ... )+
814 <        int _cnt129=0;
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 ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
820 >                        if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
821                  }
822                  
823 <                _cnt129++;
823 >                _cnt132++;
824          }
825 <        _loop129:;
825 >        _loop132:;
826          }  // ( ... )+
827          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
828             _token = makeToken(_ttype);
# Line 832 | Line 833 | void MDLexer::mStringLiteral(bool _createToken) {
833   }
834  
835   void MDLexer::mStringLiteral(bool _createToken) {
836 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
836 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
837          _ttype = StringLiteral;
838 <        int _saveIndex;
838 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
839          
840 <        match('"');
840 >        match('\"' /* charlit */ );
841          { // ( ... )*
842          for (;;) {
843                  if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
# Line 845 | Line 846 | void MDLexer::mStringLiteral(bool _createToken) {
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");
849 >                                match("\\\r\n");
850                          }
851                          else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
852 <                                match("\\r");
852 >                                match("\\\r");
853                          }
854                          else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
855 <                                match("\\n");
855 >                                match("\\\n");
856                          }
857                          else {
858                                  throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 859 | Line 860 | void MDLexer::mStringLiteral(bool _createToken) {
860                          
861                          }
862                          if ( inputState->guessing==0 ) {
863 < #line 311 "MDParser.g"
863 > #line 317 "MDParser.g"
864                                  deferredNewline();
865 < #line 865 "MDLexer.cpp"
865 > #line 866 "MDLexer.cpp"
866                          }
867                  }
868                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 870 | Line 871 | void MDLexer::mStringLiteral(bool _createToken) {
871                          }
872                  }
873                  else {
874 <                        goto _loop109;
874 >                        goto _loop112;
875                  }
876                  
877          }
878 <        _loop109:;
878 >        _loop112:;
879          } // ( ... )*
880 <        match('"');
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));
# Line 886 | Line 887 | void MDLexer::mCharLiteral(bool _createToken) {
887   }
888  
889   void MDLexer::mCharLiteral(bool _createToken) {
890 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
890 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
891          _ttype = CharLiteral;
892 <        int _saveIndex;
892 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
893          
894 <        match('\'');
894 >        match('\'' /* charlit */ );
895          {
896          if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
897                  mEscape(false);
# Line 905 | Line 906 | void MDLexer::mCharLiteral(bool _createToken) {
906          }
907          
908          }
909 <        match('\'');
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));
# Line 915 | Line 916 | void MDLexer::mEscape(bool _createToken) {
916   }
917  
918   void MDLexer::mEscape(bool _createToken) {
919 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
919 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
920          _ttype = Escape;
921 <        int _saveIndex;
921 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
922          
923 <        match('\\');
923 >        match('\\' /* charlit */ );
924          {
925          switch ( LA(1)) {
926          case 0x61 /* 'a' */ :
927          {
928 <                match('a');
928 >                match('a' /* charlit */ );
929                  break;
930          }
931          case 0x62 /* 'b' */ :
932          {
933 <                match('b');
933 >                match('b' /* charlit */ );
934                  break;
935          }
936          case 0x66 /* 'f' */ :
937          {
938 <                match('f');
938 >                match('f' /* charlit */ );
939                  break;
940          }
941          case 0x6e /* 'n' */ :
942          {
943 <                match('n');
943 >                match('n' /* charlit */ );
944                  break;
945          }
946          case 0x72 /* 'r' */ :
947          {
948 <                match('r');
948 >                match('r' /* charlit */ );
949                  break;
950          }
951          case 0x74 /* 't' */ :
952          {
953 <                match('t');
953 >                match('t' /* charlit */ );
954                  break;
955          }
956          case 0x76 /* 'v' */ :
957          {
958 <                match('v');
958 >                match('v' /* charlit */ );
959                  break;
960          }
961 <        case 0x22 /* '"' */ :
961 >        case 0x22 /* '\"' */ :
962          {
963 <                match('"');
963 >                match('\"' /* charlit */ );
964                  break;
965          }
966          case 0x27 /* '\'' */ :
967          {
968 <                match('\'');
968 >                match('\'' /* charlit */ );
969                  break;
970          }
971          case 0x5c /* '\\' */ :
972          {
973 <                match('\\');
973 >                match('\\' /* charlit */ );
974                  break;
975          }
976          case 0x3f /* '?' */ :
977          {
978 <                match('?');
978 >                match('?' /* charlit */ );
979                  break;
980          }
981          case 0x30 /* '0' */ :
# Line 1032 | Line 1033 | void MDLexer::mEscape(bool _createToken) {
1033          }
1034          case 0x78 /* 'x' */ :
1035          {
1036 <                match('x');
1036 >                match('x' /* charlit */ );
1037                  { // ( ... )+
1038 <                int _cnt120=0;
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);
# Line 1046 | Line 1047 | void MDLexer::mEscape(bool _createToken) {
1047                                  matchRange('A','F');
1048                          }
1049                          else {
1050 <                                if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1050 >                                if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1051                          }
1052                          
1053 <                        _cnt120++;
1053 >                        _cnt123++;
1054                  }
1055 <                _loop120:;
1055 >                _loop123:;
1056                  }  // ( ... )+
1057                  break;
1058          }
# Line 1070 | Line 1071 | void MDLexer::mDigit(bool _createToken) {
1071   }
1072  
1073   void MDLexer::mDigit(bool _createToken) {
1074 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1074 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1075          _ttype = Digit;
1076 <        int _saveIndex;
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 ) {
# Line 1084 | Line 1085 | void MDLexer::mVocabulary(bool _createToken) {
1085   }
1086  
1087   void MDLexer::mVocabulary(bool _createToken) {
1088 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1088 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1089          _ttype = Vocabulary;
1090 <        int _saveIndex;
1090 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1091          
1092 <        matchRange('\3',static_cast<unsigned char>(255));
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));
# Line 1098 | Line 1099 | void MDLexer::mID(bool _createToken) {
1099   }
1100  
1101   void MDLexer::mID(bool _createToken) {
1102 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1102 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1103          _ttype = ID;
1104 <        int _saveIndex;
1104 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1105          
1106          {
1107          switch ( LA(1)) {
# Line 1166 | Line 1167 | void MDLexer::mID(bool _createToken) {
1167          }
1168          case 0x5f /* '_' */ :
1169          {
1170 <                match('_');
1170 >                match('_' /* charlit */ );
1171                  break;
1172          }
1173          default:
# Line 1240 | Line 1241 | void MDLexer::mID(bool _createToken) {
1241                  }
1242                  case 0x5f /* '_' */ :
1243                  {
1244 <                        match('_');
1244 >                        match('_' /* charlit */ );
1245                          break;
1246                  }
1247                  case 0x30 /* '0' */ :
# Line 1259 | Line 1260 | void MDLexer::mID(bool _createToken) {
1260                  }
1261                  default:
1262                  {
1263 <                        goto _loop125;
1263 >                        goto _loop128;
1264                  }
1265                  }
1266          }
1267 <        _loop125:;
1267 >        _loop128:;
1268          } // ( ... )*
1269          _ttype = testLiteralsTable(_ttype);
1270          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1275 | Line 1276 | void MDLexer::mHEX_DIGIT(bool _createToken) {
1276   }
1277  
1278   void MDLexer::mHEX_DIGIT(bool _createToken) {
1279 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1279 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1280          _ttype = HEX_DIGIT;
1281 <        int _saveIndex;
1281 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1282          
1283          {
1284          switch ( LA(1)) {
# Line 1330 | Line 1331 | void MDLexer::mNUM_INT(bool _createToken) {
1331   }
1332  
1333   void MDLexer::mNUM_INT(bool _createToken) {
1334 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1334 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1335          _ttype = NUM_INT;
1336 <        int _saveIndex;
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 404 "MDParser.g"
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 1346 "MDLexer.cpp"
1346 > #line 1347 "MDLexer.cpp"
1347          
1348          {
1349          switch ( LA(1)) {
1350          case 0x2b /* '+' */ :
1351          {
1352 <                match('+');
1352 >                match('+' /* charlit */ );
1353                  break;
1354          }
1355          case 0x2d /* '-' */ :
1356          {
1357 <                match('-');
1357 >                match('-' /* charlit */ );
1358                  break;
1359          }
1360          case 0x2e /* '.' */ :
# Line 1380 | Line 1381 | void MDLexer::mNUM_INT(bool _createToken) {
1381          switch ( LA(1)) {
1382          case 0x2e /* '.' */ :
1383          {
1384 <                match('.');
1384 >                match('.' /* charlit */ );
1385                  if ( inputState->guessing==0 ) {
1386 < #line 411 "MDParser.g"
1386 > #line 417 "MDParser.g"
1387                          _ttype = DOT;
1388 < #line 1388 "MDLexer.cpp"
1388 > #line 1389 "MDLexer.cpp"
1389                  }
1390                  {
1391                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1392                          { // ( ... )+
1393 <                        int _cnt137=0;
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 ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1399 >                                        if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1400                                  }
1401                                  
1402 <                                _cnt137++;
1402 >                                _cnt140++;
1403                          }
1404 <                        _loop137:;
1404 >                        _loop140:;
1405                          }  // ( ... )+
1406                          {
1407                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1415 | Line 1416 | void MDLexer::mNUM_INT(bool _createToken) {
1416                                  mFLOAT_SUFFIX(true);
1417                                  f1=_returnToken;
1418                                  if ( inputState->guessing==0 ) {
1419 < #line 412 "MDParser.g"
1419 > #line 418 "MDParser.g"
1420                                          t=f1;
1421 < #line 1421 "MDLexer.cpp"
1421 > #line 1422 "MDLexer.cpp"
1422                                  }
1423                          }
1424                          else {
# Line 1425 | Line 1426 | void MDLexer::mNUM_INT(bool _createToken) {
1426                          
1427                          }
1428                          if ( inputState->guessing==0 ) {
1429 < #line 413 "MDParser.g"
1429 > #line 419 "MDParser.g"
1430                                  
1431                                                                          if ( t &&
1432                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1436 | Line 1437 | void MDLexer::mNUM_INT(bool _createToken) {
1437                                                                                  _ttype = NUM_DOUBLE; // assume double
1438                                                                          }
1439                                                                  
1440 < #line 1440 "MDLexer.cpp"
1440 > #line 1441 "MDLexer.cpp"
1441                          }
1442                  }
1443                  else {
# Line 1460 | Line 1461 | void MDLexer::mNUM_INT(bool _createToken) {
1461                  switch ( LA(1)) {
1462                  case 0x30 /* '0' */ :
1463                  {
1464 <                        match('0');
1464 >                        match('0' /* charlit */ );
1465                          if ( inputState->guessing==0 ) {
1466 < #line 425 "MDParser.g"
1466 > #line 431 "MDParser.g"
1467                                  isDecimal = true;
1468 < #line 1468 "MDLexer.cpp"
1468 > #line 1469 "MDLexer.cpp"
1469                          }
1470                          {
1471                          if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
# Line 1472 | Line 1473 | void MDLexer::mNUM_INT(bool _createToken) {
1473                                  switch ( LA(1)) {
1474                                  case 0x78 /* 'x' */ :
1475                                  {
1476 <                                        match('x');
1476 >                                        match('x' /* charlit */ );
1477                                          break;
1478                                  }
1479                                  case 0x58 /* 'X' */ :
1480                                  {
1481 <                                        match('X');
1481 >                                        match('X' /* charlit */ );
1482                                          break;
1483                                  }
1484                                  default:
# Line 1487 | Line 1488 | void MDLexer::mNUM_INT(bool _createToken) {
1488                                  }
1489                                  }
1490                                  { // ( ... )+
1491 <                                int _cnt144=0;
1491 >                                int _cnt147=0;
1492                                  for (;;) {
1493                                          if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1494                                                  mHEX_DIGIT(false);
1495                                          }
1496                                          else {
1497 <                                                if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1497 >                                                if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1498                                          }
1499                                          
1500 <                                        _cnt144++;
1500 >                                        _cnt147++;
1501                                  }
1502 <                                _loop144:;
1502 >                                _loop147:;
1503                                  }  // ( ... )+
1504                          }
1505                          else {
1506 <                                bool synPredMatched149 = false;
1506 >                                bool synPredMatched152 = false;
1507                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1508 <                                        int _m149 = mark();
1509 <                                        synPredMatched149 = true;
1508 >                                        int _m152 = mark();
1509 >                                        synPredMatched152 = true;
1510                                          inputState->guessing++;
1511                                          try {
1512                                                  {
1513                                                  { // ( ... )+
1514 <                                                int _cnt147=0;
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 ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1520 >                                                                if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521                                                          }
1522                                                          
1523 <                                                        _cnt147++;
1523 >                                                        _cnt150++;
1524                                                  }
1525 <                                                _loop147:;
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('.');
1532 >                                                        match('.' /* charlit */ );
1533                                                  }
1534                                                  else if ((_tokenSet_8.member(LA(1))) && (true)) {
1535                                                          mFLOAT_SUFFIX(false);
# Line 1541 | Line 1542 | void MDLexer::mNUM_INT(bool _createToken) {
1542                                                  }
1543                                          }
1544                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1545 <                                                synPredMatched149 = false;
1545 >                                                synPredMatched152 = false;
1546                                          }
1547 <                                        rewind(_m149);
1547 >                                        rewind(_m152);
1548                                          inputState->guessing--;
1549                                  }
1550 <                                if ( synPredMatched149 ) {
1550 >                                if ( synPredMatched152 ) {
1551                                          { // ( ... )+
1552 <                                        int _cnt151=0;
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 ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1558 >                                                        if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1559                                                  }
1560                                                  
1561 <                                                _cnt151++;
1561 >                                                _cnt154++;
1562                                          }
1563 <                                        _loop151:;
1563 >                                        _loop154:;
1564                                          }  // ( ... )+
1565                                  }
1566                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1567                                          { // ( ... )+
1568 <                                        int _cnt153=0;
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 ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1574 >                                                        if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1575                                                  }
1576                                                  
1577 <                                                _cnt153++;
1577 >                                                _cnt156++;
1578                                          }
1579 <                                        _loop153:;
1579 >                                        _loop156:;
1580                                          }  // ( ... )+
1581                                  }
1582                                  else {
# Line 1603 | Line 1604 | void MDLexer::mNUM_INT(bool _createToken) {
1604                                          matchRange('0','9');
1605                                  }
1606                                  else {
1607 <                                        goto _loop156;
1607 >                                        goto _loop159;
1608                                  }
1609                                  
1610                          }
1611 <                        _loop156:;
1611 >                        _loop159:;
1612                          } // ( ... )*
1613                          if ( inputState->guessing==0 ) {
1614 < #line 442 "MDParser.g"
1614 > #line 448 "MDParser.g"
1615                                  isDecimal=true;
1616 < #line 1616 "MDLexer.cpp"
1616 > #line 1617 "MDLexer.cpp"
1617                          }
1618                          break;
1619                  }
# Line 1628 | Line 1629 | void MDLexer::mNUM_INT(bool _createToken) {
1629                          switch ( LA(1)) {
1630                          case 0x6c /* 'l' */ :
1631                          {
1632 <                                match('l');
1632 >                                match('l' /* charlit */ );
1633                                  break;
1634                          }
1635                          case 0x4c /* 'L' */ :
1636                          {
1637 <                                match('L');
1637 >                                match('L' /* charlit */ );
1638                                  break;
1639                          }
1640                          default:
# Line 1643 | Line 1644 | void MDLexer::mNUM_INT(bool _createToken) {
1644                          }
1645                          }
1646                          if ( inputState->guessing==0 ) {
1647 < #line 444 "MDParser.g"
1647 > #line 450 "MDParser.g"
1648                                  _ttype = NUM_LONG;
1649 < #line 1649 "MDLexer.cpp"
1649 > #line 1650 "MDLexer.cpp"
1650                          }
1651                  }
1652                  else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
# Line 1657 | Line 1658 | void MDLexer::mNUM_INT(bool _createToken) {
1658                                          mFLOAT_SUFFIX(true);
1659                                          f3=_returnToken;
1660                                          if ( inputState->guessing==0 ) {
1661 < #line 449 "MDParser.g"
1661 > #line 455 "MDParser.g"
1662                                                  t=f3;
1663 < #line 1663 "MDLexer.cpp"
1663 > #line 1664 "MDLexer.cpp"
1664                                          }
1665                                  }
1666                                  else {
# Line 1668 | Line 1669 | void MDLexer::mNUM_INT(bool _createToken) {
1669                                  }
1670                          }
1671                          else if ((LA(1) == 0x2e /* '.' */ )) {
1672 <                                match('.');
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 _loop161;
1679 >                                                goto _loop164;
1680                                          }
1681                                          
1682                                  }
1683 <                                _loop161:;
1683 >                                _loop164:;
1684                                  } // ( ... )*
1685                                  {
1686                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1694 | Line 1695 | void MDLexer::mNUM_INT(bool _createToken) {
1695                                          mFLOAT_SUFFIX(true);
1696                                          f2=_returnToken;
1697                                          if ( inputState->guessing==0 ) {
1698 < #line 448 "MDParser.g"
1698 > #line 454 "MDParser.g"
1699                                                  t=f2;
1700 < #line 1700 "MDLexer.cpp"
1700 > #line 1701 "MDLexer.cpp"
1701                                          }
1702                                  }
1703                                  else {
# Line 1708 | Line 1709 | void MDLexer::mNUM_INT(bool _createToken) {
1709                                  mFLOAT_SUFFIX(true);
1710                                  f4=_returnToken;
1711                                  if ( inputState->guessing==0 ) {
1712 < #line 450 "MDParser.g"
1712 > #line 456 "MDParser.g"
1713                                          t=f4;
1714 < #line 1714 "MDLexer.cpp"
1714 > #line 1715 "MDLexer.cpp"
1715                                  }
1716                          }
1717                          else {
# Line 1719 | Line 1720 | void MDLexer::mNUM_INT(bool _createToken) {
1720                          
1721                          }
1722                          if ( inputState->guessing==0 ) {
1723 < #line 452 "MDParser.g"
1723 > #line 458 "MDParser.g"
1724                                  
1725                                                                          if ( t &&
1726                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1730 | Line 1731 | void MDLexer::mNUM_INT(bool _createToken) {
1731                                                                                  _ttype = NUM_DOUBLE; // assume double
1732                                                                          }
1733                                                                  
1734 < #line 1734 "MDLexer.cpp"
1734 > #line 1735 "MDLexer.cpp"
1735                          }
1736                  }
1737                  else {
# Line 1754 | Line 1755 | void MDLexer::mEXPONENT(bool _createToken) {
1755   }
1756  
1757   void MDLexer::mEXPONENT(bool _createToken) {
1758 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1758 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1759          _ttype = EXPONENT;
1760 <        int _saveIndex;
1760 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1761          
1762          {
1763          switch ( LA(1)) {
1764          case 0x65 /* 'e' */ :
1765          {
1766 <                match('e');
1766 >                match('e' /* charlit */ );
1767                  break;
1768          }
1769          case 0x45 /* 'E' */ :
1770          {
1771 <                match('E');
1771 >                match('E' /* charlit */ );
1772                  break;
1773          }
1774          case 0x64 /* 'd' */ :
1775          {
1776 <                match('d');
1776 >                match('d' /* charlit */ );
1777                  break;
1778          }
1779          case 0x44 /* 'D' */ :
1780          {
1781 <                match('D');
1781 >                match('D' /* charlit */ );
1782                  break;
1783          }
1784          default:
# Line 1790 | Line 1791 | void MDLexer::mEXPONENT(bool _createToken) {
1791          switch ( LA(1)) {
1792          case 0x2b /* '+' */ :
1793          {
1794 <                match('+');
1794 >                match('+' /* charlit */ );
1795                  break;
1796          }
1797          case 0x2d /* '-' */ :
1798          {
1799 <                match('-');
1799 >                match('-' /* charlit */ );
1800                  break;
1801          }
1802          case 0x30 /* '0' */ :
# Line 1818 | Line 1819 | void MDLexer::mEXPONENT(bool _createToken) {
1819          }
1820          }
1821          { // ( ... )+
1822 <        int _cnt169=0;
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 ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1828 >                        if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1829                  }
1830                  
1831 <                _cnt169++;
1831 >                _cnt172++;
1832          }
1833 <        _loop169:;
1833 >        _loop172:;
1834          }  // ( ... )+
1835          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1836             _token = makeToken(_ttype);
# Line 1840 | Line 1841 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1841   }
1842  
1843   void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1844 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1844 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1845          _ttype = FLOAT_SUFFIX;
1846 <        int _saveIndex;
1846 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1847          
1848          switch ( LA(1)) {
1849          case 0x66 /* 'f' */ :
1850          {
1851 <                match('f');
1851 >                match('f' /* charlit */ );
1852                  break;
1853          }
1854          case 0x46 /* 'F' */ :
1855          {
1856 <                match('F');
1856 >                match('F' /* charlit */ );
1857                  break;
1858          }
1859          case 0x64 /* 'd' */ :
1860          {
1861 <                match('d');
1861 >                match('d' /* charlit */ );
1862                  break;
1863          }
1864          case 0x44 /* 'D' */ :
1865          {
1866 <                match('D');
1866 >                match('D' /* charlit */ );
1867                  break;
1868          }
1869          default:
# Line 1879 | Line 1880 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1880   }
1881  
1882  
1883 < const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1884 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1885 < // 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1886 < // \' ( ) + , - . / 0 1 2 3 4
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_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1889 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1890 < // 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1891 < // \' ( ) * + , - . / 0 1 2 3 4
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
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_[] = { 4294958072UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1898 < // 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! # $ % & \'
1899 < // ( ) * + , - . / 0 1 2 3 4
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
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_[] = { 4294967288UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
1906 < // 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " #
1907 < // $ % & ( ) * + , - . / 0 1 2 3 4
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
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
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   // .

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines