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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC

# Line 256 | Line 256 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
256                  case OCTALINT:
257                  case DECIMALINT:
258                  case HEXADECIMALINT:
259 –                case MINUS:
259                  case FLOATONE:
260                  case FLOATTWO:
261 +                case MINUS:
262                  {
263                          signedIntOrFloat(_t,id);
264                          _t = _retTree;
# Line 477 | Line 477 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
477   }
478  
479   double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
480 < #line 266 "MDTreeParser.g"
480 > #line 264 "MDTreeParser.g"
481          double dval;
482   #line 483 "MDTreeParser.cpp"
483          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
# Line 493 | Line 493 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
493                          d1 = _t;
494                          match(_t,FLOATONE);
495                          _t = _t->getNextSibling();
496 < #line 267 "MDTreeParser.g"
496 > #line 265 "MDTreeParser.g"
497                          dval = lexi_cast<double>(d1->getText());
498   #line 499 "MDTreeParser.cpp"
499                          break;
# Line 503 | Line 503 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
503                          d2 = _t;
504                          match(_t,FLOATTWO);
505                          _t = _t->getNextSibling();
506 < #line 268 "MDTreeParser.g"
506 > #line 266 "MDTreeParser.g"
507                          dval = lexi_cast<double>(d2->getText());
508   #line 509 "MDTreeParser.cpp"
509                          break;
# Line 1027 | Line 1027 | vector<double>  MDTreeParser::signedNumberTuple(ANTLR_
1027                  for (;;) {
1028                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1029                                  _t = ASTNULL;
1030 <                        if ((_tokenSet_2.member(_t->getType()))) {
1030 >                        if (((_t->getType() >= OCTALINT && _t->getType() <= FLOATTWO))) {
1031                                  dval=signedNumber(_t);
1032                                  _t = _retTree;
1033   #line 238 "MDTreeParser.g"
# Line 1354 | Line 1354 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1354          double dval;
1355   #line 1356 "MDTreeParser.cpp"
1356          ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357 –        ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
1358 –        ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
1357          ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1358          ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1359          
# Line 1363 | Line 1361 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1361                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1362                          _t = ASTNULL;
1363                  switch ( _t->getType()) {
1364 <                case MINUS:
1364 >                case OCTALINT:
1365 >                case DECIMALINT:
1366 >                case HEXADECIMALINT:
1367                  {
1368 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1369 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1370 <                        match(_t,MINUS);
1371 <                        _t = _t->getFirstChild();
1372 <                        {
1373 <                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1374 <                                _t = ASTNULL;
1375 <                        switch ( _t->getType()) {
1376 <                        case OCTALINT:
1377 <                        case DECIMALINT:
1378 <                        case HEXADECIMALINT:
1379 <                        {
1380 <                                icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1381 <                                intConst(_t);
1382 <                                _t = _retTree;
1383 < #line 257 "MDTreeParser.g"
1384 <                                dval = lexi_cast<double>(icMinus->getText()); dval = -dval;
1385 < #line 1386 "MDTreeParser.cpp"
1386 <                                break;
1387 <                        }
1388 <                        case FLOATONE:
1389 <                        case FLOATTWO:
1390 <                        {
1391 <                                fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1392 <                                floatConst(_t);
1393 <                                _t = _retTree;
1394 <                                break;
1395 <                        }
1396 <                        default:
1397 <                        {
1398 <                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1399 <                        }
1400 <                        }
1401 <                        }
1368 >                        ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1369 >                        intConst(_t);
1370 >                        _t = _retTree;
1371   #line 258 "MDTreeParser.g"
1372 <                        dval = lexi_cast<double>(fcMinus->getText());dval = -dval;
1373 < #line 1405 "MDTreeParser.cpp"
1405 <                        _t = __t75;
1406 <                        _t = _t->getNextSibling();
1372 >                        dval = lexi_cast<double>(ic->getText());
1373 > #line 1374 "MDTreeParser.cpp"
1374                          break;
1375                  }
1409 –                case OCTALINT:
1410 –                case DECIMALINT:
1411 –                case HEXADECIMALINT:
1376                  case FLOATONE:
1377                  case FLOATTWO:
1378                  {
1379 <                        {
1380 <                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1381 <                                _t = ASTNULL;
1382 <                        switch ( _t->getType()) {
1383 <                        case OCTALINT:
1384 <                        case DECIMALINT:
1421 <                        case HEXADECIMALINT:
1422 <                        {
1423 <                                ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1424 <                                intConst(_t);
1425 <                                _t = _retTree;
1426 < #line 260 "MDTreeParser.g"
1427 <                                dval = lexi_cast<double>(ic->getText());
1428 < #line 1429 "MDTreeParser.cpp"
1429 <                                break;
1430 <                        }
1431 <                        case FLOATONE:
1432 <                        case FLOATTWO:
1433 <                        {
1434 <                                fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1435 <                                floatConst(_t);
1436 <                                _t = _retTree;
1437 < #line 261 "MDTreeParser.g"
1438 <                                dval = lexi_cast<double>(fc->getText());
1439 < #line 1440 "MDTreeParser.cpp"
1440 <                                break;
1441 <                        }
1442 <                        default:
1443 <                        {
1444 <                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1445 <                        }
1446 <                        }
1447 <                        }
1379 >                        fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380 >                        floatConst(_t);
1381 >                        _t = _retTree;
1382 > #line 259 "MDTreeParser.g"
1383 >                        dval = lexi_cast<double>(fc->getText());
1384 > #line 1385 "MDTreeParser.cpp"
1385                          break;
1386                  }
1387                  default:
# Line 1498 | Line 1435 | const char* MDTreeParser::tokenNames[] = {
1435          "OCTALINT",
1436          "DECIMALINT",
1437          "HEXADECIMALINT",
1501 –        "PLUS",
1502 –        "MINUS",
1438          "FLOATONE",
1439          "FLOATTWO",
1440          "DOT",
# Line 1522 | Line 1457 | const char* MDTreeParser::tokenNames[] = {
1457          "Exponent",
1458          "Vocabulary",
1459          "Number",
1460 +        "MINUS",
1461          0
1462   };
1463  
# Line 1532 | Line 1468 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_
1468   // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1469   // ASSIGNEQUAL
1470   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1535 – const unsigned long MDTreeParser::_tokenSet_2_data_[] = { 3758096384UL, 14UL, 0UL, 0UL };
1536 – // OCTALINT DECIMALINT HEXADECIMALINT MINUS FLOATONE FLOATTWO
1537 – const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_2(_tokenSet_2_data_,4);
1471  
1472  

Diff Legend

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