StationParser.cpp

Go to the documentation of this file.

/* $ANTLR 2.7.6 (20070220): "StationParser.g" -> "StationParser.cpp"$ */
#include "StationParser.hpp"
#include <antlr/NoViableAltException.hpp>
#include <antlr/SemanticException.hpp>
#include <antlr/ASTFactory.hpp>
#line 1 "StationParser.g"
#line 8 "StationParser.cpp"
StationParser::StationParser(antlr::TokenBuffer& tokenBuf, int k)
: antlr::LLkParser(tokenBuf,k)
{
}

StationParser::StationParser(antlr::TokenBuffer& tokenBuf)
: antlr::LLkParser(tokenBuf,10)
{
}

StationParser::StationParser(antlr::TokenStream& lexer, int k)
: antlr::LLkParser(lexer,k)
{
}

StationParser::StationParser(antlr::TokenStream& lexer)
: antlr::LLkParser(lexer,10)
{
}

StationParser::StationParser(const antlr::ParserSharedInputState& state)
: antlr::LLkParser(state,10)
{
}

void StationParser::stationfile() {
        
        try {      // for error handling
                { // ( ... )+
                int _cnt3=0;
                for (;;) {
                        if ((LA(1) == ENTRY)) {
                                stationline();
                        }
                        else {
                                if ( _cnt3>=1 ) { goto _loop3; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt3++;
                }
                _loop3:;
                }  // ( ... )+
                match(antlr::Token::EOF_TYPE);
        }
        catch (antlr::RecognitionException& ex) {
                reportError(ex);
                recover(ex,_tokenSet_0);
        }
}

void StationParser::stationline() {
#line 34 "StationParser.g"
        double latde,longde; std::string name;
#line 62 "StationParser.cpp"
        
        try {      // for error handling
                name=stringvalue();
#line 36 "StationParser.g"
                Stationnames.push_back(name);
#line 68 "StationParser.cpp"
                {
                switch ( LA(1)) {
                case ENTRY:
                {
                        {
                        longde=datavalue();
                        latde=datavalue();
                        }
#line 37 "StationParser.g"
                        Latitudes.push_back(latde); Longitudes.push_back(longde); HasLatLong.push_back(true);
#line 79 "StationParser.cpp"
                        break;
                }
                case NEWLINE:
                {
#line 38 "StationParser.g"
                        Latitudes.push_back(0); Longitudes.push_back(0); HasLatLong.push_back(false);
#line 86 "StationParser.cpp"
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltException(LT(1), getFilename());
                }
                }
                }
                match(NEWLINE);
        }
        catch (antlr::RecognitionException& ex) {
                reportError(ex);
                recover(ex,_tokenSet_1);
        }
}

std::string  StationParser::stringvalue() {
#line 47 "StationParser.g"
        std::string r;
#line 106 "StationParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(ENTRY);
#line 48 "StationParser.g"
                r = currvalue->getText();
#line 114 "StationParser.cpp"
        }
        catch (antlr::RecognitionException& ex) {
                reportError(ex);
                recover(ex,_tokenSet_2);
        }
        return r;
}

double  StationParser::datavalue() {
#line 42 "StationParser.g"
        double r;
#line 126 "StationParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(ENTRY);
#line 44 "StationParser.g"
                r = atof(currvalue->getText().c_str());
#line 134 "StationParser.cpp"
        }
        catch (antlr::RecognitionException& ex) {
                reportError(ex);
                recover(ex,_tokenSet_2);
        }
        return r;
}

void StationParser::initializeASTFactory( antlr::ASTFactory& )
{
}
const char* StationParser::tokenNames[] = {
        "<0>",
        "EOF",
        "<2>",
        "NULL_TREE_LOOKAHEAD",
        "NEWLINE",
        "ENTRY",
        "WS",
        "COMMENT",
        "PLUS",
        "MINUS",
        "DIGIT",
        "CHAR",
        "OTHER",
        0
};

const unsigned long StationParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL };
// EOF 
const antlr::BitSet StationParser::_tokenSet_0(_tokenSet_0_data_,4);
const unsigned long StationParser::_tokenSet_1_data_[] = { 34UL, 0UL, 0UL, 0UL };
// EOF ENTRY 
const antlr::BitSet StationParser::_tokenSet_1(_tokenSet_1_data_,4);
const unsigned long StationParser::_tokenSet_2_data_[] = { 48UL, 0UL, 0UL, 0UL };
// NEWLINE ENTRY 
const antlr::BitSet StationParser::_tokenSet_2(_tokenSet_2_data_,4);

---