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

#include <string.h>
#include <stdlib.h>
//#include <windows.h>
#include "Common/File.h"
#include "Common/Error.h"

#include "Common/Ini.h"

#define MAX_BUFSIZE             1024

//---------------------------------------------------------------------------------------------------------------------
KIni::KIni( KFile& File )
{
        m_pFile                         = new KFile();
        *m_pFile                        = File;
        m_bMustCloseFile        = false;
        m_bHasChanged           = false;
        LoadCache();
}

//---------------------------------------------------------------------------------------------------------------------
KIni::KIni( char* pFileName )
{
        m_pFile = new KFile();
        if( !m_pFile->Open( pFileName, KFM_READWRITE ) )
                if( !m_pFile->Open( pFileName, KFM_READ ) )
                        if( !m_pFile->Create( pFileName ) )
                                KError::Error( NULL, "KIni::KIni(...) Cannot open file : [%s]", pFileName );

        m_bMustCloseFile        = true;
        m_bHasChanged           = false;
        LoadCache();
}

//---------------------------------------------------------------------------------------------------------------------
KIni::~KIni()
{
        if( m_bHasChanged && ( m_pFile->GetMode() == KFM_READWRITE ) )
                SaveCache();

        if( m_bMustCloseFile )
                m_pFile->Close();

        Deletep( m_pFile );

        KIniSection*    pSection;
        for( pSection = m_SectionsList.GetFirst(); pSection ; pSection = m_SectionsList.GetNext( pSection ) )
                delete pSection;
        m_SectionsList.Clear();
}

//---------------------------------------------------------------------------------------------------------------------
void KIni::LoadCache()
{
        KStr            sBuffer;
        char            pSectionName[MAX_BUFSIZE];
        char            pKeyName[MAX_BUFSIZE];

        m_pFile->Rewind();

        if( !m_pFile->ReadText( sBuffer ) )
                return;

        while( !m_pFile->IsEOF() )
        {
                strcpy( pSectionName, sBuffer.GetpString() );

                // Section
                if( strlen( pSectionName ) && pSectionName[0] == '[' && !(pSectionName[0] == '/' && pSectionName[1] == '/' ) )
                {
                        // Section trouvée
                        pSectionName[strlen( pSectionName ) - 1] = '\0';
                        KIniSection*    pSection = new KIniSection( &pSectionName[1] );
                        m_SectionsList.Add( pSection );

//                      char p[1024];
//                      sprintf( p, "[%s]\n", pSection->m_pSection );
//                      OutputDebugString( p );

                        do
                        {
                                // Clé
                                if( !m_pFile->ReadText( sBuffer ) )
                                        return;
                                
                                strcpy( pKeyName, sBuffer.GetpString() );

                                if( strlen( pKeyName ) && pKeyName[0] != '[' && !( pKeyName[0] == '/' && pKeyName[1] == '/' ) )
                                {
                                        s32             Pos;
                                        char*   pPos;
                                        if( pPos = strstr( pKeyName, "=" ) )
                                        {
                                                // Clé Trouvée
                                                Pos = (s32)(pPos - pKeyName + 1);
                                                pKeyName[Pos - 1] = '\0';

                                                // Verifie si elle exite deja
                                                if( FindKey( &pSectionName[1], pKeyName, false ) )
                                                {
                                                        KError::Error( NULL, "KIni::LoadCache(...) : Duplicate key found, ignoring... %s [%s] %s=%s", m_pFile->GetsFileName().GetpString(), &pSectionName[1], pKeyName, &pKeyName[Pos] );
                                                        continue;
                                                }
                                                
                                                KIniKey*        pKey = new KIniKey( pKeyName, &pKeyName[Pos] );
                                                pSection->AddpKey( pKey );
                                                
//                                              char p[1024];
//                                              sprintf( p, "%s=%s\n", pKey->m_pKey, pKey->m_pValue );
//                                              OutputDebugString( p );
                                        }
                                }
                        }while( !m_pFile->IsEOF() && ( pKeyName[0] != '[' ) );
                }
                else
                {
                        if( !m_pFile->ReadText( sBuffer ) )
                                return;
                }
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KIni::SaveCache()
{
        KIniSection*    pIniSection;
        KIniKey*                pIniKey;
        KStr                    sBuffer;

        m_pFile->Reset();

        for( pIniSection = m_SectionsList.GetFirst(); pIniSection ; pIniSection = m_SectionsList.GetNext( pIniSection ) )
        {
                sBuffer = "[";
                sBuffer += pIniSection->m_pSection;
                sBuffer += "]\r\n";
                m_pFile->WriteText( sBuffer );

                for( pIniKey = pIniSection->GetpFirstKey(); pIniKey ; pIniKey = pIniSection->GetpNextKey( pIniKey ) )
                {
                        sBuffer = pIniKey->m_pKey;
                        sBuffer += "=";
                        sBuffer += pIniKey->m_pValue ? pIniKey->m_pValue : "";
                        sBuffer += "\r\n";
                        m_pFile->WriteText( sBuffer );
                }
                sBuffer = "\r\n";
                m_pFile->WriteText( sBuffer );
        }
}

//---------------------------------------------------------------------------------------------------------------------
char* KIni::FindKey( char* pSection, char* pKey, bool bShowError )
{
        // Recherche dans le cache
        KIniSection*    pIniSection;
        for( pIniSection = m_SectionsList.GetFirst(); pIniSection ; pIniSection = m_SectionsList.GetNext( pIniSection ) )
        {
                if( stricmp( pIniSection->m_pSection, pSection ) == 0 )
                {
                        // Section trouvée
                        KIniKey*        pIniKey;
                        for( pIniKey = pIniSection->GetpFirstKey(); pIniKey ; pIniKey = pIniSection->GetpNextKey( pIniKey ) )
                        {
                                if( stricmp( pIniKey->m_pKey, pKey ) == 0 )
                                {
                                        // Clé trouvée
                                        return pIniKey->m_pValue;
                                }
                        }
                        if( bShowError )
                                KError::Warning( NULL, "INI : [%s] %s not found", pSection, pKey );
                        
                        return NULL;
                }
        }

        if( bShowError )
                KError::Warning( NULL, "INI : [%s] %s not found", pSection, pKey );
        
        return NULL;
}

//---------------------------------------------------------------------------------------------------------------------
void KIni::SetKey( char* pSection, char* pKey, char* pString )
{
        KIniSection*    pIniSection;
        KIniKey*                pIniKey;

        m_bHasChanged = true;

        // Recherche dans le cache
        for( pIniSection = m_SectionsList.GetFirst(); pIniSection ; pIniSection = m_SectionsList.GetNext( pIniSection ) )
        {
                if( stricmp( pIniSection->m_pSection, pSection ) == 0 )
                {
                        // Section trouvée
                        for( pIniKey = pIniSection->GetpFirstKey(); pIniKey ; pIniKey = pIniSection->GetpNextKey( pIniKey ) )
                        {
                                if( stricmp( pIniKey->m_pKey, pKey ) == 0 )
                                {
                                        // Clé trouvée
                                        Freep( pIniKey->m_pValue );
                                        pIniKey->m_pValue = strdup( pString );
                                        return;
                                }
                        }
                        pIniKey = new KIniKey( pKey, pString );
                        pIniSection->AddpKey( pIniKey );
                        return;
                }
        }

        pIniSection = new KIniSection( pSection );
        m_SectionsList.Add( pIniSection );
        pIniKey = new KIniKey( pKey, pString );
        pIniSection->AddpKey( pIniKey );
}
//---------------------------------------------------------------------------------------------------------------------
s32 KIni::ReadInt( char* pSection, char* pKey, s32 DefaultValue )
{
        char*   pBuffer;

        pBuffer = FindKey( pSection, pKey );
        if( !pBuffer )
        {
                WriteInt( pSection, pKey, DefaultValue );
                return DefaultValue;
        }

        return atoi( pBuffer );
}

//---------------------------------------------------------------------------------------------------------------------
float KIni::ReadFloat( char* pSection, char* pKey, float DefaultValue )
{
        char*   pBuffer;

        pBuffer = FindKey( pSection, pKey );
        if( !pBuffer )
        {
                WriteFloat( pSection, pKey, DefaultValue );
                return DefaultValue;
        }

        return (float)atof( pBuffer );
}

//---------------------------------------------------------------------------------------------------------------------
const char* KIni::ReadString( char* pSection, char* pKey, char* DefaultString )
{
        char*   pBuffer;

        pBuffer = FindKey( pSection, pKey );
        if( !pBuffer )
        {
                WriteString( pSection, pKey, DefaultString );
                return DefaultString;
        }

        return pBuffer;
}

//---------------------------------------------------------------------------------------------------------------------
void KIni::WriteString( char* pSection, char* pKey, char* pString )
{
        SetKey( pSection, pKey, pString );
}

//---------------------------------------------------------------------------------------------------------------------
void KIni::WriteInt( char* pSection, char* pKey, s32 Value )
{
        char    pBuffer[MAX_BUFSIZE];

        sprintf( pBuffer, "%i", Value );
        SetKey( pSection, pKey, pBuffer );
}

//---------------------------------------------------------------------------------------------------------------------
void KIni::WriteFloat( char* pSection, char* pKey, float Value )
{
        char    pBuffer[MAX_BUFSIZE];

        sprintf( pBuffer, "%f", Value );
        SetKey( pSection, pKey, pBuffer );
}

---