D:/Zythum/DinoKod/Common/Parser.cpp

#include "Common/Assert.h"
#include "Common/File.h"

#include "Common/Parser.h"

//---------------------------------------------------------------------------------------------------------------------
KParser::KParser()
{
        m_pBuffer               = NULL;
        m_nSize                 = 0;
        m_nCurrentPos   = 0;
        m_bIsNewLine    = false;
        m_pToken[0]             = '\0';
        m_nLine                 = 0;
}

//---------------------------------------------------------------------------------------------------------------------
KParser::KParser( char* pFileName )
{
        m_pBuffer               = NULL;
        m_nSize                 = 0;
        m_nCurrentPos   = 0;
        m_pToken[0]             = '\0';
        m_nLine                 = 0;

        LoadASE( pFileName );
}

//---------------------------------------------------------------------------------------------------------------------
KParser::~KParser()
{
        Clean();
}


//---------------------------------------------------------------------------------------------------------------------
void KParser::Clean()
{
        m_nSize                 = 0;
        m_nCurrentPos   = 0;
        if( m_pBuffer )
                Deletev( m_pBuffer );
        m_pBuffer               = NULL;
        m_pToken[0]             = '\0';
}

//---------------------------------------------------------------------------------------------------------------------
bool KParser::LoadASE( char* pFileName )
{
        KFile   File;

        Clean();

        // Load le fichier ASCII
        if( !File.Open( pFileName ) )
                return false;

        m_nSize = File.GetSize();
        if( !m_nSize )
        {
                File.Close();
                return false;
        }

        m_pBuffer = new char[m_nSize];
        if( !File.Read( (unsigned char*)m_pBuffer, m_nSize ) )
        {
                Deletev( m_pBuffer );
                m_pBuffer       = NULL;
                m_nSize         = 0;
                return false;
        }

        File.Close();

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KParser::SearchToken( char* pToken )
{
        KASSERT( m_pBuffer );

        // TODO
}

// Cherche le prochain token
//---------------------------------------------------------------------------------------------------------------------
void KParser::FindToken()
{
        KASSERT( m_pBuffer );

        u32             nPos;
        u32             nTokenPos = 0;

        m_pToken[0]             = '\0';

        for( nPos = m_nCurrentPos; nPos < m_nSize; nPos ++ )
        {
                m_bIsNewLine = false;
                switch( m_pBuffer[nPos] )
                {
                case '\n':
                case '\r':
                        m_bIsNewLine = true;
                case ' ':
                case '\t':
                        if( nTokenPos )
                        {
                                m_pToken[nTokenPos++] = '\0';
                                m_nCurrentPos = nPos;
                                return;
                        }
                        break;
                case '#':
                case ';':
                        // "#" ";" Commentaire : Passe la ligne
                        while( ( m_pBuffer[++nPos] != '\n' ) && nPos < m_nSize );
                        break;
                case '/':
                        // "//" "/*" Commentaire ?
                        if(nPos + 1 < m_nSize )
                        {
                                if( m_pBuffer[nPos+1] == '/' )
                                {
                                        // Passe la ligne
                                        while( ( m_pBuffer[++nPos] != '\n' ) && nPos < m_nSize );
                                        break;
                                }
                                else
                                if( m_pBuffer[nPos+1] == '*' )
                                {
                                        // Cherche la fin du commentaire
                                        while( nPos + 1 < m_nSize )
                                        {
                                                nPos ++;
                                                if( ( m_pBuffer[nPos] == '*' ) && ( m_pBuffer[nPos + 1] == '/' ) )
                                                {
                                                        nPos += 2;
                                                        break;
                                                }
                                        }
                                        break;
                                }
                        }
                default:
                        m_pToken[nTokenPos++] = m_pBuffer[nPos];
                        break;
                }

                if( m_bIsNewLine )
                        m_nLine ++;
        }
        m_nCurrentPos = nPos;
}

//---------------------------------------------------------------------------------------------------------------------
char* KParser::GetToken()
{
        return m_pToken;
}

---