interpret.cpp

Go to the documentation of this file.

#include <SdlArs.h>

Lexer::Lexer( const string &aBuffer )
: buffer( aBuffer ) , bufLen( aBuffer.length() ) , at( 0 ) , lineno( 0 )
{
}

const int Lexer::GetTopSymbol( void )
{
        realConstant = false;
        constantStr.clear();

        while( isSeparator() )
                at++;

        return SkipComment();
}

const bool Lexer::isSeparator( void )
{
        if( at < bufLen && buffer.substr( at , 1 ).find_first_of( "\n\r\t " ) != string::npos )
        {
                if( buffer[at] == '\n' )
                        lineno += 1;
                return true;
        }
        return false;
}

const int Lexer::SkipComment( void )
{
        if( at > bufLen )
                return -1;
        else if( at == bufLen )
        {
                at += 1;
                return EofId();
        }
        else if( (at + 2) < bufLen && buffer.substr( at , 2 ) == "//" )
        {
                at = buffer.find( '\n' , at );
                                  
                return GetTopSymbol();
        }
        return LexNext();
}

const int Lexer::LexNext( void )
{
        for( map<string,int,greater<string> >::iterator it = symbol.begin() ; it != symbol.end() ; ++it )
                if( buffer.substr( at , it->first.length() ) == it->first )
                {
                        constantStr = it->first;
                        at += it->first.length();
                        return it->second;
                }

        if( isalpha( buffer[at] ) )
                return GetIdentifier();
        else if( isdigit( buffer[at] ) )
                return GetNumber();

        return -1;
}

const int Lexer::GetIdentifier( void )
{
        while( isalnum( buffer[at] ) || buffer[at] == '_' )
                constantStr += buffer[at++];

        return IdentifierId();
}

const int Lexer::GetNumber( void )
{
        while( isdigit( buffer[at] ) )
                constantStr += buffer[at++];
        if( buffer[at] == '.' )
        {
                at += 1;
                realConstant = true;
                constantStr += '.';
                while( isdigit( buffer[at] ) )
                        constantStr += buffer[at++];
        }
        return NumberId();
}

Interpret::Interpret( Lexer &SedLex )
: duraLex( SedLex )
{
        Initialize();
}

/*
Interpret::~Interpret( void )
{
        for( deque<TreeNode *>::iterator it = begin() ; it != end() ; ++it )
                delete (*it);
        clear();
}
*/

const bool Interpret::Run( void )
{
        int     ts = duraLex.GetTopSymbol();

        while( ts != -1 )
        {
                switch( duraLex.atSr( back()->symbolId , ts ) )
                {
                        default :
                        case ' ' :      
                        {       printf( "syntax error:\n" );
                                for( deque<TreeNode*>::iterator it = begin() ; it != end() ; ++it )
                                {
                                        const char      *s = (*it)->constant.empty() ? "" : (*it)->constant.c_str();
                                        printf( "%s\t" , s );
                                }
                                printf( "\nwith terminal symbol: %s\n" , duraLex.GetConstant().c_str() );
                        }
                                return false;

                        case '=' :      //      Shift the stack... according to the grammar rule
                        case '<' :      //      Shift the stack... according to the grammar rule
                                ShiftRule( ts );
                                ts = duraLex.GetTopSymbol();
                                break;

                        case '>' :      //      Reduce
                                if( !ReduceRule( ts ) )
                                        return false;
                                break;
                        case '$' :
                                return true;
                }
        }
        return true;
}

void Interpret::Initialize( void )
{
        clear();
        push_back( new TreeNode( duraLex.EofId() ) );
}

void Interpret::ShiftRule( const int TopSymbol )
{
        TreeNode *tn2 = back();
        back()->next = new TreeNode( TopSymbol , duraLex.GetConstant() );
        push_back( back()->next );
        tn2 = back();
}

const bool Interpret::ReduceRule( const int TopSymbol )
{
        TreeNode *tn = back();
        pop_back();
        TreeNode *tn2 = back();
        back()->next = 0;
        tn->next = tn->child;
        tn->child = back()->child;
        back()->child = tn;

        return true;
}

---