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 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.4: "MDParser.g" -> "MDLexer.cpp"$ */
1 > /* $ANTLR 2.7.7 (20080702): "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["members"] = 15;
34 +        literals["position"] = 17;
35          literals["torsion"] = 10;
36 <        literals["molecule"] = 5;
36 >        literals["component"] = 4;
37 >        literals["rigidBody"] = 12;
38 >        literals["center"] = 16;
39          literals["inversion"] = 11;
40 <        literals["fragment"] = 14;
40 >        literals["zconstraint"] = 6;
41 >        literals["cutoffGroup"] = 13;
42          literals["bend"] = 9;
43          literals["orientation"] = 18;
44 <        literals["cutoffGroup"] = 13;
40 <        literals["zconstraint"] = 6;
44 >        literals["fragment"] = 14;
45          literals["bond"] = 8;
46 <        literals["rigidBody"] = 12;
43 <        literals["center"] = 16;
44 <        literals["component"] = 4;
45 <        literals["position"] = 17;
46 >        literals["molecule"] = 5;
47          literals["atom"] = 7;
47 –        literals["members"] = 15;
48   }
49  
50   ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
# Line 139 | Line 139 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
139                                  theRetToken=_returnToken;
140                                  break;
141                          }
142 <                        case 0x22 /* '"' */ :
142 >                        case 0x22 /* '\"' */ :
143                          {
144                                  mStringLiteral(true);
145                                  theRetToken=_returnToken;
# Line 266 | Line 266 | void MDLexer::mASSIGNEQUAL(bool _createToken) {
266   }
267  
268   void MDLexer::mASSIGNEQUAL(bool _createToken) {
269 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
270 <        _ttype = ASSIGNEQUAL;
271 <        int _saveIndex;
269 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
270 >        _ttype = ASSIGNEQUAL;
271 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
272          
273 <        match('=');
273 >        match('=' /* charlit */ );
274          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
275             _token = makeToken(_ttype);
276             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 280 | Line 280 | void MDLexer::mCOLON(bool _createToken) {
280   }
281  
282   void MDLexer::mCOLON(bool _createToken) {
283 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
283 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
284          _ttype = COLON;
285 <        int _saveIndex;
285 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
286          
287 <        match(':');
287 >        match(':' /* charlit */ );
288          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
289             _token = makeToken(_ttype);
290             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 294 | Line 294 | void MDLexer::mCOMMA(bool _createToken) {
294   }
295  
296   void MDLexer::mCOMMA(bool _createToken) {
297 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
297 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
298          _ttype = COMMA;
299 <        int _saveIndex;
299 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
300          
301 <        match(',');
301 >        match(',' /* charlit */ );
302          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
303             _token = makeToken(_ttype);
304             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 308 | Line 308 | void MDLexer::mQUESTIONMARK(bool _createToken) {
308   }
309  
310   void MDLexer::mQUESTIONMARK(bool _createToken) {
311 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
311 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
312          _ttype = QUESTIONMARK;
313 <        int _saveIndex;
313 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
314          
315 <        match('?');
315 >        match('?' /* charlit */ );
316          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
317             _token = makeToken(_ttype);
318             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 322 | Line 322 | void MDLexer::mSEMICOLON(bool _createToken) {
322   }
323  
324   void MDLexer::mSEMICOLON(bool _createToken) {
325 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
325 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
326          _ttype = SEMICOLON;
327 <        int _saveIndex;
327 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
328          
329 <        match(';');
329 >        match(';' /* charlit */ );
330          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
331             _token = makeToken(_ttype);
332             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 336 | Line 336 | void MDLexer::mLPAREN(bool _createToken) {
336   }
337  
338   void MDLexer::mLPAREN(bool _createToken) {
339 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
339 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
340          _ttype = LPAREN;
341 <        int _saveIndex;
341 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
342          
343 <        match('(');
343 >        match('(' /* charlit */ );
344          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
345             _token = makeToken(_ttype);
346             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 350 | Line 350 | void MDLexer::mRPAREN(bool _createToken) {
350   }
351  
352   void MDLexer::mRPAREN(bool _createToken) {
353 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
353 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
354          _ttype = RPAREN;
355 <        int _saveIndex;
355 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
356          
357 <        match(')');
357 >        match(')' /* charlit */ );
358          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
359             _token = makeToken(_ttype);
360             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 364 | Line 364 | void MDLexer::mLBRACKET(bool _createToken) {
364   }
365  
366   void MDLexer::mLBRACKET(bool _createToken) {
367 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
367 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
368          _ttype = LBRACKET;
369 <        int _saveIndex;
369 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
370          
371 <        match('[');
371 >        match('[' /* charlit */ );
372          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
373             _token = makeToken(_ttype);
374             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 378 | Line 378 | void MDLexer::mRBRACKET(bool _createToken) {
378   }
379  
380   void MDLexer::mRBRACKET(bool _createToken) {
381 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
381 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
382          _ttype = RBRACKET;
383 <        int _saveIndex;
383 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
384          
385 <        match(']');
385 >        match(']' /* charlit */ );
386          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
387             _token = makeToken(_ttype);
388             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 392 | Line 392 | void MDLexer::mLCURLY(bool _createToken) {
392   }
393  
394   void MDLexer::mLCURLY(bool _createToken) {
395 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
395 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
396          _ttype = LCURLY;
397 <        int _saveIndex;
397 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
398          
399 <        match('{');
399 >        match('{' /* charlit */ );
400          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
401             _token = makeToken(_ttype);
402             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 406 | Line 406 | void MDLexer::mRCURLY(bool _createToken) {
406   }
407  
408   void MDLexer::mRCURLY(bool _createToken) {
409 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
409 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
410          _ttype = RCURLY;
411 <        int _saveIndex;
411 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
412          
413 <        match('}');
413 >        match('}' /* charlit */ );
414          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
415             _token = makeToken(_ttype);
416             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 420 | Line 420 | void MDLexer::mWhitespace(bool _createToken) {
420   }
421  
422   void MDLexer::mWhitespace(bool _createToken) {
423 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
423 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
424          _ttype = Whitespace;
425 <        int _saveIndex;
425 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
426          
427          {
428          switch ( LA(1)) {
# Line 434 | Line 434 | void MDLexer::mWhitespace(bool _createToken) {
434                  switch ( LA(1)) {
435                  case 0x20 /* ' ' */ :
436                  {
437 <                        match(' ');
437 >                        match(' ' /* charlit */ );
438                          break;
439                  }
440                  case 0x9 /* '\t' */ :
441                  {
442 <                        match('\t');
442 >                        match('\t' /* charlit */ );
443                          break;
444                  }
445                  case 0xc /* '\14' */ :
446                  {
447 <                        match('\14');
447 >                        match('\14' /* charlit */ );
448                          break;
449                  }
450                  default:
# Line 460 | Line 460 | void MDLexer::mWhitespace(bool _createToken) {
460          {
461                  {
462                  if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
463 <                        match('\r');
464 <                        match('\n');
463 >                        match('\r' /* charlit */ );
464 >                        match('\n' /* charlit */ );
465                  }
466                  else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
467 <                        match('\r');
467 >                        match('\r' /* charlit */ );
468                  }
469                  else if ((LA(1) == 0xa /* '\n' */ )) {
470 <                        match('\n');
470 >                        match('\n' /* charlit */ );
471                  }
472                  else {
473                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 475 | Line 475 | void MDLexer::mWhitespace(bool _createToken) {
475                  
476                  }
477                  if ( inputState->guessing==0 ) {
478 < #line 227 "MDParser.g"
478 > #line 228 "MDParser.g"
479                          newline();
480   #line 481 "MDLexer.cpp"
481                  }
# Line 485 | Line 485 | void MDLexer::mWhitespace(bool _createToken) {
485          {
486                  {
487                  if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
488 <                        match('\\');
489 <                        match('\r');
490 <                        match('\n');
488 >                        match('\\' /* charlit */ );
489 >                        match('\r' /* charlit */ );
490 >                        match('\n' /* charlit */ );
491                  }
492                  else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
493 <                        match('\\');
494 <                        match('\r');
493 >                        match('\\' /* charlit */ );
494 >                        match('\r' /* charlit */ );
495                  }
496                  else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
497 <                        match('\\');
498 <                        match('\n');
497 >                        match('\\' /* charlit */ );
498 >                        match('\n' /* charlit */ );
499                  }
500                  else {
501                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 503 | Line 503 | void MDLexer::mWhitespace(bool _createToken) {
503                  
504                  }
505                  if ( inputState->guessing==0 ) {
506 < #line 232 "MDParser.g"
506 > #line 233 "MDParser.g"
507                          printf("CPP_parser.g continuation line detected\n");
508                          deferredNewline();
509   #line 510 "MDLexer.cpp"
# Line 517 | Line 517 | void MDLexer::mWhitespace(bool _createToken) {
517          }
518          }
519          if ( inputState->guessing==0 ) {
520 < #line 235 "MDParser.g"
520 > #line 236 "MDParser.g"
521                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
522   #line 523 "MDLexer.cpp"
523          }
# Line 530 | Line 530 | void MDLexer::mComment(bool _createToken) {
530   }
531  
532   void MDLexer::mComment(bool _createToken) {
533 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
533 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
534          _ttype = Comment;
535 <        int _saveIndex;
535 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
536          
537          match("/*");
538          { // ( ... )*
539          for (;;) {
540 <                if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
541 <                        match('*');
540 >                if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
541 >                        match('*' /* charlit */ );
542                  }
543                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
544                          mEndOfLine(false);
545                          if ( inputState->guessing==0 ) {
546 < #line 242 "MDParser.g"
546 > #line 243 "MDParser.g"
547                                  deferredNewline();
548   #line 549 "MDLexer.cpp"
549                          }
# Line 562 | Line 562 | void MDLexer::mComment(bool _createToken) {
562          } // ( ... )*
563          match("*/");
564          if ( inputState->guessing==0 ) {
565 < #line 245 "MDParser.g"
565 > #line 246 "MDParser.g"
566                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
567   #line 568 "MDLexer.cpp"
568          }
# Line 575 | Line 575 | void MDLexer::mEndOfLine(bool _createToken) {
575   }
576  
577   void MDLexer::mEndOfLine(bool _createToken) {
578 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
578 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
579          _ttype = EndOfLine;
580 <        int _saveIndex;
580 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
581          
582          {
583          if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
584                  match("\r\n");
585          }
586          else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
587 <                match('\r');
587 >                match('\r' /* charlit */ );
588          }
589          else if ((LA(1) == 0xa /* '\n' */ )) {
590 <                match('\n');
590 >                match('\n' /* charlit */ );
591          }
592          else {
593                  throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 603 | Line 603 | void MDLexer::mCPPComment(bool _createToken) {
603   }
604  
605   void MDLexer::mCPPComment(bool _createToken) {
606 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
606 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
607          _ttype = CPPComment;
608 <        int _saveIndex;
608 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
609          
610          match("//");
611          { // ( ... )*
# Line 624 | Line 624 | void MDLexer::mCPPComment(bool _createToken) {
624          } // ( ... )*
625          mEndOfLine(false);
626          if ( inputState->guessing==0 ) {
627 < #line 251 "MDParser.g"
627 > #line 252 "MDParser.g"
628                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
629   #line 630 "MDLexer.cpp"
630          }
# Line 637 | Line 637 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
637   }
638  
639   void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
640 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
640 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
641          _ttype = PREPROC_DIRECTIVE;
642 <        int _saveIndex;
642 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
643          
644 <        match('#');
644 >        match('#' /* charlit */ );
645          mLineDirective(false);
646          if ( inputState->guessing==0 ) {
647 < #line 258 "MDParser.g"
647 > #line 259 "MDParser.g"
648                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
649   #line 650 "MDLexer.cpp"
650          }
# Line 657 | Line 657 | void MDLexer::mLineDirective(bool _createToken) {
657   }
658  
659   void MDLexer::mLineDirective(bool _createToken) {
660 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
660 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
661          _ttype = LineDirective;
662 <        int _saveIndex;
662 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
663          ANTLR_USE_NAMESPACE(antlr)RefToken n;
664          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
665          
666          if ( inputState->guessing==0 ) {
667 < #line 264 "MDParser.g"
667 > #line 265 "MDParser.g"
668                  
669                  deferredLineCount = 0;
670                  
# Line 706 | Line 706 | void MDLexer::mLineDirective(bool _createToken) {
706          mDecimal(true);
707          n=_returnToken;
708          if ( inputState->guessing==0 ) {
709 < #line 269 "MDParser.g"
709 > #line 270 "MDParser.g"
710                  setLine(oopse::lexi_cast<int>(n->getText()) - 1);
711   #line 712 "MDLexer.cpp"
712          }
# Line 729 | Line 729 | void MDLexer::mLineDirective(bool _createToken) {
729          sl=_returnToken;
730          }
731          if ( inputState->guessing==0 ) {
732 < #line 271 "MDParser.g"
732 > #line 272 "MDParser.g"
733                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
734   #line 735 "MDLexer.cpp"
735          }
# Line 769 | Line 769 | void MDLexer::mSpace(bool _createToken) {
769   }
770  
771   void MDLexer::mSpace(bool _createToken) {
772 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
772 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
773          _ttype = Space;
774 <        int _saveIndex;
774 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
775          
776          {
777          switch ( LA(1)) {
778          case 0x20 /* ' ' */ :
779          {
780 <                match(' ');
780 >                match(' ' /* charlit */ );
781                  break;
782          }
783          case 0x9 /* '\t' */ :
784          {
785 <                match('\t');
785 >                match('\t' /* charlit */ );
786                  break;
787          }
788          case 0xc /* '\14' */ :
789          {
790 <                match('\14');
790 >                match('\14' /* charlit */ );
791                  break;
792          }
793          default:
# Line 805 | Line 805 | void MDLexer::mDecimal(bool _createToken) {
805   }
806  
807   void MDLexer::mDecimal(bool _createToken) {
808 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
808 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
809          _ttype = Decimal;
810 <        int _saveIndex;
810 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
811          
812          { // ( ... )+
813          int _cnt129=0;
# Line 832 | Line 832 | void MDLexer::mStringLiteral(bool _createToken) {
832   }
833  
834   void MDLexer::mStringLiteral(bool _createToken) {
835 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
835 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
836          _ttype = StringLiteral;
837 <        int _saveIndex;
837 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
838          
839 <        match('"');
839 >        match('\"' /* charlit */ );
840          { // ( ... )*
841          for (;;) {
842                  if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
# Line 845 | Line 845 | void MDLexer::mStringLiteral(bool _createToken) {
845                  else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */  || LA(2) == 0xd /* '\r' */ )) {
846                          {
847                          if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
848 <                                match("\\r\n");
848 >                                match("\\\r\n");
849                          }
850                          else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
851 <                                match("\\r");
851 >                                match("\\\r");
852                          }
853                          else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
854 <                                match("\\n");
854 >                                match("\\\n");
855                          }
856                          else {
857                                  throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
# Line 859 | Line 859 | void MDLexer::mStringLiteral(bool _createToken) {
859                          
860                          }
861                          if ( inputState->guessing==0 ) {
862 < #line 311 "MDParser.g"
862 > #line 312 "MDParser.g"
863                                  deferredNewline();
864   #line 865 "MDLexer.cpp"
865                          }
# Line 876 | Line 876 | void MDLexer::mStringLiteral(bool _createToken) {
876          }
877          _loop109:;
878          } // ( ... )*
879 <        match('"');
879 >        match('\"' /* charlit */ );
880          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
881             _token = makeToken(_ttype);
882             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 886 | Line 886 | void MDLexer::mCharLiteral(bool _createToken) {
886   }
887  
888   void MDLexer::mCharLiteral(bool _createToken) {
889 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
889 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
890          _ttype = CharLiteral;
891 <        int _saveIndex;
891 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
892          
893 <        match('\'');
893 >        match('\'' /* charlit */ );
894          {
895          if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
896                  mEscape(false);
# Line 905 | Line 905 | void MDLexer::mCharLiteral(bool _createToken) {
905          }
906          
907          }
908 <        match('\'');
908 >        match('\'' /* charlit */ );
909          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
910             _token = makeToken(_ttype);
911             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 915 | Line 915 | void MDLexer::mEscape(bool _createToken) {
915   }
916  
917   void MDLexer::mEscape(bool _createToken) {
918 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
918 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
919          _ttype = Escape;
920 <        int _saveIndex;
920 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
921          
922 <        match('\\');
922 >        match('\\' /* charlit */ );
923          {
924          switch ( LA(1)) {
925          case 0x61 /* 'a' */ :
926          {
927 <                match('a');
927 >                match('a' /* charlit */ );
928                  break;
929          }
930          case 0x62 /* 'b' */ :
931          {
932 <                match('b');
932 >                match('b' /* charlit */ );
933                  break;
934          }
935          case 0x66 /* 'f' */ :
936          {
937 <                match('f');
937 >                match('f' /* charlit */ );
938                  break;
939          }
940          case 0x6e /* 'n' */ :
941          {
942 <                match('n');
942 >                match('n' /* charlit */ );
943                  break;
944          }
945          case 0x72 /* 'r' */ :
946          {
947 <                match('r');
947 >                match('r' /* charlit */ );
948                  break;
949          }
950          case 0x74 /* 't' */ :
951          {
952 <                match('t');
952 >                match('t' /* charlit */ );
953                  break;
954          }
955          case 0x76 /* 'v' */ :
956          {
957 <                match('v');
957 >                match('v' /* charlit */ );
958                  break;
959          }
960 <        case 0x22 /* '"' */ :
960 >        case 0x22 /* '\"' */ :
961          {
962 <                match('"');
962 >                match('\"' /* charlit */ );
963                  break;
964          }
965          case 0x27 /* '\'' */ :
966          {
967 <                match('\'');
967 >                match('\'' /* charlit */ );
968                  break;
969          }
970          case 0x5c /* '\\' */ :
971          {
972 <                match('\\');
972 >                match('\\' /* charlit */ );
973                  break;
974          }
975          case 0x3f /* '?' */ :
976          {
977 <                match('?');
977 >                match('?' /* charlit */ );
978                  break;
979          }
980          case 0x30 /* '0' */ :
# Line 1032 | Line 1032 | void MDLexer::mEscape(bool _createToken) {
1032          }
1033          case 0x78 /* 'x' */ :
1034          {
1035 <                match('x');
1035 >                match('x' /* charlit */ );
1036                  { // ( ... )+
1037                  int _cnt120=0;
1038                  for (;;) {
# Line 1070 | Line 1070 | void MDLexer::mDigit(bool _createToken) {
1070   }
1071  
1072   void MDLexer::mDigit(bool _createToken) {
1073 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1073 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1074          _ttype = Digit;
1075 <        int _saveIndex;
1075 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1076          
1077          matchRange('0','9');
1078          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1084 | Line 1084 | void MDLexer::mVocabulary(bool _createToken) {
1084   }
1085  
1086   void MDLexer::mVocabulary(bool _createToken) {
1087 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1087 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1088          _ttype = Vocabulary;
1089 <        int _saveIndex;
1089 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1090          
1091 <        matchRange('\3',static_cast<unsigned char>(255));
1091 >        matchRange('\3',static_cast<unsigned char>('\377'));
1092          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1093             _token = makeToken(_ttype);
1094             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 1098 | Line 1098 | void MDLexer::mID(bool _createToken) {
1098   }
1099  
1100   void MDLexer::mID(bool _createToken) {
1101 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1101 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1102          _ttype = ID;
1103 <        int _saveIndex;
1103 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1104          
1105          {
1106          switch ( LA(1)) {
# Line 1166 | Line 1166 | void MDLexer::mID(bool _createToken) {
1166          }
1167          case 0x5f /* '_' */ :
1168          {
1169 <                match('_');
1169 >                match('_' /* charlit */ );
1170                  break;
1171          }
1172          default:
# Line 1240 | Line 1240 | void MDLexer::mID(bool _createToken) {
1240                  }
1241                  case 0x5f /* '_' */ :
1242                  {
1243 <                        match('_');
1243 >                        match('_' /* charlit */ );
1244                          break;
1245                  }
1246                  case 0x30 /* '0' */ :
# Line 1275 | Line 1275 | void MDLexer::mHEX_DIGIT(bool _createToken) {
1275   }
1276  
1277   void MDLexer::mHEX_DIGIT(bool _createToken) {
1278 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1278 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1279          _ttype = HEX_DIGIT;
1280 <        int _saveIndex;
1280 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1281          
1282          {
1283          switch ( LA(1)) {
# Line 1330 | Line 1330 | void MDLexer::mNUM_INT(bool _createToken) {
1330   }
1331  
1332   void MDLexer::mNUM_INT(bool _createToken) {
1333 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1333 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1334          _ttype = NUM_INT;
1335 <        int _saveIndex;
1335 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1336          ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1337          ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1338          ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1339          ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1340 < #line 404 "MDParser.g"
1340 > #line 405 "MDParser.g"
1341          
1342                          bool isDecimal = false;
1343                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
# Line 1348 | Line 1348 | void MDLexer::mNUM_INT(bool _createToken) {
1348          switch ( LA(1)) {
1349          case 0x2b /* '+' */ :
1350          {
1351 <                match('+');
1351 >                match('+' /* charlit */ );
1352                  break;
1353          }
1354          case 0x2d /* '-' */ :
1355          {
1356 <                match('-');
1356 >                match('-' /* charlit */ );
1357                  break;
1358          }
1359          case 0x2e /* '.' */ :
# Line 1380 | Line 1380 | void MDLexer::mNUM_INT(bool _createToken) {
1380          switch ( LA(1)) {
1381          case 0x2e /* '.' */ :
1382          {
1383 <                match('.');
1383 >                match('.' /* charlit */ );
1384                  if ( inputState->guessing==0 ) {
1385 < #line 411 "MDParser.g"
1385 > #line 412 "MDParser.g"
1386                          _ttype = DOT;
1387   #line 1388 "MDLexer.cpp"
1388                  }
# Line 1415 | Line 1415 | void MDLexer::mNUM_INT(bool _createToken) {
1415                                  mFLOAT_SUFFIX(true);
1416                                  f1=_returnToken;
1417                                  if ( inputState->guessing==0 ) {
1418 < #line 412 "MDParser.g"
1418 > #line 413 "MDParser.g"
1419                                          t=f1;
1420   #line 1421 "MDLexer.cpp"
1421                                  }
# Line 1425 | Line 1425 | void MDLexer::mNUM_INT(bool _createToken) {
1425                          
1426                          }
1427                          if ( inputState->guessing==0 ) {
1428 < #line 413 "MDParser.g"
1428 > #line 414 "MDParser.g"
1429                                  
1430                                                                          if ( t &&
1431                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1460 | Line 1460 | void MDLexer::mNUM_INT(bool _createToken) {
1460                  switch ( LA(1)) {
1461                  case 0x30 /* '0' */ :
1462                  {
1463 <                        match('0');
1463 >                        match('0' /* charlit */ );
1464                          if ( inputState->guessing==0 ) {
1465 < #line 425 "MDParser.g"
1465 > #line 426 "MDParser.g"
1466                                  isDecimal = true;
1467   #line 1468 "MDLexer.cpp"
1468                          }
# Line 1472 | Line 1472 | void MDLexer::mNUM_INT(bool _createToken) {
1472                                  switch ( LA(1)) {
1473                                  case 0x78 /* 'x' */ :
1474                                  {
1475 <                                        match('x');
1475 >                                        match('x' /* charlit */ );
1476                                          break;
1477                                  }
1478                                  case 0x58 /* 'X' */ :
1479                                  {
1480 <                                        match('X');
1480 >                                        match('X' /* charlit */ );
1481                                          break;
1482                                  }
1483                                  default:
# Line 1528 | Line 1528 | void MDLexer::mNUM_INT(bool _createToken) {
1528                                                          mEXPONENT(false);
1529                                                  }
1530                                                  else if ((LA(1) == 0x2e /* '.' */ )) {
1531 <                                                        match('.');
1531 >                                                        match('.' /* charlit */ );
1532                                                  }
1533                                                  else if ((_tokenSet_8.member(LA(1))) && (true)) {
1534                                                          mFLOAT_SUFFIX(false);
# Line 1610 | Line 1610 | void MDLexer::mNUM_INT(bool _createToken) {
1610                          _loop156:;
1611                          } // ( ... )*
1612                          if ( inputState->guessing==0 ) {
1613 < #line 442 "MDParser.g"
1613 > #line 443 "MDParser.g"
1614                                  isDecimal=true;
1615   #line 1616 "MDLexer.cpp"
1616                          }
# Line 1628 | Line 1628 | void MDLexer::mNUM_INT(bool _createToken) {
1628                          switch ( LA(1)) {
1629                          case 0x6c /* 'l' */ :
1630                          {
1631 <                                match('l');
1631 >                                match('l' /* charlit */ );
1632                                  break;
1633                          }
1634                          case 0x4c /* 'L' */ :
1635                          {
1636 <                                match('L');
1636 >                                match('L' /* charlit */ );
1637                                  break;
1638                          }
1639                          default:
# Line 1643 | Line 1643 | void MDLexer::mNUM_INT(bool _createToken) {
1643                          }
1644                          }
1645                          if ( inputState->guessing==0 ) {
1646 < #line 444 "MDParser.g"
1646 > #line 445 "MDParser.g"
1647                                  _ttype = NUM_LONG;
1648   #line 1649 "MDLexer.cpp"
1649                          }
# Line 1657 | Line 1657 | void MDLexer::mNUM_INT(bool _createToken) {
1657                                          mFLOAT_SUFFIX(true);
1658                                          f3=_returnToken;
1659                                          if ( inputState->guessing==0 ) {
1660 < #line 449 "MDParser.g"
1660 > #line 450 "MDParser.g"
1661                                                  t=f3;
1662   #line 1663 "MDLexer.cpp"
1663                                          }
# Line 1668 | Line 1668 | void MDLexer::mNUM_INT(bool _createToken) {
1668                                  }
1669                          }
1670                          else if ((LA(1) == 0x2e /* '.' */ )) {
1671 <                                match('.');
1671 >                                match('.' /* charlit */ );
1672                                  { // ( ... )*
1673                                  for (;;) {
1674                                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
# Line 1694 | Line 1694 | void MDLexer::mNUM_INT(bool _createToken) {
1694                                          mFLOAT_SUFFIX(true);
1695                                          f2=_returnToken;
1696                                          if ( inputState->guessing==0 ) {
1697 < #line 448 "MDParser.g"
1697 > #line 449 "MDParser.g"
1698                                                  t=f2;
1699   #line 1700 "MDLexer.cpp"
1700                                          }
# Line 1708 | Line 1708 | void MDLexer::mNUM_INT(bool _createToken) {
1708                                  mFLOAT_SUFFIX(true);
1709                                  f4=_returnToken;
1710                                  if ( inputState->guessing==0 ) {
1711 < #line 450 "MDParser.g"
1711 > #line 451 "MDParser.g"
1712                                          t=f4;
1713   #line 1714 "MDLexer.cpp"
1714                                  }
# Line 1719 | Line 1719 | void MDLexer::mNUM_INT(bool _createToken) {
1719                          
1720                          }
1721                          if ( inputState->guessing==0 ) {
1722 < #line 452 "MDParser.g"
1722 > #line 453 "MDParser.g"
1723                                  
1724                                                                          if ( t &&
1725                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1754 | Line 1754 | void MDLexer::mEXPONENT(bool _createToken) {
1754   }
1755  
1756   void MDLexer::mEXPONENT(bool _createToken) {
1757 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1757 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1758          _ttype = EXPONENT;
1759 <        int _saveIndex;
1759 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1760          
1761          {
1762          switch ( LA(1)) {
1763          case 0x65 /* 'e' */ :
1764          {
1765 <                match('e');
1765 >                match('e' /* charlit */ );
1766                  break;
1767          }
1768          case 0x45 /* 'E' */ :
1769          {
1770 <                match('E');
1770 >                match('E' /* charlit */ );
1771                  break;
1772          }
1773          case 0x64 /* 'd' */ :
1774          {
1775 <                match('d');
1775 >                match('d' /* charlit */ );
1776                  break;
1777          }
1778          case 0x44 /* 'D' */ :
1779          {
1780 <                match('D');
1780 >                match('D' /* charlit */ );
1781                  break;
1782          }
1783          default:
# Line 1790 | Line 1790 | void MDLexer::mEXPONENT(bool _createToken) {
1790          switch ( LA(1)) {
1791          case 0x2b /* '+' */ :
1792          {
1793 <                match('+');
1793 >                match('+' /* charlit */ );
1794                  break;
1795          }
1796          case 0x2d /* '-' */ :
1797          {
1798 <                match('-');
1798 >                match('-' /* charlit */ );
1799                  break;
1800          }
1801          case 0x30 /* '0' */ :
# Line 1840 | Line 1840 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1840   }
1841  
1842   void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1843 <        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1843 >        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1844          _ttype = FLOAT_SUFFIX;
1845 <        int _saveIndex;
1845 >        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1846          
1847          switch ( LA(1)) {
1848          case 0x66 /* 'f' */ :
1849          {
1850 <                match('f');
1850 >                match('f' /* charlit */ );
1851                  break;
1852          }
1853          case 0x46 /* 'F' */ :
1854          {
1855 <                match('F');
1855 >                match('F' /* charlit */ );
1856                  break;
1857          }
1858          case 0x64 /* 'd' */ :
1859          {
1860 <                match('d');
1860 >                match('d' /* charlit */ );
1861                  break;
1862          }
1863          case 0x44 /* 'D' */ :
1864          {
1865 <                match('D');
1865 >                match('D' /* charlit */ );
1866                  break;
1867          }
1868          default:
# Line 1879 | Line 1879 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1879   }
1880  
1881  
1882 < const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1883 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1884 < // 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1885 < // \' ( ) + , - . / 0 1 2 3 4
1882 > const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1883 > // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1884 > // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1885 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4
1886   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1887 < const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1888 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1889 < // 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1890 < // \' ( ) * + , - . / 0 1 2 3 4
1887 > const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1888 > // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1889 > // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1890 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4
1891   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1892   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1893 < // " \' 0 1 2 3 4
1893 > // \" \' 0 1 2 3 4
1894   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1895 < const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1896 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1897 < // 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! # $ % & \'
1898 < // ( ) * + , - . / 0 1 2 3 4
1895 > const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1896 > // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1897 > // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1898 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4
1899   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1900   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1901   // \' 0 1 2 3 4
1902   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1903 < const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967288UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1904 < // 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
1905 < // 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " #
1906 < // $ % & ( ) * + , - . / 0 1 2 3 4
1903 > const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1904 > // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1905 > // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1906 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4
1907   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1908   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1909   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);

Diff Legend

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