IniFile.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: INI file support class. (Ini files are portable, registry is not.)
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/IniFile.h>
#include <uLib/StrFunc.h>
#include <uLib/UtilFunc.h>
#include <uLib/Debug.h>

// FIXME: IniFile should use ANSI strings only, not TCHAR.

IniFile::IniFile( CSTR Name, UINT BufSize )
: _buffer(NULL), _bufSize(0), _valSize(0), UserData(0)
{
    SetFilename( Name );
    if (BufSize) AllocBuffer( BufSize );
}

IniFile::~IniFile()
{
    if (_buffer) mem_Free( _buffer );
}

void IniFile::SetFilename( CSTR FName )
{
    static CCSTR iniExt = _T(".ini");

    if (FName) _tcscpy_s( Filename, dimof(Filename), FName );
    else
    {
        GetModuleFileName( NULL, Filename, dimof(Filename) );
        TSTR dot = _tcsrchr( Filename, DOT );
      BEGIN_STRSAFE_OVERRIDE
        if (dot) _tcscpy( dot, iniExt );
        else _tcscat( Filename, iniExt );
      END_STRSAFE_OVERRIDE
    }
}

bool IniFile::AllocBuffer( UINT Size )
{
    // Size 0 means: use default (MAX_PATH)

    bool ok = ((_bufSize >= Size) && (Size != 0));
    if (!ok)
    {
        if (!Size) Size = MAX_PATH;
        PBYTE newBuf = (PBYTE) mem_Alloc( Size );
        ok = (newBuf != NULL);
        if (ok)
        {
            if (_buffer) mem_Free( _buffer );
            _buffer = newBuf;
            _bufSize = Size;
        }
    }
    if (_buffer) _buffer[0] = 0;
    return ok;
}

// READ -----------------------------------------------------------------------

UINT IniFile::GetInt( CSTR Section, CSTR KeyName, INT Default )
{
    return GetPrivateProfileInt( Section, KeyName, Default, Filename );
}

INT IniFile::GetString( CSTR Section, CSTR KeyName, CSTR Default, TSTR Buf, UINT BufLen )
{
    if (!_buffer) _valSize = 0;
    else _valSize = GetPrivateProfileString( Section, KeyName, Default, (TSTR)_buffer, _bufSize, Filename ); // cache it

    if (_valSize) _tcsncpyz( Buf, (TSTR)_buffer, min_<UINT>( BufLen, (UINT)_valSize+1 ));
    if (_valSize == INT(_bufSize-1) || _valSize == INT(_bufSize-2) ) // See MSDN
        _valSize = -_valSize; // Insufficient buffer
    return _valSize;
}

TSTR IniFile::GetString( CSTR Section, CSTR KeyName, CSTR Default, INT* Size )
{
    if (!_buffer) _valSize = 0;
    else _valSize = GetPrivateProfileString( Section, KeyName, Default, (TSTR)_buffer, _bufSize, Filename );

    if (_valSize == INT(_bufSize-1) || _valSize == INT(_bufSize-2) )
        _valSize = -_valSize; // Insufficient buffer
    if (Size) *Size = _valSize;
    return _valSize ? (TSTR)_buffer : NULL;
}

//

TSTR IniFile::GetSection( CSTR Section, INT* Size )
{
    if (_buffer)
    {
        _valSize = GetPrivateProfileSection( Section, (TSTR)_buffer, _bufSize, Filename );
        if (_valSize == INT(_bufSize - 2)) // If buffer was too small...
        {
            _buffer[_valSize] = _buffer[_valSize+1] = _NUL; // double-null term for safety.
            _valSize = -_valSize;
        }
        if (Size) *Size = _valSize;
    }
    return (TSTR)_buffer;
}

TSTR IniFile::GetSectionNames( INT* Size )
{
    if (_buffer)
    {
        _valSize = GetPrivateProfileSectionNames( (TSTR)_buffer, _bufSize, Filename );
        if (_valSize == INT(_bufSize - 2))
        {
            _buffer[_valSize] = _buffer[_valSize+1] = _NUL;
            _valSize = -_valSize;
        }
        if (Size) *Size = _valSize;
    }
    return (TSTR)_buffer;
}

PBYTE IniFile::GetStruct( CSTR Section, CSTR Key, UINT cbData )
{
    BOOL ok = (_buffer != 0);
    if (ok) ok = (_bufSize >= cbData+1 );
    if (ok) ok = GetPrivateProfileStruct( Section, Key, _buffer, cbData, Filename );
    return ok ? _buffer : NULL;
}

static BYTE __hexVal( TCHAR Ch )
{
    BYTE val;
    if (Ch <= _T('9')) val = Ch - _T('0');
    else val = 10 + (_totupper( Ch ) - _T('A'));
    return val;
}
static BYTE _hexVal( TCHAR* Src )
{
    BYTE hiVal = __hexVal( *Src );
    BYTE loVal = __hexVal( *(Src+1) );
    return (hiVal << 4) + loVal;
}

PBYTE IniFile::GetBinary( CSTR Section, CSTR Key, INT* pSize )
{
    INT size = 0;
    GetString( Section, Key, NULL, &size );
    if (size <= 0) return NULL;

    TSTR src = (TSTR)_buffer;
    PBYTE dst = _buffer;
    while( *src )
    {
        *dst = _hexVal( src );
        src += 2;
        dst++;
    }
    size /= 2;
    size--;

    if (pSize) *pSize = size;

    BYTE csum = 0;
    for( INT i=0; i < size; ++i ) csum += _buffer[i];
    return (csum == _buffer[size]) ? _buffer : NULL;
}

// WRITE ----------------------------------------------------------------------

BOOL IniFile::WriteSection( CSTR Section, CSTR String )
{
    return WritePrivateProfileSection( Section, String, Filename );
}

//static UINT multiSzSize( CSTR pmSz )
//{
//    TSTR pEnd = (TSTR) pmSz;
//    while( *pEnd ) pEnd = _tcschr( pEnd,0 ) + 1;
//    return (pEnd - pmSz) + _TCHAR_SIZE; // Count the 2nd _NUL as well
//}
static UINT writeMultiSz( HANDLE hFile, CSTR pmSz )
{
    UINT nStr = 0;
    TSTR pEnd = (TSTR) pmSz;
    while( pEnd && *pEnd )
    {
        TSTR pBegin = pEnd;
        pEnd = _tcschr( pEnd, 0 );
        if (pEnd)
        {
            WriteLine( hFile, pBegin );
            nStr++;
            pEnd++;
        }
    }
    return nStr;
}

BOOL IniFile::WriteRawSection( CSTR Section, CSTR MultiSz )
{
    // It seems WritePrivateProfileSection actually parses the multistring
    // instead of just replacing the entire section with the given block :/
    // So, here is one that just replaces the section verbatim.

    static const TCHAR _SqBrkt  = _T('[');
    static const TCHAR _ESqBrkt = _T(']');

    UINT nStr = 0, fpos;
    HANDLE hFile = CheckHandle(
        CreateFile( Filename, GENERIC_RW, 0, &DefSec, OPEN_ALWAYS, 0, NULL )
        );
    if (!hFile)
        DPrint( DP_ERROR, _F("Can't open %s: %s\n"), Filename, SysErrorMsg() );
    else
    {
        TSTR pSect = NULL, pNext = NULL;
        UINT nlen = (UINT)_tcslen( Section ); // Section name length
        PBYTE fbuf = NULL;
        UINT fsize = GetFileSize( hFile, NULL );
        if (fsize)
        {
            fbuf = (PBYTE) mem_Alloc( fsize );
            if (!fbuf)
            {
                DPrint( DP_ERROR, _F("Out of memory (fsize=%lu).\n"), fsize );
                goto wrs_Close;
            }
            if (BlockRead( hFile, fbuf, fsize ) == fsize)
            {
                // Find Section so it can be replaced.
                // If not found (pSect=NULL), it will be appended instead.

                TSTR pTmp = (TSTR) fbuf;
                while( pTmp )
                {
                    pTmp = _tcschr( pTmp, _SqBrkt );
                    if (pTmp)
                    {
                        if (_tcsnicmp( &pTmp[1], Section, nlen ) == 0)
                        {
                            // Check if it's a partial or full Section name match
                            TSTR pEnd = pTmp + (nlen+1);
                            if (*pEnd == _ESqBrkt)   // ']' - Found it
                            {
                                pSect = pTmp;        // '['
                                pNext = _tcschr( pEnd, _SqBrkt ); // Next section, if any
                                break;
                            }
                        }
                        pTmp++;
                    }
                }
            }
        }

        // Write out MultiSz, either at old pos, or appended at end of file.
        // This code is outside the BlockRead compound so it can be written
        // to a file with no previous content.

        fpos = pSect ? UINT( PBYTE(pSect) - fbuf ) : fsize;
        SetFilePointer( hFile, fpos, NULL, FILE_BEGIN );

        WriteStr( hFile, _T("[%s]\r\n"), Section ); // Section heading (rewrite).
        nStr = writeMultiSz( hFile, MultiSz );      // Section data.

        if (pNext) // Any more sections trailing ?
        {
            BlockWrite( hFile, (PVOID)_T("\r\n"), 2*sizeof(TCHAR) ); // Add blank line.
            UINT nbytes = fsize - UINT( PBYTE(pNext) - fbuf ); // Nr of bytes after pNext.
            BlockWrite( hFile, pNext, nbytes ); // Write out trailing sections.
        }
        mem_Free( fbuf );

    wrs_Close:
        CloseHandle( hFile );
    }
    return nStr;
}

BOOL IniFile::WriteInt( CSTR Section, CSTR KeyName, LONG Value, BYTE Radix )
{
    CSTR fmt;
    switch( Radix ) // GetPrivateProfileInt can handle radix 10 and 16.
    {
        case 10: fmt = _T("%li"); break;
        case 16: fmt = _T("0x%08X"); break;
        default: return FALSE;
    }
    return WriteStringFmt( Section, KeyName, fmt, Value );
}

BOOL IniFile::WriteString( CSTR Section, CSTR KeyName, CSTR Text )
{
    return WritePrivateProfileString( Section, KeyName, TSTR(Text), Filename );
}

BOOL IniFile::WriteStringFmt( CSTR Section, CSTR KeyName, CSTR Fmt, ... )
{
    va_list va;

    va_start( va, Fmt );
    size_t dim = _bufSize/sizeof(TCHAR); // Buffer dimension (TCHAR count)
    _vstprintf_s( (TSTR)_buffer, dim, Fmt, va );
    va_end( va );

    return WritePrivateProfileString( Section, KeyName, (TSTR)_buffer, Filename );
    UNUSED( dim ); // if __GNUC__
}

BOOL IniFile::WriteStruct( CSTR Section, CSTR Key, PVOID pStruct, UINT Size )
{
    return WritePrivateProfileStruct( Section, Key, pStruct, Size, Filename );
}

BOOL IniFile::DeleteString( CSTR Section, CSTR KeyName )
{
    return WritePrivateProfileString( Section, KeyName, NULL, Filename );
}

BOOL IniFile::DeleteSection( CSTR Section )
{
    return WritePrivateProfileString( Section, NULL, NULL, Filename );
}

// Common chores..

BOOL IniFile::SaveWndRect( HWND hWnd, CSTR Section, CSTR Key )
{
    BOOL ok = IsWindow( hWnd );
    if ( ok )
    {
        RECT r; ok = GetWindowRect( hWnd, &r );
        if (ok) ok = WriteStruct( Section, Key, &r, sizeof(RECT) );

    }
    return ok;
}

BOOL IniFile::RestoreWndRect( HWND hWnd, CSTR Section, CSTR Key )
{
    BOOL ok = IsWindow( hWnd );
    if ( ok )
    {
        PRECT pr = (PRECT) GetStruct( Section, Key, sizeof(RECT) );
        ok = (pr != NULL);
        if ( ok )
        {
            // Constrain rect to stay on the visible screen.
            SIZE scrSiz = { SYSMET( CXSCREEN ), SYSMET( CYSCREEN ) };
            if ((pr->left < 0) || (pr->left > scrSiz.cx)) OffsetRect( pr, -pr->left, 0 );
            if ((pr->top < 0) || (pr->top > scrSiz.cy)) OffsetRect( pr, 0, -pr->top );

            AbsToDimRect( pr );
            ok = SetWindowPos( hWnd, NULL, pr->left, pr->top, pr->right, pr->bottom, SWP_NOZORDER );
        }
    }
    return ok;
}

// EOF