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 809 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC

# Line 120 | Line 120 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
120                                  theRetToken=_returnToken;
121                                  break;
122                          }
123 –                        case 0x2b /* '+' */ :
124 –                        {
125 –                                mPLUS(true);
126 –                                theRetToken=_returnToken;
127 –                                break;
128 –                        }
129 –                        case 0x2d /* '-' */ :
130 –                        {
131 –                                mMINUS(true);
132 –                                theRetToken=_returnToken;
133 –                                break;
134 –                        }
123                          case 0x9 /* '\t' */ :
124                          case 0xa /* '\n' */ :
125                          case 0xc /* '\14' */ :
# Line 161 | Line 149 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
149                                  theRetToken=_returnToken;
150                                  break;
151                          }
152 +                        case 0x2b /* '+' */ :
153 +                        case 0x2d /* '-' */ :
154                          case 0x2e /* '.' */ :
155                          case 0x30 /* '0' */ :
156                          case 0x31 /* '1' */ :
# Line 419 | Line 409 | void MDLexer::mRCURLY(bool _createToken) {
409          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
410          
411          match('}' /* charlit */ );
422 –        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
423 –           _token = makeToken(_ttype);
424 –           _token->setText(text.substr(_begin, text.length()-_begin));
425 –        }
426 –        _returnToken = _token;
427 –        _saveIndex=0;
428 – }
429 –
430 – void MDLexer::mPLUS(bool _createToken) {
431 –        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
432 –        _ttype = PLUS;
433 –        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
434 –        
435 –        match('+' /* charlit */ );
412          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
413             _token = makeToken(_ttype);
414             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 441 | Line 417 | void MDLexer::mPLUS(bool _createToken) {
417          _saveIndex=0;
418   }
419  
444 – void MDLexer::mMINUS(bool _createToken) {
445 –        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
446 –        _ttype = MINUS;
447 –        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
448 –        
449 –        match('-' /* charlit */ );
450 –        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
451 –           _token = makeToken(_ttype);
452 –           _token->setText(text.substr(_begin, text.length()-_begin));
453 –        }
454 –        _returnToken = _token;
455 –        _saveIndex=0;
456 – }
457 –
420   void MDLexer::mWhitespace(bool _createToken) {
421          int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
422          _ttype = Whitespace;
# Line 511 | Line 473 | void MDLexer::mWhitespace(bool _createToken) {
473                  
474                  }
475                  if ( inputState->guessing==0 ) {
476 < #line 262 "MDParser.g"
476 > #line 259 "MDParser.g"
477                          newline();
478 < #line 517 "MDLexer.cpp"
478 > #line 479 "MDLexer.cpp"
479                  }
480                  break;
481          }
# Line 539 | Line 501 | void MDLexer::mWhitespace(bool _createToken) {
501                  
502                  }
503                  if ( inputState->guessing==0 ) {
504 < #line 267 "MDParser.g"
504 > #line 264 "MDParser.g"
505                          printf("CPP_parser.g continuation line detected\n");
506                          deferredNewline();
507 < #line 546 "MDLexer.cpp"
507 > #line 508 "MDLexer.cpp"
508                  }
509                  break;
510          }
# Line 553 | Line 515 | void MDLexer::mWhitespace(bool _createToken) {
515          }
516          }
517          if ( inputState->guessing==0 ) {
518 < #line 270 "MDParser.g"
518 > #line 267 "MDParser.g"
519                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
520 < #line 559 "MDLexer.cpp"
520 > #line 521 "MDLexer.cpp"
521          }
522          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
523             _token = makeToken(_ttype);
# Line 579 | Line 541 | void MDLexer::mComment(bool _createToken) {
541                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
542                          mEndOfLine(false);
543                          if ( inputState->guessing==0 ) {
544 < #line 277 "MDParser.g"
544 > #line 274 "MDParser.g"
545                                  deferredNewline();
546 < #line 585 "MDLexer.cpp"
546 > #line 547 "MDLexer.cpp"
547                          }
548                  }
549                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 590 | Line 552 | void MDLexer::mComment(bool _createToken) {
552                          }
553                  }
554                  else {
555 <                        goto _loop81;
555 >                        goto _loop78;
556                  }
557                  
558          }
559 <        _loop81:;
559 >        _loop78:;
560          } // ( ... )*
561          match("*/");
562          if ( inputState->guessing==0 ) {
563 < #line 280 "MDParser.g"
563 > #line 277 "MDParser.g"
564                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
565 < #line 604 "MDLexer.cpp"
565 > #line 566 "MDLexer.cpp"
566          }
567          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
568             _token = makeToken(_ttype);
# Line 652 | Line 614 | void MDLexer::mCPPComment(bool _createToken) {
614                          }
615                  }
616                  else {
617 <                        goto _loop85;
617 >                        goto _loop82;
618                  }
619                  
620          }
621 <        _loop85:;
621 >        _loop82:;
622          } // ( ... )*
623          mEndOfLine(false);
624          if ( inputState->guessing==0 ) {
625 < #line 286 "MDParser.g"
625 > #line 283 "MDParser.g"
626                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
627 < #line 666 "MDLexer.cpp"
627 > #line 628 "MDLexer.cpp"
628          }
629          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
630             _token = makeToken(_ttype);
# Line 680 | Line 642 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
642          match('#' /* charlit */ );
643          mLineDirective(false);
644          if ( inputState->guessing==0 ) {
645 < #line 293 "MDParser.g"
645 > #line 290 "MDParser.g"
646                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
647 < #line 686 "MDLexer.cpp"
647 > #line 648 "MDLexer.cpp"
648          }
649          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
650             _token = makeToken(_ttype);
# Line 700 | Line 662 | void MDLexer::mLineDirective(bool _createToken) {
662          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
663          
664          if ( inputState->guessing==0 ) {
665 < #line 299 "MDParser.g"
665 > #line 296 "MDParser.g"
666                  
667                  deferredLineCount = 0;
668                  
669 < #line 708 "MDLexer.cpp"
669 > #line 670 "MDLexer.cpp"
670          }
671          {
672          switch ( LA(1)) {
# Line 726 | Line 688 | void MDLexer::mLineDirective(bool _createToken) {
688          }
689          }
690          { // ( ... )+
691 <        int _cnt90=0;
691 >        int _cnt87=0;
692          for (;;) {
693                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
694                          mSpace(false);
695                  }
696                  else {
697 <                        if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
697 >                        if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
698                  }
699                  
700 <                _cnt90++;
700 >                _cnt87++;
701          }
702 <        _loop90:;
702 >        _loop87:;
703          }  // ( ... )+
704          mDecimal(true);
705          n=_returnToken;
706          if ( inputState->guessing==0 ) {
707 < #line 304 "MDParser.g"
707 > #line 301 "MDParser.g"
708                  setLine(oopse::lexi_cast<int>(n->getText()) - 1);
709 < #line 748 "MDLexer.cpp"
709 > #line 710 "MDLexer.cpp"
710          }
711          { // ( ... )+
712 <        int _cnt92=0;
712 >        int _cnt89=0;
713          for (;;) {
714                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
715                          mSpace(false);
716                  }
717                  else {
718 <                        if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
718 >                        if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
719                  }
720                  
721 <                _cnt92++;
721 >                _cnt89++;
722          }
723 <        _loop92:;
723 >        _loop89:;
724          }  // ( ... )+
725          {
726          mStringLiteral(true);
727          sl=_returnToken;
728          }
729          if ( inputState->guessing==0 ) {
730 < #line 306 "MDParser.g"
730 > #line 303 "MDParser.g"
731                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
732 < #line 771 "MDLexer.cpp"
732 > #line 733 "MDLexer.cpp"
733          }
734          { // ( ... )*
735          for (;;) {
736                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
737                          { // ( ... )+
738 <                        int _cnt96=0;
738 >                        int _cnt93=0;
739                          for (;;) {
740                                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
741                                          mSpace(false);
742                                  }
743                                  else {
744 <                                        if ( _cnt96>=1 ) { goto _loop96; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
744 >                                        if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
745                                  }
746                                  
747 <                                _cnt96++;
747 >                                _cnt93++;
748                          }
749 <                        _loop96:;
749 >                        _loop93:;
750                          }  // ( ... )+
751                          mDecimal(false);
752                  }
753                  else {
754 <                        goto _loop97;
754 >                        goto _loop94;
755                  }
756                  
757          }
758 <        _loop97:;
758 >        _loop94:;
759          } // ( ... )*
760          mEndOfLine(false);
761          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 846 | Line 808 | void MDLexer::mDecimal(bool _createToken) {
808          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
809          
810          { // ( ... )+
811 <        int _cnt122=0;
811 >        int _cnt119=0;
812          for (;;) {
813                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
814                          matchRange('0','9');
815                  }
816                  else {
817 <                        if ( _cnt122>=1 ) { goto _loop122; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
817 >                        if ( _cnt119>=1 ) { goto _loop119; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
818                  }
819                  
820 <                _cnt122++;
820 >                _cnt119++;
821          }
822 <        _loop122:;
822 >        _loop119:;
823          }  // ( ... )+
824          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
825             _token = makeToken(_ttype);
# Line 895 | Line 857 | void MDLexer::mStringLiteral(bool _createToken) {
857                          
858                          }
859                          if ( inputState->guessing==0 ) {
860 < #line 346 "MDParser.g"
860 > #line 343 "MDParser.g"
861                                  deferredNewline();
862 < #line 901 "MDLexer.cpp"
862 > #line 863 "MDLexer.cpp"
863                          }
864                  }
865                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 906 | Line 868 | void MDLexer::mStringLiteral(bool _createToken) {
868                          }
869                  }
870                  else {
871 <                        goto _loop107;
871 >                        goto _loop104;
872                  }
873                  
874          }
875 <        _loop107:;
875 >        _loop104:;
876          } // ( ... )*
877          match('\"' /* charlit */ );
878          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1070 | Line 1032 | void MDLexer::mEscape(bool _createToken) {
1032          {
1033                  match('x' /* charlit */ );
1034                  { // ( ... )+
1035 <                int _cnt118=0;
1035 >                int _cnt115=0;
1036                  for (;;) {
1037                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1038                                  mDigit(false);
# Line 1082 | Line 1044 | void MDLexer::mEscape(bool _createToken) {
1044                                  matchRange('A','F');
1045                          }
1046                          else {
1047 <                                if ( _cnt118>=1 ) { goto _loop118; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1047 >                                if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1048                          }
1049                          
1050 <                        _cnt118++;
1050 >                        _cnt115++;
1051                  }
1052 <                _loop118:;
1052 >                _loop115:;
1053                  }  // ( ... )+
1054                  break;
1055          }
# Line 1271 | Line 1233 | void MDLexer::mExponent(bool _createToken) {
1233          }
1234          }
1235          { // ( ... )+
1236 <        int _cnt130=0;
1236 >        int _cnt127=0;
1237          for (;;) {
1238                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1239                          mDigit(false);
1240                  }
1241                  else {
1242 <                        if ( _cnt130>=1 ) { goto _loop130; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1242 >                        if ( _cnt127>=1 ) { goto _loop127; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1243                  }
1244                  
1245 <                _cnt130++;
1245 >                _cnt127++;
1246          }
1247 <        _loop130:;
1247 >        _loop127:;
1248          }  // ( ... )+
1249          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1250             _token = makeToken(_ttype);
# Line 1311 | Line 1273 | void MDLexer::mNumber(bool _createToken) {
1273          _ttype = Number;
1274          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1275          
1276 <        bool synPredMatched137 = false;
1276 >        {
1277 >        switch ( LA(1)) {
1278 >        case 0x2b /* '+' */ :
1279 >        {
1280 >                match('+' /* charlit */ );
1281 >                break;
1282 >        }
1283 >        case 0x2d /* '-' */ :
1284 >        {
1285 >                match('-' /* charlit */ );
1286 >                break;
1287 >        }
1288 >        case 0x2e /* '.' */ :
1289 >        case 0x30 /* '0' */ :
1290 >        case 0x31 /* '1' */ :
1291 >        case 0x32 /* '2' */ :
1292 >        case 0x33 /* '3' */ :
1293 >        case 0x34 /* '4' */ :
1294 >        case 0x35 /* '5' */ :
1295 >        case 0x36 /* '6' */ :
1296 >        case 0x37 /* '7' */ :
1297 >        case 0x38 /* '8' */ :
1298 >        case 0x39 /* '9' */ :
1299 >        {
1300 >                break;
1301 >        }
1302 >        default:
1303 >        {
1304 >                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1305 >        }
1306 >        }
1307 >        }
1308 >        {
1309 >        bool synPredMatched136 = false;
1310          if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_6.member(LA(2))) && (true))) {
1311 <                int _m137 = mark();
1312 <                synPredMatched137 = true;
1311 >                int _m136 = mark();
1312 >                synPredMatched136 = true;
1313                  inputState->guessing++;
1314                  try {
1315                          {
1316                          { // ( ... )+
1317 <                        int _cnt135=0;
1317 >                        int _cnt134=0;
1318                          for (;;) {
1319                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1320                                          mDigit(false);
1321                                  }
1322                                  else {
1323 <                                        if ( _cnt135>=1 ) { goto _loop135; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1323 >                                        if ( _cnt134>=1 ) { goto _loop134; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1324                                  }
1325                                  
1326 <                                _cnt135++;
1326 >                                _cnt134++;
1327                          }
1328 <                        _loop135:;
1328 >                        _loop134:;
1329                          }  // ( ... )+
1330                          {
1331                          switch ( LA(1)) {
# Line 1368 | Line 1363 | void MDLexer::mNumber(bool _createToken) {
1363                          }
1364                  }
1365                  catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1366 <                        synPredMatched137 = false;
1366 >                        synPredMatched136 = false;
1367                  }
1368 <                rewind(_m137);
1368 >                rewind(_m136);
1369                  inputState->guessing--;
1370          }
1371 <        if ( synPredMatched137 ) {
1371 >        if ( synPredMatched136 ) {
1372                  { // ( ... )+
1373 <                int _cnt139=0;
1373 >                int _cnt138=0;
1374                  for (;;) {
1375                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1376                                  mDigit(false);
1377                          }
1378                          else {
1379 <                                if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1379 >                                if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1380                          }
1381                          
1382 <                        _cnt139++;
1382 >                        _cnt138++;
1383                  }
1384 <                _loop139:;
1384 >                _loop138:;
1385                  }  // ( ... )+
1386                  {
1387                  switch ( LA(1)) {
# Line 1399 | Line 1394 | void MDLexer::mNumber(bool _createToken) {
1394                                          mDigit(false);
1395                                  }
1396                                  else {
1397 <                                        goto _loop142;
1397 >                                        goto _loop141;
1398                                  }
1399                                  
1400                          }
1401 <                        _loop142:;
1401 >                        _loop141:;
1402                          } // ( ... )*
1403                          {
1404                          if ((_tokenSet_7.member(LA(1)))) {
# Line 1414 | Line 1409 | void MDLexer::mNumber(bool _createToken) {
1409                          
1410                          }
1411                          if ( inputState->guessing==0 ) {
1412 < #line 451 "MDParser.g"
1412 > #line 450 "MDParser.g"
1413                                  _ttype = FLOATONE;
1414 < #line 1420 "MDLexer.cpp"
1414 > #line 1415 "MDLexer.cpp"
1415                          }
1416                          break;
1417                  }
# Line 1427 | Line 1422 | void MDLexer::mNumber(bool _createToken) {
1422                  {
1423                          mExponent(false);
1424                          if ( inputState->guessing==0 ) {
1425 < #line 452 "MDParser.g"
1425 > #line 451 "MDParser.g"
1426                                  _ttype = FLOATTWO;
1427 < #line 1433 "MDLexer.cpp"
1427 > #line 1428 "MDLexer.cpp"
1428                          }
1429                          break;
1430                  }
# Line 1480 | Line 1475 | void MDLexer::mNumber(bool _createToken) {
1475                  }
1476                  }
1477                  { // ( ... )+
1478 <                int _cnt160=0;
1478 >                int _cnt159=0;
1479                  for (;;) {
1480                          switch ( LA(1)) {
1481                          case 0x61 /* 'a' */ :
# Line 1519 | Line 1514 | void MDLexer::mNumber(bool _createToken) {
1514                          }
1515                          default:
1516                          {
1517 <                                if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1517 >                                if ( _cnt159>=1 ) { goto _loop159; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1518                          }
1519                          }
1520 <                        _cnt160++;
1520 >                        _cnt159++;
1521                  }
1522 <                _loop160:;
1522 >                _loop159:;
1523                  }  // ( ... )+
1524                  { // ( ... )*
1525                  for (;;) {
# Line 1543 | Line 1538 | void MDLexer::mNumber(bool _createToken) {
1538                          }
1539                          default:
1540                          {
1541 <                                goto _loop162;
1541 >                                goto _loop161;
1542                          }
1543                          }
1544                  }
1545 <                _loop162:;
1545 >                _loop161:;
1546                  } // ( ... )*
1547                  if ( inputState->guessing==0 ) {
1548 < #line 480 "MDParser.g"
1548 > #line 479 "MDParser.g"
1549                          _ttype = HEXADECIMALINT;
1550 < #line 1556 "MDLexer.cpp"
1550 > #line 1551 "MDLexer.cpp"
1551                  }
1552          }
1553          else if ((LA(1) == 0x2e /* '.' */ )) {
1554                  match('.' /* charlit */ );
1555                  if ( inputState->guessing==0 ) {
1556 < #line 458 "MDParser.g"
1556 > #line 457 "MDParser.g"
1557                          _ttype = DOT;
1558 < #line 1564 "MDLexer.cpp"
1558 > #line 1559 "MDLexer.cpp"
1559                  }
1560                  {
1561                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1562                          { // ( ... )+
1563 <                        int _cnt147=0;
1563 >                        int _cnt146=0;
1564                          for (;;) {
1565                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1566                                          mDigit(false);
1567                                  }
1568                                  else {
1569 <                                        if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1569 >                                        if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1570                                  }
1571                                  
1572 <                                _cnt147++;
1572 >                                _cnt146++;
1573                          }
1574 <                        _loop147:;
1574 >                        _loop146:;
1575                          }  // ( ... )+
1576                          {
1577                          if ((_tokenSet_7.member(LA(1)))) {
# Line 1587 | Line 1582 | void MDLexer::mNumber(bool _createToken) {
1582                          
1583                          }
1584                          if ( inputState->guessing==0 ) {
1585 < #line 459 "MDParser.g"
1585 > #line 458 "MDParser.g"
1586                                  _ttype = FLOATONE;
1587 < #line 1593 "MDLexer.cpp"
1587 > #line 1588 "MDLexer.cpp"
1588                          }
1589                          {
1590                          switch ( LA(1)) {
# Line 1624 | Line 1619 | void MDLexer::mNumber(bool _createToken) {
1619                                  matchRange('0','7');
1620                          }
1621                          else {
1622 <                                goto _loop151;
1622 >                                goto _loop150;
1623                          }
1624                          
1625                  }
1626 <                _loop151:;
1626 >                _loop150:;
1627                  } // ( ... )*
1628                  { // ( ... )*
1629                  for (;;) {
# Line 1647 | Line 1642 | void MDLexer::mNumber(bool _createToken) {
1642                          }
1643                          default:
1644                          {
1645 <                                goto _loop153;
1645 >                                goto _loop152;
1646                          }
1647                          }
1648                  }
1649 <                _loop153:;
1649 >                _loop152:;
1650                  } // ( ... )*
1651                  if ( inputState->guessing==0 ) {
1652 < #line 469 "MDParser.g"
1652 > #line 468 "MDParser.g"
1653                          _ttype = OCTALINT;
1654 < #line 1660 "MDLexer.cpp"
1654 > #line 1655 "MDLexer.cpp"
1655                  }
1656          }
1657          else if (((LA(1) >= 0x31 /* '1' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true)) {
# Line 1667 | Line 1662 | void MDLexer::mNumber(bool _createToken) {
1662                                  mDigit(false);
1663                          }
1664                          else {
1665 <                                goto _loop155;
1665 >                                goto _loop154;
1666                          }
1667                          
1668                  }
1669 <                _loop155:;
1669 >                _loop154:;
1670                  } // ( ... )*
1671                  { // ( ... )*
1672                  for (;;) {
# Line 1690 | Line 1685 | void MDLexer::mNumber(bool _createToken) {
1685                          }
1686                          default:
1687                          {
1688 <                                goto _loop157;
1688 >                                goto _loop156;
1689                          }
1690                          }
1691                  }
1692 <                _loop157:;
1692 >                _loop156:;
1693                  } // ( ... )*
1694                  if ( inputState->guessing==0 ) {
1695 < #line 474 "MDParser.g"
1695 > #line 473 "MDParser.g"
1696                          _ttype = DECIMALINT;
1697 < #line 1703 "MDLexer.cpp"
1697 > #line 1698 "MDLexer.cpp"
1698                  }
1699          }
1700          else {
1701                  throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1702          }
1703          
1704 +        }
1705          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1706             _token = makeToken(_ttype);
1707             _token->setText(text.substr(_begin, text.length()-_begin));
# Line 1876 | Line 1872 | void MDLexer::mID(bool _createToken) {
1872                  }
1873                  default:
1874                  {
1875 <                        goto _loop166;
1875 >                        goto _loop165;
1876                  }
1877                  }
1878          }
1879 <        _loop166:;
1879 >        _loop165:;
1880          } // ( ... )*
1881          _ttype = testLiteralsTable(_ttype);
1882          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1895 | Line 1891 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1891   const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1892   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1893   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1894 < // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7
1894 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1895   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1896   const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 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 6 7
1899 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1900   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1901   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1902 < // \" \' 0 1 2 3 4 5 6 7
1902 > // \" \' 0 1 2 3 4 5
1903   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1904   const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1906   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1907 < // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7
1907 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1908   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1909   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1910 < // \' 0 1 2 3 4 5 6 7
1910 > // \' 0 1 2 3 4 5
1911   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1912   const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1913   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1914   // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1915 < // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7
1915 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1916   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1917   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 67059712UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918 < // . 0 1 2 3 4 5 6 7
1918 > // . 0 1 2 3 4 5
1919   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1920   const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);

Diff Legend

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