void IOSCfgParser::xoperator() {
try { // for error handling
switch ( LA(1)) {
case P_EQ:
case P_GT:
case P_LT:
case P_NEQ:
{
single_port_op();
break;
}
case P_RANGE:
{
port_range();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_11);
} else {
throw;
}
}
}
void MDParser::constant() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
switch ( LA(1)) {
case NUM_INT:
case NUM_LONG:
{
intConst();
astFactory->addASTChild( currentAST, returnAST );
constant_AST = currentAST.root;
break;
}
case NUM_FLOAT:
case NUM_DOUBLE:
{
floatConst();
astFactory->addASTChild( currentAST, returnAST );
constant_AST = currentAST.root;
break;
}
case LPAREN:
{
vectorConst();
astFactory->addASTChild( currentAST, returnAST );
constant_AST = currentAST.root;
break;
}
case ID:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp25_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp25_AST);
match(ID);
constant_AST = currentAST.root;
break;
}
case StringLiteral:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp26_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp26_AST);
match(StringLiteral);
constant_AST = currentAST.root;
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_5);
}
returnAST = constant_AST;
}
void IOSCfgParser::interface_known_ip_commands() {
try { // for error handling
{
if ((LA(1) == ACCESS_GROUP) && (LA(2) == WORD)) {
access_group_by_name();
}
else if ((LA(1) == ACCESS_GROUP) && (LA(2) == INT_CONST)) {
access_group_by_number();
}
else if ((LA(1) == ADDRESS)) {
intf_address();
}
else {
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
match(NEWLINE);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void IOSCfgParser::icmp_spec() {
ANTLR_USE_NAMESPACE(antlr)RefToken icmp_type = ANTLR_USE_NAMESPACE(antlr)nullToken;
ANTLR_USE_NAMESPACE(antlr)RefToken icmp_code = ANTLR_USE_NAMESPACE(antlr)nullToken;
ANTLR_USE_NAMESPACE(antlr)RefToken icmp_word = ANTLR_USE_NAMESPACE(antlr)nullToken;
try { // for error handling
{
switch ( LA(1)) {
case INT_CONST:
{
{
icmp_type = LT(1);
match(INT_CONST);
icmp_code = LT(1);
match(INT_CONST);
}
if ( inputState->guessing==0 ) {
#line 379 "iosacl.g"
importer->icmp_type = icmp_type->getText();
importer->icmp_code = icmp_code->getText();
importer->icmp_spec = "";
*dbg << icmp_type->getText() << " "
<< icmp_code->getText() << " ";
#line 1787 "IOSCfgParser.cpp"
}
break;
}
case WORD:
{
icmp_word = LT(1);
match(WORD);
if ( inputState->guessing==0 ) {
#line 388 "iosacl.g"
importer->icmp_spec = icmp_word->getText();
*dbg << icmp_word->getText() << " ";
#line 1801 "IOSCfgParser.cpp"
}
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_5);
} else {
throw;
}
}
}
void MDParser::inversionblock() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp55_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp55_AST);
match(INVERSION);
{
switch ( LA(1)) {
case LBRACKET:
{
match(LBRACKET);
intConst();
match(RBRACKET);
break;
}
case LCURLY:
{
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
match(LCURLY);
{ // ( ... )*
for (;;) {
if ((_tokenSet_10.member(LA(1)))) {
inversionstatement();
astFactory->addASTChild( currentAST, returnAST );
}
else {
goto _loop51;
}
}
_loop51:;
} // ( ... )*
ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp59_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp59_AST);
match(RCURLY);
#line 137 "MDParser.g"
tmp59_AST->setType(ENDBLOCK);
#line 971 "MDParser.cpp"
inversionblock_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_8);
}
returnAST = inversionblock_AST;
}
void MDParser::bendblock() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp45_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp45_AST);
match(BEND);
{
switch ( LA(1)) {
case LBRACKET:
{
match(LBRACKET);
intConst();
match(RBRACKET);
break;
}
case LCURLY:
{
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
match(LCURLY);
{ // ( ... )*
for (;;) {
if ((LA(1) == MEMBERS || LA(1) == ID)) {
bendstatement();
astFactory->addASTChild( currentAST, returnAST );
}
else {
goto _loop41;
}
}
_loop41:;
} // ( ... )*
ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp49_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp49_AST);
match(RCURLY);
#line 123 "MDParser.g"
tmp49_AST->setType(ENDBLOCK);
#line 853 "MDParser.cpp"
bendblock_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_8);
}
returnAST = bendblock_AST;
}
void ConversionParser::conversion() {
ANTLR_USE_NAMESPACE(antlr)RefToken v_from = ANTLR_USE_NAMESPACE(antlr)nullToken;
ANTLR_USE_NAMESPACE(antlr)RefToken v_to = ANTLR_USE_NAMESPACE(antlr)nullToken;
unsigned int from;
unsigned int to;
bool add = false;
try { // for error handling
v_from = LT(1);
match(NUMBER);
{
switch ( LA(1)) {
case C_TYPE:
{
match(C_TYPE);
add = true;
break;
}
case S_TYPE:
{
match(S_TYPE);
add = true;
break;
}
case T_TYPE:
{
match(T_TYPE);
break;
}
case F_TYPE:
{
match(F_TYPE);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
v_to = LT(1);
match(NUMBER);
if(add)
{
from = toHexInt(v_from->getText());
to = toHexInt(v_to->getText());
changer->SetConversion(from,to);
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_1);
}
}
void IOSCfgParser::intf_address() {
ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken;
ANTLR_USE_NAMESPACE(antlr)RefToken m = ANTLR_USE_NAMESPACE(antlr)nullToken;
ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
try { // for error handling
match(ADDRESS);
a = LT(1);
match(IPV4);
m = LT(1);
match(IPV4);
{
switch ( LA(1)) {
case SECONDARY:
{
s = LT(1);
match(SECONDARY);
break;
}
case NEWLINE:
{
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 638 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
importer->addInterfaceAddress(a->getText(), m->getText());
*dbg << LT(1)->getLine() << ":"
<< " INTRFACE ADDRESS: " << a->getText()
<< "/" << m->getText() << " ";
if (s)
{
*dbg << s->getText();
}
*dbg << std::endl;
#line 2172 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_14);
} else {
throw;
}
}
}
void MDParser::atomstatement() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
switch ( LA(1)) {
case ID:
{
assignment();
astFactory->addASTChild( currentAST, returnAST );
atomstatement_AST = currentAST.root;
break;
}
case POSITION:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp75_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp75_AST);
match(POSITION);
match(LPAREN);
doubleNumberTuple();
astFactory->addASTChild( currentAST, returnAST );
match(RPAREN);
match(SEMICOLON);
atomstatement_AST = currentAST.root;
break;
}
case ORIENTATION:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp79_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp79_AST);
match(ORIENTATION);
match(LPAREN);
doubleNumberTuple();
astFactory->addASTChild( currentAST, returnAST );
match(RPAREN);
match(SEMICOLON);
atomstatement_AST = currentAST.root;
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = atomstatement_AST;
}
void IOSCfgParser::intrface() {
ANTLR_USE_NAMESPACE(antlr)RefToken in = ANTLR_USE_NAMESPACE(antlr)nullToken;
try { // for error handling
match(INTRFACE);
in = LT(1);
match(WORD);
if ( inputState->guessing==0 ) {
#line 527 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
importer->newInterface( in->getText() );
*dbg << in->getLine() << ":"
<< " INTRFACE: " << in->getText() << std::endl;
#line 300 "IOSCfgParser.cpp"
}
{
switch ( LA(1)) {
case POINT_TO_POINT:
{
match(POINT_TO_POINT);
if ( inputState->guessing==0 ) {
#line 535 "iosacl.g"
importer->addMessageToLog(
QString("Warning: point-to-point interfaces "
"are not supported"));
#line 314 "IOSCfgParser.cpp"
}
break;
}
case NEWLINE:
{
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
match(NEWLINE);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void MDParser::inversionstatement() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
switch ( LA(1)) {
case ID:
{
assignment();
astFactory->addASTChild( currentAST, returnAST );
inversionstatement_AST = currentAST.root;
break;
}
case CENTER:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp97_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp97_AST);
match(CENTER);
match(LPAREN);
intConst();
astFactory->addASTChild( currentAST, returnAST );
match(RPAREN);
match(SEMICOLON);
inversionstatement_AST = currentAST.root;
break;
}
case SATELLITES:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp101_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp101_AST);
match(SATELLITES);
match(LPAREN);
inttuple();
astFactory->addASTChild( currentAST, returnAST );
match(RPAREN);
match(SEMICOLON);
inversionstatement_AST = currentAST.root;
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_14);
}
returnAST = inversionstatement_AST;
}
void P::arith_exp() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST arith_exp_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
term();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
{ // ( ... )*
for (;;) {
if ((LA(1) == PLUS || LA(1) == MINUS)) {
{
switch ( LA(1)) {
case PLUS:
{
RefBinaryCompArithOpAST tmp7_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp7_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp7_AST));
match(PLUS);
break;
}
case MINUS:
{
RefBinaryCompArithOpAST tmp8_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp8_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp8_AST));
match(MINUS);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
term();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
}
else {
goto _loop6;
}
}
_loop6:;
} // ( ... )*
arith_exp_AST = RefBasicAST(currentAST.root);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_1);
}
returnAST = arith_exp_AST;
}
void P::factor() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST factor_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
factor2();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
{ // ( ... )*
for (;;) {
if ((LA(1) == MOD || LA(1) == EXP)) {
{
switch ( LA(1)) {
case EXP:
{
RefBinaryCompArithOpAST tmp11_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp11_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST));
match(EXP);
break;
}
case MOD:
{
RefBinaryCompArithOpAST tmp12_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp12_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST));
match(MOD);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
factor2();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
}
else {
goto _loop14;
}
}
_loop14:;
} // ( ... )*
factor_AST = RefBasicAST(currentAST.root);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = factor_AST;
}
// [RULE] stat: list EOF | assign EOF;
void stat() {
// check if stat is a list
if (stat_list()) {
list();
match(EOF_TYPE);
}
// check if stat is an assignment
else if (stat_assign()) {
assign();
match(EOF_TYPE);
} else
throw NoViableAltException(lookaheadType(1));
}
void IOSCfgParser::single_port_op() {
try { // for error handling
{
switch ( LA(1)) {
case P_EQ:
{
match(P_EQ);
break;
}
case P_GT:
{
match(P_GT);
break;
}
case P_LT:
{
match(P_LT);
break;
}
case P_NEQ:
{
match(P_NEQ);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 399 "iosacl.g"
importer->tmp_port_op = LT(0)->getText();
*dbg << LT(0)->getText() << " ";
#line 1980 "IOSCfgParser.cpp"
}
port_spec();
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_11);
} else {
throw;
}
}
}
void IOSCfgParser::ip_commands() {
try { // for error handling
match(IP);
{
switch ( LA(1)) {
case ACCESS_LIST:
{
ip_access_list_ext();
break;
}
case ACCESS_GROUP:
case ADDRESS:
{
interface_known_ip_commands();
break;
}
case COMMUNITY_LIST:
{
community_list_command();
break;
}
case ICMP:
case TCP:
case HOST:
{
ip_unused_command();
break;
}
case WORD:
{
unknown_command();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void IOSCfgParser::access_list_commands() {
ANTLR_USE_NAMESPACE(antlr)RefToken acl_num = ANTLR_USE_NAMESPACE(antlr)nullToken;
try { // for error handling
match(ACCESS_LIST);
acl_num = LT(1);
match(INT_CONST);
if ( inputState->guessing==0 ) {
#line 216 "iosacl.g"
importer->newUnidirRuleSet( std::string("acl_") + acl_num->getText(),
libfwbuilder::Policy::TYPENAME);
*dbg << acl_num->getLine() << ":"
<< " ACL #" << acl_num->getText() << " ";
#line 421 "IOSCfgParser.cpp"
}
{
if ((LA(1) == PERMIT) && (LA(2) == IPV4 || LA(2) == ANY)) {
permit_std();
}
else if ((LA(1) == DENY) && (LA(2) == IPV4 || LA(2) == ANY)) {
deny_std();
}
else if ((LA(1) == PERMIT) && (_tokenSet_3.member(LA(2)))) {
permit_ext();
}
else if ((LA(1) == DENY) && (_tokenSet_3.member(LA(2)))) {
deny_ext();
}
else if ((LA(1) == REMARK)) {
remark();
}
else {
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void P::const_lit() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST const_lit_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
switch ( LA(1)) {
case INT:
{
RefDataTypeAST tmp22_AST = RefDataTypeAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp22_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST));
match(INT);
const_lit_AST = RefBasicAST(currentAST.root);
break;
}
case FLOAT:
{
RefDataTypeAST tmp23_AST = RefDataTypeAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp23_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST));
match(FLOAT);
const_lit_AST = RefBasicAST(currentAST.root);
break;
}
case STRING:
{
RefDataTypeAST tmp24_AST = RefDataTypeAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp24_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST));
match(STRING);
const_lit_AST = RefBasicAST(currentAST.root);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_5);
}
returnAST = const_lit_AST;
}
void IOSCfgParser::hostname() {
try { // for error handling
match(HOSTNAME);
{
switch ( LA(1)) {
case STRING:
{
match(STRING);
break;
}
case WORD:
{
match(WORD);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 200 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
importer->setHostName( LT(0)->getText() );
*dbg << "HOSTNAME "
<< "LT0=" << LT(0)->getText()
<< std::endl;
#line 221 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void IOSCfgParser::ip_unused_command() {
try { // for error handling
switch ( LA(1)) {
case ICMP:
{
match(ICMP);
break;
}
case TCP:
{
match(TCP);
break;
}
case HOST:
{
match(HOST);
if ( inputState->guessing==0 ) {
#line 164 "iosacl.g"
consumeUntil(NEWLINE);
#line 736 "IOSCfgParser.cpp"
}
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void IOSCfgParser::vlan() {
try { // for error handling
match(VLAN);
{
switch ( LA(1)) {
case WORD:
{
match(WORD);
break;
}
case INT_CONST:
{
match(INT_CONST);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 507 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
importer->clearCurrentInterface();
consumeUntil(NEWLINE);
#line 393 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void IOSCfgParser::port_spec() {
try { // for error handling
{
switch ( LA(1)) {
case WORD:
{
match(WORD);
break;
}
case INT_CONST:
{
match(INT_CONST);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 415 "iosacl.g"
importer->tmp_port_spec += (std::string(" ") + LT(0)->getText());
*dbg << LT(0)->getText() << " ";
#line 2046 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_13);
} else {
throw;
}
}
}
void IOSCfgParser::ip_protocols() {
try { // for error handling
{
switch ( LA(1)) {
case IP:
{
match(IP);
break;
}
case WORD:
{
match(WORD);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 371 "iosacl.g"
importer->protocol = LT(0)->getText();
*dbg << "protocol " << LT(0)->getText() << " ";
#line 1586 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_7);
} else {
throw;
}
}
}
void IOSCfgParser::log() {
try { // for error handling
{
switch ( LA(1)) {
case LOG:
{
match(LOG);
break;
}
case LOG_INPUT:
{
match(LOG_INPUT);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState->guessing==0 ) {
#line 468 "iosacl.g"
importer->logging = true;
*dbg << "logging ";
#line 1749 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_1);
} else {
throw;
}
}
}
void MDParser::floatConst() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
switch ( LA(1)) {
case NUM_FLOAT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp29_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp29_AST);
match(NUM_FLOAT);
floatConst_AST = currentAST.root;
break;
}
case NUM_DOUBLE:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp30_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp30_AST);
match(NUM_DOUBLE);
floatConst_AST = currentAST.root;
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_7);
}
returnAST = floatConst_AST;
}
void MDParser::doubleNumber() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
{
switch ( LA(1)) {
case NUM_INT:
case NUM_LONG:
{
intConst();
astFactory->addASTChild( currentAST, returnAST );
break;
}
case NUM_FLOAT:
case NUM_DOUBLE:
{
floatConst();
astFactory->addASTChild( currentAST, returnAST );
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
doubleNumber_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_16);
}
returnAST = doubleNumber_AST;
}
void SliceParser::slice() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST slice_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
if ((LA(1) == CONSTRUCT_NAME) && (LA(2) == LEFT_PAREN)) {
ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp1_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp1_AST);
match(CONSTRUCT_NAME);
match(LEFT_PAREN);
{
switch ( LA(1)) {
case CONSTRUCT_NAME:
case LEFT_PAREN:
case NUMBER:
{
internal();
astFactory->addASTChild( currentAST, returnAST );
{ // ( ... )*
for (;;) {
if ((LA(1) == PARAM_SEPARATOR)) {
match(PARAM_SEPARATOR);
internal();
astFactory->addASTChild( currentAST, returnAST );
}
else {
goto _loop4;
}
}
_loop4:;
} // ( ... )*
break;
}
case RIGHT_PAREN:
{
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
match(RIGHT_PAREN);
slice_AST = currentAST.root;
}
else if ((LA(1) == CONSTRUCT_NAME) && (LA(2) == PARAM_SEPARATOR || LA(2) == RIGHT_PAREN)) {
ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp5_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp5_AST);
match(CONSTRUCT_NAME);
slice_AST = currentAST.root;
}
else if ((LA(1) == CONSTRUCT_NAME) && (LA(2) == CONSTRUCT_NAME || LA(2) == NUMBER)) {
ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp6_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp6_AST);
match(CONSTRUCT_NAME);
slice();
astFactory->addASTChild( currentAST, returnAST );
slice_AST = currentAST.root;
}
else if ((LA(1) == NUMBER)) {
ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp7_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp7_AST);
match(NUMBER);
slice_AST = currentAST.root;
}
else {
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
returnAST = slice_AST;
}
CalcChecker::CalcChecker()
: ANTLR_USE_NAMESPACE(antlr)TreeParser() {
}
void CalcChecker::program(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST program_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST_in = _t;
match(_t,PROGRAM_AST);
_t = _t->getFirstChild();
{ // ( ... )+
int _cnt73=0;
for (;;) {
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case DECL:
{
declaration(_t);
_t = _retTree;
break;
}
case PRINT:
case BECOMES:
{
statement(_t);
_t = _retTree;
break;
}
default:
{
if ( _cnt73>=1 ) { goto _loop73; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
}
}
_cnt73++;
}
_loop73:;
} // ( ... )+
_t = __t71;
_t = _t->getNextSibling();
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
match(_t,DECL);
_t = _t->getFirstChild();
type(_t);
_t = _retTree;
id = _t;
match(_t,IDENTIFIER);
_t = _t->getNextSibling();
_t = __t75;
_t = _t->getNextSibling();
#line 231 "Calc.g"
if (isDeclared(id->getText())){
cerr << id->getText() << " is already declared" << endl;
exit(-1);
}
else
declare(id->getText());
#line 88 "CalcChecker.cpp"
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case BECOMES:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
match(_t,BECOMES);
_t = _t->getFirstChild();
id = _t;
match(_t,IDENTIFIER);
_t = _t->getNextSibling();
expr(_t);
_t = _retTree;
_t = __t77;
_t = _t->getNextSibling();
#line 243 "Calc.g"
if (!isDeclared(id->getText()))
{
cerr << id->getText() << " is not declared" << endl;
exit(-1);
}
//TODO: type checking
#line 130 "CalcChecker.cpp"
break;
}
case PRINT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t78 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
match(_t,PRINT);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
_t = __t78;
_t = _t->getNextSibling();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::type(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST type_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case INT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
match(_t,INT);
_t = _t->getNextSibling();
break;
}
case FLOAT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
match(_t,FLOAT);
_t = _t->getNextSibling();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::expr(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST expr_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case INT:
case FLOAT:
case IDENTIFIER:
{
operand(_t);
_t = _retTree;
break;
}
case PLUS:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
match(_t,PLUS);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t80;
_t = _t->getNextSibling();
#line 258 "Calc.g"
/*TODO: type checking*/
#line 223 "CalcChecker.cpp"
break;
}
case MINUS:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
match(_t,MINUS);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t81;
_t = _t->getNextSibling();
#line 259 "Calc.g"
/*TODO: type checking*/
#line 240 "CalcChecker.cpp"
break;
}
case MUL:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
match(_t,MUL);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t82;
_t = _t->getNextSibling();
#line 260 "Calc.g"
/*TODO: type checking*/
#line 257 "CalcChecker.cpp"
break;
}
case DIV:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
match(_t,DIV);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t83;
_t = _t->getNextSibling();
#line 261 "Calc.g"
/*TODO: type checking*/
#line 274 "CalcChecker.cpp"
break;
}
case POW:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t84 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
match(_t,POW);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t84;
_t = _t->getNextSibling();
#line 262 "Calc.g"
/*TODO: type checking*/
#line 291 "CalcChecker.cpp"
break;
}
case SIGN_MINUS:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t85 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
match(_t,SIGN_MINUS);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
_t = __t85;
_t = _t->getNextSibling();
#line 263 "Calc.g"
/*TODO: type checking*/
#line 306 "CalcChecker.cpp"
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::operand(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST operand_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case IDENTIFIER:
{
id = _t;
match(_t,IDENTIFIER);
_t = _t->getNextSibling();
#line 268 "Calc.g"
if (!isDeclared(id->getText())){
cerr << id->getText() << " is not declared" << endl;
exit(-1);
}
#line 342 "CalcChecker.cpp"
break;
}
case INT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
match(_t,INT);
_t = _t->getNextSibling();
break;
}
case FLOAT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
match(_t,FLOAT);
_t = _t->getNextSibling();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
{
}
const char* CalcChecker::tokenNames[] = {
"<0>",
"EOF",
"<2>",
"NULL_TREE_LOOKAHEAD",
"\"print\"",
"\"int\"",
"\"float\"",
"BECOMES",
"PLUS",
"MINUS",
"MUL",
"DIV",
"MOD",
"POW",
"COLON",
"SEMICOLON",
"LPAREN",
"RPAREN",
"LBRACKET",
"RBRACKET",
"COMMA",
"LOWER",
"UPPER",
"DIGIT",
"IDENTIFIER",
"NUMBER",
"COMMENT",
"WS",
"PROGRAM_AST",
"DECL",
"SIGN_MINUS",
"SIGN_PLUS",
0
};
void MDParser::moleculestatement() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
switch ( LA(1)) {
case ID:
{
assignment();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case ATOM:
{
atomblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case BOND:
{
bondblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case BEND:
{
bendblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case TORSION:
{
torsionblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case INVERSION:
{
inversionblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case RIGIDBODY:
{
rigidbodyblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case CUTOFFGROUP:
{
cutoffgroupblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
case FRAGMENT:
{
fragmentblock();
astFactory->addASTChild( currentAST, returnAST );
moleculestatement_AST = currentAST.root;
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_8);
}
returnAST = moleculestatement_AST;
}
void MDParser::statement() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
switch ( LA(1)) {
case ID:
{
assignment();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case COMPONENT:
{
componentblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case MOLECULE:
{
moleculeblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case ZCONSTRAINT:
{
zconstraintblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case RESTRAINT:
{
restraintblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case FLUCQ:
{
flucqblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case RNEMD:
{
rnemdblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
case MINIMIZER:
{
minimizerblock();
astFactory->addASTChild( currentAST, returnAST );
statement_AST = currentAST.root;
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_2);
}
returnAST = statement_AST;
}
