ANTLR_USE_NAMESPACE(antlr)RefToken LexTokenStream::nextToken()
{
ANTLR_USE_NAMESPACE(antlr)RefToken ret;
if (!reachedEOF)
{
int type;
currentLexer = this;
while ((type = yylex()) == -1) // Token::SKIP
;
if (type != 0)
{
if( type != JavaTokenTypes::STRING_LITERAL )
ret = ANTLR_USE_NAMESPACE(antlr)RefToken(new ANTLR_USE_NAMESPACE(antlr)CommonToken(type,yytext));
else
ret = ANTLR_USE_NAMESPACE(antlr)RefToken(new ANTLR_USE_NAMESPACE(antlr)CommonToken(type,string_buf));
// ANTLR_USE_NAMESPACE(std)cout << "Read token " << type << " [" << ret->getText() << "]" << ANTLR_USE_NAMESPACE(std)endl;
}
else
reachedEOF = true;
}
if (reachedEOF)
{
ret = ANTLR_USE_NAMESPACE(antlr)RefToken(new ANTLR_USE_NAMESPACE(antlr)CommonToken(1,"EOF"));
// cout << "EOF reached" << endl;
}
ret->setLine(line);
return ret;
}
void IOSCfgParser::access_group_by_number() {
ANTLR_USE_NAMESPACE(antlr)RefToken acln = ANTLR_USE_NAMESPACE(antlr)nullToken;
ANTLR_USE_NAMESPACE(antlr)RefToken dir = ANTLR_USE_NAMESPACE(antlr)nullToken;
try { // for error handling
match(ACCESS_GROUP);
acln = LT(1);
match(INT_CONST);
dir = LT(1);
match(WORD);
if ( inputState->guessing==0 ) {
#line 625 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
importer->setInterfaceAndDirectionForRuleSet(
std::string("acl_") + acln->getText(),
"",
dir->getText() );
*dbg << LT(1)->getLine() << ":"
<< " INTRFACE: ACL '" << acln->getText() << "'"
<< " " << dir->getText() << std::endl;
#line 2116 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_14);
} else {
throw;
}
}
}
void MDParser::inttuple() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
intConst();
astFactory->addASTChild( currentAST, returnAST );
{ // ( ... )*
for (;;) {
if ((LA(1) == COMMA)) {
match(COMMA);
intConst();
astFactory->addASTChild( currentAST, returnAST );
}
else {
goto _loop71;
}
}
_loop71:;
} // ( ... )*
inttuple_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_12);
}
returnAST = inttuple_AST;
}
void MDParser::mdfile() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
{ // ( ... )*
for (;;) {
if ((_tokenSet_0.member(LA(1)))) {
statement();
astFactory->addASTChild( currentAST, returnAST );
}
else {
goto _loop3;
}
}
_loop3:;
} // ( ... )*
mdfile_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_1);
}
returnAST = mdfile_AST;
}
void IOSCfgParser::time_range() {
ANTLR_USE_NAMESPACE(antlr)RefToken tr_name = ANTLR_USE_NAMESPACE(antlr)nullToken;
try { // for error handling
match(TIME_RANGE);
tr_name = LT(1);
match(WORD);
if ( inputState->guessing==0 ) {
#line 489 "iosacl.g"
importer->time_range_name = tr_name->getText();
*dbg << "time_range " << tr_name->getText() << " ";
#line 1686 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_9);
} else {
throw;
}
}
}
/** Parser error-reporting function can be overridden in subclass */
void Parser::reportError(const RecognitionException& ex)
{
// DW 060204 Amended to indicate error in DOS window
ANTLR_USE_NAMESPACE(std)cerr << "cerr " << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;
// DW 060204 Inserted to show position of condition in trace output
ANTLR_USE_NAMESPACE(std)cout << "cout " << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;
}
ANTLR_USE_NAMESPACE(std)string MismatchedTokenException::getMessage() const
{
ANTLR_USE_NAMESPACE(std)string s;
switch (mismatchType) {
case TOKEN:
s += "expecting " + tokenName(expecting) + ", found '" + tokenText + "'";
break;
case NOT_TOKEN:
s += "expecting anything but " + tokenName(expecting) + "; got it anyway";
break;
case RANGE:
s += "expecting token in range: " + tokenName(expecting) + ".." + tokenName(upper) + ", found '" + tokenText + "'";
break;
case NOT_RANGE:
s += "expecting token NOT in range: " + tokenName(expecting) + ".." + tokenName(upper) + ", found '" + tokenText + "'";
break;
case SET:
case NOT_SET:
{
s += ANTLR_USE_NAMESPACE(std)string("expecting ") + (mismatchType == NOT_SET ? "NOT " : "") + "one of (";
ANTLR_USE_NAMESPACE(std)vector<unsigned int> elems = set.toArray();
for ( unsigned int i = 0; i < elems.size(); i++ )
{
s += " ";
s += tokenName(elems[i]);
}
s += "), found '" + tokenText + "'";
}
break;
default:
s = RecognitionException::getMessage();
break;
}
return s;
}
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 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::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::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 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 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;
}
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 MDParser::assignment() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp1_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, tmp1_AST);
match(ID);
ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
tmp2_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, tmp2_AST);
match(ASSIGNEQUAL);
constant();
astFactory->addASTChild( currentAST, returnAST );
match(SEMICOLON);
assignment_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = assignment_AST;
}
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 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 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 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 IOSCfgParser::description() {
try { // for error handling
match(DESCRIPTION);
if ( inputState->guessing==0 ) {
#line 547 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
*dbg << LT(1)->getLine() << ":";
std::string descr;
while (LA(1) != ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE && LA(1) != NEWLINE)
{
descr += LT(1)->getText() + " ";
consume();
}
importer->setInterfaceComment( descr );
*dbg << " DESCRIPTION " << descr << std::endl;
//consumeUntil(NEWLINE);
#line 489 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_2);
} else {
throw;
}
}
}
void MDParser::fragmentstatement() {
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
assignment();
astFactory->addASTChild( currentAST, returnAST );
fragmentstatement_AST = currentAST.root;
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_15);
}
returnAST = fragmentstatement_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::remark() {
try { // for error handling
match(REMARK);
if ( inputState->guessing==0 ) {
#line 566 "iosacl.g"
importer->setCurrentLineNumber(LT(0)->getLine());
*dbg << LT(1)->getLine() << ":";
std::string rem;
while (LA(1) != ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE && LA(1) != NEWLINE)
{
rem += LT(1)->getText() + " ";
consume();
}
importer->addRuleComment( rem );
*dbg << " REMARK " << rem << std::endl;
//consumeUntil(NEWLINE);
#line 909 "IOSCfgParser.cpp"
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
if( inputState->guessing == 0 ) {
reportError(ex);
recover(ex,_tokenSet_1);
} 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;
}
ANTLR_USE_NAMESPACE(std)string MismatchedTokenException::tokenName(int tokenType) const
{
if (tokenType == Token::INVALID_TYPE)
return "<Set of tokens>";
else if (tokenType < 0 || tokenType >= numTokens)
return ANTLR_USE_NAMESPACE(std)string("<") + tokenType + ">";
else
return tokenNames[tokenType];
}
/** get the current marked characters as a string
* @warning it may treat 0 and EOF values wrong
*/
ANTLR_USE_NAMESPACE(std)string InputBuffer::getMarkedChars( void ) const
{
ANTLR_USE_NAMESPACE(std)string ret;
for(unsigned int i = 0; i < markerOffset; i++)
ret += queue.elementAt(i);
return ret;
}
/** get the current lookahead characters as a string
* @warning it may treat 0 and EOF values wrong
*/
ANTLR_USE_NAMESPACE(std)string InputBuffer::getLAChars( void ) const
{
ANTLR_USE_NAMESPACE(std)string ret;
for(int i = markerOffset; i < queue.entries(); i++)
ret += queue.elementAt(i);
return ret;
}
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;
}
}
}
ANTLR_USE_NAMESPACE(std)vector<unsigned int> BitSet::toArray() const {
ANTLR_USE_NAMESPACE(std)vector<unsigned int> elems;
for (unsigned int i = 0; i < storage.size(); i++) {
if (storage[i])
elems.push_back(i);
}
return elems;
}
/**Make sure current lookahead symbol matches token type <tt>t</tt>.
* Throw an exception upon mismatch, which is catch by either the
* error handler or by the syntactic predicate.
*/
void Parser::match(int t)
{
if ( DEBUG_PARSER )
{
traceIndent();
ANTLR_USE_NAMESPACE(std)cout << "enter match(" << t << ") with LA(1)=" << LA(1) << ANTLR_USE_NAMESPACE(std)endl;
}
if ( LA(1)!=t ) {
if ( DEBUG_PARSER )
{
traceIndent();
ANTLR_USE_NAMESPACE(std)cout << "token mismatch: " << LA(1) << "!=" << t << ANTLR_USE_NAMESPACE(std)endl;
}
throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), t, false, getFilename());
} else {
// mark token as consumed -- fetch next token deferred until LA/LT
consume();
}
}
