diff --git a/x64_dbg_bridge/Utf8Ini.h b/x64_dbg_bridge/Utf8Ini.h new file mode 100644 index 00000000..634682b6 --- /dev/null +++ b/x64_dbg_bridge/Utf8Ini.h @@ -0,0 +1,326 @@ +#ifndef _UTF8INI_H +#define _UTF8INI_H + +#include +#include +#include + +class Utf8Ini +{ +public: + /** + \brief Serialize to the INI file format. + */ + inline std::string Serialize() const + { + std::string output; + for(const auto & section : _sections) + { + if(output.length()) + appendLine(output, ""); + appendLine(output, makeSectionText(section.first)); + for(const auto & keyvalue : section.second) + if(keyvalue.first.length()) + appendLine(output, makeKeyValueText(keyvalue.first, keyvalue.second)); + } + return output; + } + + /** + \brief Deserialize from the INI file format. + \param data The INI data. + \param [out] errorLine The error line (only has a meaning when this function failed). + \return true if it succeeds, false if it fails. + */ + inline bool Deserialize(const std::string & data, int & errorLine) + { + //initialize + errorLine = 0; + Clear(); + + //read lines + std::vector lines; + std::string curLine; + for(auto ch : data) + { + switch(ch) + { + case '\r': + break; + case '\n': + lines.push_back(trim(curLine)); + curLine.clear(); + break; + default: + curLine += ch; + } + } + if(curLine.length()) + lines.push_back(trim(curLine)); + + //parse lines + std::string section = ""; + for(const auto & line : lines) + { + errorLine++; + switch(getLineType(line)) + { + case LineType::Invalid: + MessageBoxA(0, line.c_str(), "line", 0); + return false; + + case LineType::Comment: + case LineType::Empty: + continue; + + case LineType::KeyValue: + { + std::string key; + std::string value; + if(!section.length() || + !parseKeyValueLine(line, key, value) || + !SetValue(section, key, value)) + return false; + } + break; + + case LineType::Section: + if(!parseSectionLine(line, section)) + return false; + } + } + return true; + } + + /** + \brief Sets a value. This will overwrite older values. + \param section The section. Must have a length greater than one. + \param key The key. Must have a length greater than one. + \param value The value. Can be empty (effectively removing the value). + \return true if the value was set successfully, false otherwise. + */ + inline bool SetValue(const std::string & section, const std::string & key, const std::string & value) + { + auto trimmedSection = trim(section); + auto trimmedKey = trim(key); + if(!trimmedSection.length() || !trimmedKey.length()) + return false; + auto found = _sections.find(trimmedSection); + if(found != _sections.end()) + found->second[trimmedKey] = value; + else + { + KeyValueMap keyValueMap; + keyValueMap[trimmedKey] = value; + _sections[trimmedSection] = keyValueMap; + } + return true; + } + + /** + \brief Removes all key/value pairs from a section. + \param section The section to clear. + \return true if it succeeds, false otherwise. + */ + inline bool ClearSection(const std::string & section) + { + auto trimmedSection = trim(section); + if(!trimmedSection.length()) + return false; + auto found = _sections.find(trimmedSection); + if(found == _sections.end()) + return false; + _sections.erase(found); + return true; + } + + /** + \brief Removes all sections. + */ + inline void Clear() + { + _sections.clear(); + } + + /** + \brief Gets a value. + \param section The section. + \param key The key. + \param [in,out] value The value. + \return The value. Empty string when the value was not found or empty. + */ + inline std::string GetValue(const std::string & section, const std::string & key) const + { + auto trimmedSection = trim(section); + auto trimmedKey = trim(key); + if(!trimmedSection.length() || !trimmedKey.length()) + return ""; + auto sectionFound = _sections.find(trimmedSection); + if(sectionFound == _sections.end()) + return ""; + const auto & keyValueMap = sectionFound->second; + auto keyFound = keyValueMap.find(trimmedKey); + if(keyFound == keyValueMap.end()) + return ""; + return keyFound->second; + } + +private: + typedef std::map KeyValueMap; + std::map _sections; + + enum class LineType + { + Invalid, + Empty, + Section, + KeyValue, + Comment + }; + + static inline LineType getLineType(const std::string & line) + { + auto len = line.length(); + if(!len) + return LineType::Empty; + if(line[0] == '[' && line[len - 1] == ']') + return LineType::Section; + if(line[0] == ';') + return LineType::Comment; + if(line.find('=') != std::string::npos) + return LineType::KeyValue; + return LineType::Invalid; + } + + static inline std::string trim(const std::string & str) + { + auto len = str.length(); + if(!len) + return ""; + size_t pre = 0; + while(str[pre] == ' ') + pre++; + size_t post = 0; + while(str[len - post - 1] == ' ' && post < len) + post++; + auto sublen = len - post - pre; + return sublen > 0 ? str.substr(pre, len - post - pre) : ""; + } + + static inline bool parseKeyValueLine(const std::string & line, std::string & key, std::string & value) + { + auto pos = line.find('='); + key = trim(line.substr(0, pos)); + value = trim(line.substr(pos + 1)); + auto len = value.length(); + if(len && value[0] == '\"' && value[len - 1] == '\"') + value = unescapeValue(value); + return true; + } + + static inline bool parseSectionLine(const std::string & line, std::string & section) + { + section = trim(line.substr(1, line.length() - 2)); + return section.length() > 0; + } + + static inline void appendLine(std::string & output, const std::string & line) + { + if(output.length()) + output += "\r\n"; + output += line; + } + + static inline std::string makeSectionText(const std::string & section) + { + return "[" + section + "]"; + } + + static inline std::string makeKeyValueText(const std::string & key, const std::string & value) + { + return key + "=" + escapeValue(value); + } + + static inline bool needsEscaping(const std::string & value) + { + auto len = value.length(); + return len && (value[0] == ' ' || value[len - 1] == ' ' || + value.find('\n') != std::string::npos || + value.find('\"') != std::string::npos); + } + + static inline std::string escapeValue(const std::string & value) + { + if(!needsEscaping(value)) + return value; + std::string escaped = "\""; + for(auto ch : value) + { + switch(ch) + { + case '\"': + escaped += "\\\""; + break; + case '\\': + escaped += "\\\\"; + break; + case '\r': + escaped += "\\r"; + break; + case '\n': + escaped += "\\n"; + break; + case '\t': + escaped += "\\t"; + default: + escaped += ch; + } + } + return escaped + "\""; + } + + static inline std::string unescapeValue(const std::string & str) + { + std::string result; + bool bEscaped = false; + for(auto ch : str) + { + if(!bEscaped) + { + switch(ch) + { + case '\"': + break; + case '\\': + bEscaped = true; + break; + default: + result += ch; + } + } + else + { + switch(ch) + { + case 'r': + result += '\r'; + break; + case 'n': + result += '\n'; + break; + case 't': + result += '\t'; + break; + default: + result += ch; + } + bEscaped = false; + } + } + if(bEscaped) + result += '\\'; + return result; + } +}; + +#endif //_UTF8INI_H \ No newline at end of file diff --git a/x64_dbg_bridge/bridgemain.cpp b/x64_dbg_bridge/bridgemain.cpp index 3d405a22..85527813 100644 --- a/x64_dbg_bridge/bridgemain.cpp +++ b/x64_dbg_bridge/bridgemain.cpp @@ -7,10 +7,10 @@ #include "_global.h" #include "bridgemain.h" #include -#include "simpleini.h" +#include "Utf8Ini.h" static HINSTANCE hInst; - +static Utf8Ini settings; static wchar_t szIniFile[MAX_PATH] = L""; static CRITICAL_SECTION csIni; @@ -90,7 +90,19 @@ BRIDGE_IMPEXP const char* BridgeStart() { if(!_dbg_dbginit || !_gui_guiinit) return "\"_dbg_dbginit\" || \"_gui_guiinit\" was not loaded yet, call BridgeInit!"; + int errorLine = 0; + if(!BridgeSettingRead(&errorLine)) + { + static char error[256] = ""; + if(!errorLine) + strcpy_s(error, "Failed to read settings file from disk..."); + else + sprintf_s(error, "Error in settings file on line %d...", errorLine); + return error; + } _gui_guiinit(0, 0); //remove arguments + if(!BridgeSettingFlush()) + return "Failed to save settings!"; DeleteCriticalSection(&csIni); return 0; } @@ -117,19 +129,11 @@ BRIDGE_IMPEXP bool BridgeSettingGet(const char* section, const char* key, char* if(!section || !key || !value) return false; EnterCriticalSection(&csIni); - CSimpleIniA inifile(true, false, false); - bool success = false; - if(inifile.LoadFile(szIniFile) >= 0) - { - const char* szValue = inifile.GetValue(section, key); - if(szValue) - { - strcpy_s(value, MAX_SETTING_SIZE, szValue); - success = true; - } - } + auto foundValue = settings.GetValue(section, key); + strcpy_s(value, MAX_SETTING_SIZE, settings.GetValue(section, key).c_str()); + bool result = foundValue.length() > 0; LeaveCriticalSection(&csIni); - return success; + return result; } BRIDGE_IMPEXP bool BridgeSettingGetUint(const char* section, const char* key, duint* value) @@ -155,13 +159,12 @@ BRIDGE_IMPEXP bool BridgeSettingSet(const char* section, const char* key, const if(section) { EnterCriticalSection(&csIni); - CSimpleIniA inifile(true, false, false); - inifile.LoadFile(szIniFile); - if(!key || !value) //delete value/key when 0 - inifile.Delete(section, key, true); + if(!key) + success = settings.ClearSection(section); + else if(!value) + success = settings.SetValue(section, key, ""); else - inifile.SetValue(section, key, value); - success = inifile.SaveFile(szIniFile, false) >= 0; + success = settings.SetValue(section, key, value); LeaveCriticalSection(&csIni); } return success; @@ -180,6 +183,63 @@ BRIDGE_IMPEXP bool BridgeSettingSetUint(const char* section, const char* key, du return BridgeSettingSet(section, key, newvalue); } +BRIDGE_IMPEXP bool BridgeSettingFlush() +{ + EnterCriticalSection(&csIni); + std::string iniData = settings.Serialize(); + LeaveCriticalSection(&csIni); + bool success = false; + HANDLE hFile = CreateFileW(szIniFile, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); + if(hFile != INVALID_HANDLE_VALUE) + { + SetEndOfFile(hFile); + DWORD written = 0; + if(WriteFile(hFile, iniData.c_str(), (DWORD)iniData.length(), &written, nullptr)) + success = true; + CloseHandle(hFile); + } + return success; +} + +BRIDGE_IMPEXP bool BridgeSettingRead(int* errorLine) +{ + if(errorLine) + *errorLine = 0; + bool success = false; + std::string iniData; + HANDLE hFile = CreateFileW(szIniFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr); + if(hFile != INVALID_HANDLE_VALUE) + { + DWORD fileSize = GetFileSize(hFile, nullptr); + if(fileSize) + { + unsigned char utf8bom[] = { 0xEF, 0xBB, 0xBF }; + char* fileData = (char*)BridgeAlloc(sizeof(utf8bom) + fileSize + 1); + DWORD read = 0; + if(ReadFile(hFile, fileData, fileSize, &read, nullptr)) + { + success = true; + if(!memcmp(fileData, utf8bom, sizeof(utf8bom))) + iniData.assign(fileData + sizeof(utf8bom)); + else + iniData.assign(fileData); + } + BridgeFree(fileData); + } + CloseHandle(hFile); + } + if(success) //if we failed to read the file, the current settings are better than none at all + { + EnterCriticalSection(&csIni); + int errline = 0; + success = settings.Deserialize(iniData, errline); + if(errorLine) + *errorLine = errline; + LeaveCriticalSection(&csIni); + } + return success; +} + BRIDGE_IMPEXP int BridgeGetDbgVersion() { return DBG_VERSION; @@ -1144,4 +1204,4 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { hInst = hinstDLL; return TRUE; -} +} \ No newline at end of file diff --git a/x64_dbg_bridge/bridgemain.h b/x64_dbg_bridge/bridgemain.h index 67ea4784..36132332 100644 --- a/x64_dbg_bridge/bridgemain.h +++ b/x64_dbg_bridge/bridgemain.h @@ -48,6 +48,8 @@ BRIDGE_IMPEXP bool BridgeSettingGet(const char* section, const char* key, char* BRIDGE_IMPEXP bool BridgeSettingGetUint(const char* section, const char* key, duint* value); BRIDGE_IMPEXP bool BridgeSettingSet(const char* section, const char* key, const char* value); BRIDGE_IMPEXP bool BridgeSettingSetUint(const char* section, const char* key, duint value); +BRIDGE_IMPEXP bool BridgeSettingFlush(); +BRIDGE_IMPEXP bool BridgeSettingRead(int* errorLine); BRIDGE_IMPEXP int BridgeGetDbgVersion(); //Debugger defines diff --git a/x64_dbg_bridge/simpleini.h b/x64_dbg_bridge/simpleini.h deleted file mode 100644 index 3fddf404..00000000 --- a/x64_dbg_bridge/simpleini.h +++ /dev/null @@ -1,3705 +0,0 @@ -/** @mainpage - - -
Library SimpleIni -
File SimpleIni.h -
Author Brodie Thiesfield [code at jellycan dot com] -
Source https://github.com/brofield/simpleini -
Version 4.17 -
- - Jump to the @link CSimpleIniTempl CSimpleIni @endlink interface documentation. - - @section intro INTRODUCTION - - This component allows an INI-style configuration file to be used on both - Windows and Linux/Unix. It is fast, simple and source code using this - component will compile unchanged on either OS. - - - @section features FEATURES - - - MIT Licence allows free use in all software (including GPL and commercial) - - multi-platform (Windows 95/98/ME/NT/2K/XP/2003, Windows CE, Linux, Unix) - - loading and saving of INI-style configuration files - - configuration files can have any newline format on all platforms - - liberal acceptance of file format - - key/values with no section - - removal of whitespace around sections, keys and values - - support for multi-line values (values with embedded newline characters) - - optional support for multiple keys with the same name - - optional case-insensitive sections and keys (for ASCII characters only) - - saves files with sections and keys in the same order as they were loaded - - preserves comments on the file, section and keys where possible. - - supports both char or wchar_t programming interfaces - - supports both MBCS (system locale) and UTF-8 file encodings - - system locale does not need to be UTF-8 on Linux/Unix to load UTF-8 file - - support for non-ASCII characters in section, keys, values and comments - - support for non-standard character types or file encodings - via user-written converter classes - - support for adding/modifying values programmatically - - compiles cleanly in the following compilers: - - Windows/VC6 (warning level 3) - - Windows/VC.NET 2003 (warning level 4) - - Windows/VC 2005 (warning level 4) - - Linux/gcc (-Wall) - - - @section usage USAGE SUMMARY - - -# Define the appropriate symbol for the converter you wish to use and - include the SimpleIni.h header file. If no specific converter is defined - then the default converter is used. The default conversion mode uses - SI_CONVERT_WIN32 on Windows and SI_CONVERT_GENERIC on all other - platforms. If you are using ICU then SI_CONVERT_ICU is supported on all - platforms. - -# Declare an instance the appropriate class. Note that the following - definitions are just shortcuts for commonly used types. Other types - (PRUnichar, unsigned short, unsigned char) are also possible. - -
Interface Case-sensitive Load UTF-8 Load MBCS Typedef -
SI_CONVERT_GENERIC -
char No Yes Yes #1 CSimpleIniA -
char Yes Yes Yes CSimpleIniCaseA -
wchar_t No Yes Yes CSimpleIniW -
wchar_t Yes Yes Yes CSimpleIniCaseW -
SI_CONVERT_WIN32 -
char No No #2 Yes CSimpleIniA -
char Yes Yes Yes CSimpleIniCaseA -
wchar_t No Yes Yes CSimpleIniW -
wchar_t Yes Yes Yes CSimpleIniCaseW -
SI_CONVERT_ICU -
char No Yes Yes CSimpleIniA -
char Yes Yes Yes CSimpleIniCaseA -
UChar No Yes Yes CSimpleIniW -
UChar Yes Yes Yes CSimpleIniCaseW -
- #1 On Windows you are better to use CSimpleIniA with SI_CONVERT_WIN32.
- #2 Only affects Windows. On Windows this uses MBCS functions and - so may fold case incorrectly leading to uncertain results. - -# Call LoadData() or LoadFile() to load and parse the INI configuration file - -# Access and modify the data of the file using the following functions - -
GetAllSections Return all section names -
GetAllKeys Return all key names within a section -
GetAllValues Return all values within a section & key -
GetSection Return all key names and values in a section -
GetSectionSize Return the number of keys in a section -
GetValue Return a value for a section & key -
SetValue Add or update a value for a section & key -
Delete Remove a section, or a key from a section -
- -# Call Save() or SaveFile() to save the INI configuration data - - @section iostreams IO STREAMS - - SimpleIni supports reading from and writing to STL IO streams. Enable this - by defining SI_SUPPORT_IOSTREAMS before including the SimpleIni.h header - file. Ensure that if the streams are backed by a file (e.g. ifstream or - ofstream) then the flag ios_base::binary has been used when the file was - opened. - - @section multiline MULTI-LINE VALUES - - Values that span multiple lines are created using the following format. - - 
-        key = <<
-
-    Note the following:
-    - The text used for ENDTAG can be anything and is used to find
-      where the multi-line text ends.
-    - The newline after ENDTAG in the start tag, and the newline
-      before ENDTAG in the end tag is not included in the data value.
-    - The ending tag must be on it's own line with no whitespace before
-      or after it.
-    - The multi-line value is modified at load so that each line in the value
-      is delimited by a single '\\n' character on all platforms. At save time
-      it will be converted into the newline format used by the current
-      platform.
-
-    @section comments COMMENTS
-
-    Comments are preserved in the file within the following restrictions:
-    - Every file may have a single "file comment". It must start with the
-      first character in the file, and will end with the first non-comment
-      line in the file.
-    - Every section may have a single "section comment". It will start
-      with the first comment line following the file comment, or the last
-      data entry. It ends at the beginning of the section.
-    - Every key may have a single "key comment". This comment will start
-      with the first comment line following the section start, or the file
-      comment if there is no section name.
-    - Comments are set at the time that the file, section or key is first
-      created. The only way to modify a comment on a section or a key is to
-      delete that entry and recreate it with the new comment. There is no
-      way to change the file comment.
-
-    @section save SAVE ORDER
-
-    The sections and keys are written out in the same order as they were
-    read in from the file. Sections and keys added to the data after the
-    file has been loaded will be added to the end of the file when it is
-    written. There is no way to specify the location of a section or key
-    other than in first-created, first-saved order.
-
-    @section notes NOTES
-
-    - To load UTF-8 data on Windows 95, you need to use Microsoft Layer for
-      Unicode, or SI_CONVERT_GENERIC, or SI_CONVERT_ICU.
-    - When using SI_CONVERT_GENERIC, ConvertUTF.c must be compiled and linked.
-    - When using SI_CONVERT_ICU, ICU header files must be on the include
-      path and icuuc.lib must be linked in.
-    - To load a UTF-8 file on Windows AND expose it with SI_CHAR == char,
-      you should use SI_CONVERT_GENERIC.
-    - The collation (sorting) order used for sections and keys returned from
-      iterators is NOT DEFINED. If collation order of the text is important
-      then it should be done yourself by either supplying a replacement
-      SI_STRLESS class, or by sorting the strings external to this library.
-    - Usage of the  header on Windows can be disabled by defining
-      SI_NO_MBCS. This is defined automatically on Windows CE platforms.
-
-    @section contrib CONTRIBUTIONS
-
-    - 2010/05/03: Tobias Gehrig: added GetDoubleValue()
-
-    @section licence MIT LICENCE
-
-    The licence text below is the boilerplate "MIT Licence" used from:
-    http://www.opensource.org/licenses/mit-license.php
-
-    Copyright (c) 2006-2012, Brodie Thiesfield
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is furnished
-    to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-    FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef INCLUDED_SimpleIni_h
-#define INCLUDED_SimpleIni_h
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// Disable these warnings in MSVC:
-//  4127 "conditional expression is constant" as the conversion classes trigger
-//  it with the statement if (sizeof(SI_CHAR) == sizeof(char)). This test will
-//  be optimized away in a release build.
-//  4503 'insert' : decorated name length exceeded, name was truncated
-//  4702 "unreachable code" as the MS STL header causes it in release mode.
-//  Again, the code causing the warning will be cleaned up by the compiler.
-//  4786 "identifier truncated to 256 characters" as this is thrown hundreds
-//  of times VC6 as soon as STL is used.
-#ifdef _MSC_VER
-# pragma warning (push)
-# pragma warning (disable: 4127 4503 4702 4786)
-#endif
-
-#include 
-#include 
-#include 
-#include 
-#include 
-#include 
-
-#ifdef SI_SUPPORT_IOSTREAMS
-# include 
-#endif // SI_SUPPORT_IOSTREAMS
-
-#ifdef _DEBUG
-# ifndef assert
-#  include 
-# endif
-# define SI_ASSERT(x)   assert(x)
-#else
-# define SI_ASSERT(x)
-#endif
-
-enum SI_Error
-{
-    SI_OK       =  0,   //!< No error
-    SI_UPDATED  =  1,   //!< An existing value was updated
-    SI_INSERTED =  2,   //!< A new value was inserted
-
-    // note: test for any error with (retval < 0)
-    SI_FAIL     = -1,   //!< Generic failure
-    SI_NOMEM    = -2,   //!< Out of memory error
-    SI_FILE     = -3    //!< File error (see errno for detail error)
-};
-
-#define SI_UTF8_SIGNATURE     "\xEF\xBB\xBF"
-
-#ifdef _WIN32
-# define SI_NEWLINE_A   "\r\n"
-# define SI_NEWLINE_W   L"\r\n"
-#else // !_WIN32
-# define SI_NEWLINE_A   "\n"
-# define SI_NEWLINE_W   L"\n"
-#endif // _WIN32
-
-#if defined(SI_CONVERT_ICU)
-# include 
-#endif
-
-#if defined(_WIN32)
-# define SI_HAS_WIDE_FILE
-# define SI_WCHAR_T     wchar_t
-#elif defined(SI_CONVERT_ICU)
-# define SI_HAS_WIDE_FILE
-# define SI_WCHAR_T     UChar
-#endif
-
-
-// ---------------------------------------------------------------------------
-//                              MAIN TEMPLATE CLASS
-// ---------------------------------------------------------------------------
-
-/** Simple INI file reader.
-
-    This can be instantiated with the choice of unicode or native characterset,
-    and case sensitive or insensitive comparisons of section and key names.
-    The supported combinations are pre-defined with the following typedefs:
-
-    
-        
Interface   Case-sensitive  Typedef
-        
char        No              CSimpleIniA
-        
char        Yes             CSimpleIniCaseA
-        
wchar_t     No              CSimpleIniW
-        
wchar_t     Yes             CSimpleIniCaseW
-    

-
-    Note that using other types for the SI_CHAR is supported. For instance,
-    unsigned char, unsigned short, etc. Note that where the alternative type
-    is a different size to char/wchar_t you may need to supply new helper
-    classes for SI_STRLESS and SI_CONVERTER.
- */
-template
-class CSimpleIniTempl
-{
-public:
-    typedef SI_CHAR SI_CHAR_T;
-
-    /** key entry */
-    struct Entry
-    {
-        const SI_CHAR* pItem;
-        const SI_CHAR* pComment;
-        int             nOrder;
-
-        Entry(const SI_CHAR* a_pszItem = NULL, int a_nOrder = 0)
-            : pItem(a_pszItem)
-            , pComment(NULL)
-            , nOrder(a_nOrder)
-        { }
-        Entry(const SI_CHAR* a_pszItem, const SI_CHAR* a_pszComment, int a_nOrder)
-            : pItem(a_pszItem)
-            , pComment(a_pszComment)
-            , nOrder(a_nOrder)
-        { }
-        Entry(const Entry & rhs)
-        {
-            operator=(rhs);
-        }
-        Entry & operator=(const Entry & rhs)
-        {
-            pItem    = rhs.pItem;
-            pComment = rhs.pComment;
-            nOrder   = rhs.nOrder;
-            return *this;
-        }
-
-#if defined(_MSC_VER) && _MSC_VER <= 1200
-        /** STL of VC6 doesn't allow me to specify my own comparator for list::sort() */
-        bool operator<(const Entry & rhs) const
-        {
-            return LoadOrder()(*this, rhs);
-        }
-        bool operator>(const Entry & rhs) const
-        {
-            return LoadOrder()(rhs, *this);
-        }
-#endif
-
-        /** Strict less ordering by name of key only */
-        struct KeyOrder : std::binary_function
-        {
-            bool operator()(const Entry & lhs, const Entry & rhs) const
-            {
-                const static SI_STRLESS isLess = SI_STRLESS();
-                return isLess(lhs.pItem, rhs.pItem);
-            }
-        };
-
-        /** Strict less ordering by order, and then name of key */
-        struct LoadOrder : std::binary_function
-        {
-            bool operator()(const Entry & lhs, const Entry & rhs) const
-            {
-                if(lhs.nOrder != rhs.nOrder)
-                {
-                    return lhs.nOrder < rhs.nOrder;
-                }
-                return KeyOrder()(lhs.pItem, rhs.pItem);
-            }
-        };
-    };
-
-    /** map keys to values */
-    typedef std::multimap TKeyVal;
-
-    /** map sections to key/value map */
-    typedef std::map TSection;
-
-    /** set of dependent string pointers. Note that these pointers are
-        dependent on memory owned by CSimpleIni.
-    */
-    typedef std::list TNamesDepend;
-
-    /** interface definition for the OutputWriter object to pass to Save()
-        in order to output the INI file data.
-    */
-    class OutputWriter
-    {
-    public:
-        OutputWriter() { }
-        virtual ~OutputWriter() { }
-        virtual void Write(const char* a_pBuf) = 0;
-    private:
-        OutputWriter(const OutputWriter &);             // disable
-        OutputWriter & operator=(const OutputWriter &); // disable
-    };
-
-    /** OutputWriter class to write the INI data to a file */
-    class FileWriter : public OutputWriter
-    {
-        FILE* m_file;
-    public:
-        FileWriter(FILE* a_file) : m_file(a_file) { }
-        void Write(const char* a_pBuf)
-        {
-            fputs(a_pBuf, m_file);
-        }
-    private:
-        FileWriter(const FileWriter &);             // disable
-        FileWriter & operator=(const FileWriter &); // disable
-    };
-
-    /** OutputWriter class to write the INI data to a string */
-    class StringWriter : public OutputWriter
-    {
-        std::string & m_string;
-    public:
-        StringWriter(std::string & a_string) : m_string(a_string) { }
-        void Write(const char* a_pBuf)
-        {
-            m_string.append(a_pBuf);
-        }
-    private:
-        StringWriter(const StringWriter &);             // disable
-        StringWriter & operator=(const StringWriter &); // disable
-    };
-
-#ifdef SI_SUPPORT_IOSTREAMS
-    /** OutputWriter class to write the INI data to an ostream */
-    class StreamWriter : public OutputWriter
-    {
-        std::ostream & m_ostream;
-    public:
-        StreamWriter(std::ostream & a_ostream) : m_ostream(a_ostream) { }
-        void Write(const char* a_pBuf)
-        {
-            m_ostream << a_pBuf;
-        }
-    private:
-        StreamWriter(const StreamWriter &);             // disable
-        StreamWriter & operator=(const StreamWriter &); // disable
-    };
-#endif // SI_SUPPORT_IOSTREAMS
-
-    /** Characterset conversion utility class to convert strings to the
-        same format as is used for the storage.
-    */
-    class Converter : private SI_CONVERTER
-    {
-    public:
-        Converter(bool a_bStoreIsUtf8) : SI_CONVERTER(a_bStoreIsUtf8)
-        {
-            m_scratch.resize(1024);
-        }
-        Converter(const Converter & rhs)
-        {
-            operator=(rhs);
-        }
-        Converter & operator=(const Converter & rhs)
-        {
-            m_scratch = rhs.m_scratch;
-            return *this;
-        }
-        bool ConvertToStore(const SI_CHAR* a_pszString)
-        {
-            size_t uLen = SI_CONVERTER::SizeToStore(a_pszString);
-            if(uLen == (size_t)(-1))
-            {
-                return false;
-            }
-            while(uLen > m_scratch.size())
-            {
-                m_scratch.resize(m_scratch.size() * 2);
-            }
-            return SI_CONVERTER::ConvertToStore(
-                       a_pszString,
-                       const_cast(m_scratch.data()),
-                       m_scratch.size());
-        }
-        const char* Data()
-        {
-            return m_scratch.data();
-        }
-    private:
-        std::string m_scratch;
-    };
-
-public:
-    /*-----------------------------------------------------------------------*/
-
-    /** Default constructor.
-
-        @param a_bIsUtf8     See the method SetUnicode() for details.
-        @param a_bMultiKey   See the method SetMultiKey() for details.
-        @param a_bMultiLine  See the method SetMultiLine() for details.
-     */
-    CSimpleIniTempl(
-        bool a_bIsUtf8    = false,
-        bool a_bMultiKey  = false,
-        bool a_bMultiLine = false
-    );
-
-    /** Destructor */
-    ~CSimpleIniTempl();
-
-    /** Deallocate all memory stored by this object */
-    void Reset();
-
-    /** Has any data been loaded */
-    bool IsEmpty() const
-    {
-        return m_data.empty();
-    }
-
-    /*-----------------------------------------------------------------------*/
-    /** @{ @name Settings */
-
-    /** Set the storage format of the INI data. This affects both the loading
-        and saving of the INI data using all of the Load/Save API functions.
-        This value cannot be changed after any INI data has been loaded.
-
-        If the file is not set to Unicode (UTF-8), then the data encoding is
-        assumed to be the OS native encoding. This encoding is the system
-        locale on Linux/Unix and the legacy MBCS encoding on Windows NT/2K/XP.
-        If the storage format is set to Unicode then the file will be loaded
-        as UTF-8 encoded data regardless of the native file encoding. If
-        SI_CHAR == char then all of the char* parameters take and return UTF-8
-        encoded data regardless of the system locale.
-
-        \param a_bIsUtf8     Assume UTF-8 encoding for the source?
-     */
-    void SetUnicode(bool a_bIsUtf8 = true)
-    {
-        if(!m_pData) m_bStoreIsUtf8 = a_bIsUtf8;
-    }
-
-    /** Get the storage format of the INI data. */
-    bool IsUnicode() const
-    {
-        return m_bStoreIsUtf8;
-    }
-
-    /** Should multiple identical keys be permitted in the file. If set to false
-        then the last value encountered will be used as the value of the key.
-        If set to true, then all values will be available to be queried. For
-        example, with the following input:
-
-        
-        [section]
-        test=value1
-        test=value2
-        

-
-        Then with SetMultiKey(true), both of the values "value1" and "value2"
-        will be returned for the key test. If SetMultiKey(false) is used, then
-        the value for "test" will only be "value2". This value may be changed
-        at any time.
-
-        \param a_bAllowMultiKey  Allow multi-keys in the source?
-     */
-    void SetMultiKey(bool a_bAllowMultiKey = true)
-    {
-        m_bAllowMultiKey = a_bAllowMultiKey;
-    }
-
-    /** Get the storage format of the INI data. */
-    bool IsMultiKey() const
-    {
-        return m_bAllowMultiKey;
-    }
-
-    /** Should data values be permitted to span multiple lines in the file. If
-        set to false then the multi-line construct <<
-            SI_CHAR     FORMAT
-            char        same format as when loaded (MBCS or UTF-8)
-            wchar_t     UTF-8
-            other       UTF-8
-        
-
-        Note that comments from the original data is preserved as per the
-        documentation on comments. The order of the sections and values
-        from the original file will be preserved.
-
-        Any data prepended or appended to the output device must use the the
-        same format (MBCS or UTF-8). You may use the GetConverter() method to
-        convert text to the correct format regardless of the output format
-        being used by SimpleIni.
-
-        To add a BOM to UTF-8 data, write it out manually at the very beginning
-        like is done in SaveFile when a_bUseBOM is true.
-
-        @param a_oOutput    Output writer to write the data to.
-
-        @param a_bAddSignature  Prepend the UTF-8 BOM if the output data is in
-                            UTF-8 format. If it is not UTF-8 then this value is
-                            ignored. Do not set this to true if anything has
-                            already been written to the OutputWriter.
-
-        @return SI_Error    See error definitions
-     */
-    SI_Error Save(
-        OutputWriter  & a_oOutput,
-        bool            a_bAddSignature = false
-    ) const;
-
-#ifdef SI_SUPPORT_IOSTREAMS
-    /** Save the INI data to an ostream. See Save() for details.
-
-        @param a_ostream    String to have the INI data appended to.
-
-        @param a_bAddSignature  Prepend the UTF-8 BOM if the output data is in
-                            UTF-8 format. If it is not UTF-8 then this value is
-                            ignored. Do not set this to true if anything has
-                            already been written to the stream.
-
-        @return SI_Error    See error definitions
-     */
-    SI_Error Save(
-        std::ostream  & a_ostream,
-        bool            a_bAddSignature = false
-    ) const
-    {
-        StreamWriter writer(a_ostream);
-        return Save(writer, a_bAddSignature);
-    }
-#endif // SI_SUPPORT_IOSTREAMS
-
-    /** Append the INI data to a string. See Save() for details.
-
-        @param a_sBuffer    String to have the INI data appended to.
-
-        @param a_bAddSignature  Prepend the UTF-8 BOM if the output data is in
-                            UTF-8 format. If it is not UTF-8 then this value is
-                            ignored. Do not set this to true if anything has
-                            already been written to the string.
-
-        @return SI_Error    See error definitions
-     */
-    SI_Error Save(
-        std::string  &  a_sBuffer,
-        bool            a_bAddSignature = false
-    ) const
-    {
-        StringWriter writer(a_sBuffer);
-        return Save(writer, a_bAddSignature);
-    }
-
-    /*-----------------------------------------------------------------------*/
-    /** @}
-        @{ @name Accessing INI Data */
-
-    /** Retrieve all section names. The list is returned as an STL vector of
-        names and can be iterated or searched as necessary. Note that the
-        sort order of the returned strings is NOT DEFINED. You can sort
-        the names into the load order if desired. Search this file for ".sort"
-        for an example.
-
-        NOTE! This structure contains only pointers to strings. The actual
-        string data is stored in memory owned by CSimpleIni. Ensure that the
-        CSimpleIni object is not destroyed or Reset() while these pointers
-        are in use!
-
-        @param a_names          Vector that will receive all of the section
-                                 names. See note above!
-     */
-    void GetAllSections(
-        TNamesDepend & a_names
-    ) const;
-
-    /** Retrieve all unique key names in a section. The sort order of the
-        returned strings is NOT DEFINED. You can sort the names into the load
-        order if desired. Search this file for ".sort" for an example. Only
-        unique key names are returned.
-
-        NOTE! This structure contains only pointers to strings. The actual
-        string data is stored in memory owned by CSimpleIni. Ensure that the
-        CSimpleIni object is not destroyed or Reset() while these strings
-        are in use!
-
-        @param a_pSection       Section to request data for
-        @param a_names          List that will receive all of the key
-                                 names. See note above!
-
-        @return true            Section was found.
-        @return false           Matching section was not found.
-     */
-    bool GetAllKeys(
-        const SI_CHAR* a_pSection,
-        TNamesDepend  & a_names
-    ) const;
-
-    /** Retrieve all values for a specific key. This method can be used when
-        multiple keys are both enabled and disabled. Note that the sort order
-        of the returned strings is NOT DEFINED. You can sort the names into
-        the load order if desired. Search this file for ".sort" for an example.
-
-        NOTE! The returned values are pointers to string data stored in memory
-        owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed
-        or Reset while you are using this pointer!
-
-        @param a_pSection       Section to search
-        @param a_pKey           Key to search for
-        @param a_values         List to return if the key is not found
-
-        @return true            Key was found.
-        @return false           Matching section/key was not found.
-     */
-    bool GetAllValues(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        TNamesDepend  & a_values
-    ) const;
-
-    /** Query the number of keys in a specific section. Note that if multiple
-        keys are enabled, then this value may be different to the number of
-        keys returned by GetAllKeys.
-
-        @param a_pSection       Section to request data for
-
-        @return -1              Section does not exist in the file
-        @return >=0             Number of keys in the section
-     */
-    int GetSectionSize(
-        const SI_CHAR* a_pSection
-    ) const;
-
-    /** Retrieve all key and value pairs for a section. The data is returned
-        as a pointer to an STL map and can be iterated or searched as
-        desired. Note that multiple entries for the same key may exist when
-        multiple keys have been enabled.
-
-        NOTE! This structure contains only pointers to strings. The actual
-        string data is stored in memory owned by CSimpleIni. Ensure that the
-        CSimpleIni object is not destroyed or Reset() while these strings
-        are in use!
-
-        @param a_pSection       Name of the section to return
-        @return boolean         Was a section matching the supplied
-                                name found.
-     */
-    const TKeyVal* GetSection(
-        const SI_CHAR* a_pSection
-    ) const;
-
-    /** Retrieve the value for a specific key. If multiple keys are enabled
-        (see SetMultiKey) then only the first value associated with that key
-        will be returned, see GetAllValues for getting all values with multikey.
-
-        NOTE! The returned value is a pointer to string data stored in memory
-        owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed
-        or Reset while you are using this pointer!
-
-        @param a_pSection       Section to search
-        @param a_pKey           Key to search for
-        @param a_pDefault       Value to return if the key is not found
-        @param a_pHasMultiple   Optionally receive notification of if there are
-                                multiple entries for this key.
-
-        @return a_pDefault      Key was not found in the section
-        @return other           Value of the key
-     */
-    const SI_CHAR* GetValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        const SI_CHAR* a_pDefault     = NULL,
-        bool*           a_pHasMultiple = NULL
-    ) const;
-
-    /** Retrieve a numeric value for a specific key. If multiple keys are enabled
-        (see SetMultiKey) then only the first value associated with that key
-        will be returned, see GetAllValues for getting all values with multikey.
-
-        @param a_pSection       Section to search
-        @param a_pKey           Key to search for
-        @param a_nDefault       Value to return if the key is not found
-        @param a_pHasMultiple   Optionally receive notification of if there are
-                                multiple entries for this key.
-
-        @return a_nDefault      Key was not found in the section
-        @return other           Value of the key
-     */
-    long GetLongValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        long            a_nDefault     = 0,
-        bool*           a_pHasMultiple = NULL
-    ) const;
-
-    /** Retrieve a numeric value for a specific key. If multiple keys are enabled
-        (see SetMultiKey) then only the first value associated with that key
-        will be returned, see GetAllValues for getting all values with multikey.
-
-        @param a_pSection       Section to search
-        @param a_pKey           Key to search for
-        @param a_nDefault       Value to return if the key is not found
-        @param a_pHasMultiple   Optionally receive notification of if there are
-                                multiple entries for this key.
-
-        @return a_nDefault      Key was not found in the section
-        @return other           Value of the key
-     */
-    double GetDoubleValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        double          a_nDefault     = 0,
-        bool*           a_pHasMultiple = NULL
-    ) const;
-
-    /** Retrieve a boolean value for a specific key. If multiple keys are enabled
-        (see SetMultiKey) then only the first value associated with that key
-        will be returned, see GetAllValues for getting all values with multikey.
-
-        Strings starting with "t", "y", "on" or "1" are returned as logically true.
-        Strings starting with "f", "n", "of" or "0" are returned as logically false.
-        For all other values the default is returned. Character comparisons are
-        case-insensitive.
-
-        @param a_pSection       Section to search
-        @param a_pKey           Key to search for
-        @param a_bDefault       Value to return if the key is not found
-        @param a_pHasMultiple   Optionally receive notification of if there are
-                                multiple entries for this key.
-
-        @return a_nDefault      Key was not found in the section
-        @return other           Value of the key
-     */
-    bool GetBoolValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        bool            a_bDefault     = false,
-        bool*           a_pHasMultiple = NULL
-    ) const;
-
-    /** Add or update a section or value. This will always insert
-        when multiple keys are enabled.
-
-        @param a_pSection   Section to add or update
-        @param a_pKey       Key to add or update. Set to NULL to
-                            create an empty section.
-        @param a_pValue     Value to set. Set to NULL to create an
-                            empty section.
-        @param a_pComment   Comment to be associated with the section or the
-                            key. If a_pKey is NULL then it will be associated
-                            with the section, otherwise the key. Note that a
-                            comment may be set ONLY when the section or key is
-                            first created (i.e. when this function returns the
-                            value SI_INSERTED). If you wish to create a section
-                            with a comment then you need to create the section
-                            separately to the key. The comment string must be
-                            in full comment form already (have a comment
-                            character starting every line).
-        @param a_bForceReplace  Should all existing values in a multi-key INI
-                            file be replaced with this entry. This option has
-                            no effect if not using multi-key files. The
-                            difference between Delete/SetValue and SetValue
-                            with a_bForceReplace = true, is that the load
-                            order and comment will be preserved this way.
-
-        @return SI_Error    See error definitions
-        @return SI_UPDATED  Value was updated
-        @return SI_INSERTED Value was inserted
-     */
-    SI_Error SetValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        const SI_CHAR* a_pValue,
-        const SI_CHAR* a_pComment      = NULL,
-        bool            a_bForceReplace = false
-    )
-    {
-        return AddEntry(a_pSection, a_pKey, a_pValue, a_pComment, a_bForceReplace, true);
-    }
-
-    /** Add or update a numeric value. This will always insert
-        when multiple keys are enabled.
-
-        @param a_pSection   Section to add or update
-        @param a_pKey       Key to add or update.
-        @param a_nValue     Value to set.
-        @param a_pComment   Comment to be associated with the key. See the
-                            notes on SetValue() for comments.
-        @param a_bUseHex    By default the value will be written to the file
-                            in decimal format. Set this to true to write it
-                            as hexadecimal.
-        @param a_bForceReplace  Should all existing values in a multi-key INI
-                            file be replaced with this entry. This option has
-                            no effect if not using multi-key files. The
-                            difference between Delete/SetLongValue and
-                            SetLongValue with a_bForceReplace = true, is that
-                            the load order and comment will be preserved this
-                            way.
-
-        @return SI_Error    See error definitions
-        @return SI_UPDATED  Value was updated
-        @return SI_INSERTED Value was inserted
-     */
-    SI_Error SetLongValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        long            a_nValue,
-        const SI_CHAR* a_pComment      = NULL,
-        bool            a_bUseHex       = false,
-        bool            a_bForceReplace = false
-    );
-
-    /** Add or update a double value. This will always insert
-        when multiple keys are enabled.
-
-        @param a_pSection   Section to add or update
-        @param a_pKey       Key to add or update.
-        @param a_nValue     Value to set.
-        @param a_pComment   Comment to be associated with the key. See the
-                            notes on SetValue() for comments.
-        @param a_bForceReplace  Should all existing values in a multi-key INI
-                            file be replaced with this entry. This option has
-                            no effect if not using multi-key files. The
-                            difference between Delete/SetDoubleValue and
-                            SetDoubleValue with a_bForceReplace = true, is that
-                            the load order and comment will be preserved this
-                            way.
-
-        @return SI_Error    See error definitions
-        @return SI_UPDATED  Value was updated
-        @return SI_INSERTED Value was inserted
-     */
-    SI_Error SetDoubleValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        double          a_nValue,
-        const SI_CHAR* a_pComment      = NULL,
-        bool            a_bForceReplace = false
-    );
-
-    /** Add or update a boolean value. This will always insert
-        when multiple keys are enabled.
-
-        @param a_pSection   Section to add or update
-        @param a_pKey       Key to add or update.
-        @param a_bValue     Value to set.
-        @param a_pComment   Comment to be associated with the key. See the
-                            notes on SetValue() for comments.
-        @param a_bForceReplace  Should all existing values in a multi-key INI
-                            file be replaced with this entry. This option has
-                            no effect if not using multi-key files. The
-                            difference between Delete/SetBoolValue and
-                            SetBoolValue with a_bForceReplace = true, is that
-                            the load order and comment will be preserved this
-                            way.
-
-        @return SI_Error    See error definitions
-        @return SI_UPDATED  Value was updated
-        @return SI_INSERTED Value was inserted
-     */
-    SI_Error SetBoolValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        bool            a_bValue,
-        const SI_CHAR* a_pComment      = NULL,
-        bool            a_bForceReplace = false
-    );
-
-    /** Delete an entire section, or a key from a section. Note that the
-        data returned by GetSection is invalid and must not be used after
-        anything has been deleted from that section using this method.
-        Note when multiple keys is enabled, this will delete all keys with
-        that name; to selectively delete individual key/values, use
-        DeleteValue.
-
-        @param a_pSection       Section to delete key from, or if
-                                a_pKey is NULL, the section to remove.
-        @param a_pKey           Key to remove from the section. Set to
-                                NULL to remove the entire section.
-        @param a_bRemoveEmpty   If the section is empty after this key has
-                                been deleted, should the empty section be
-                                removed?
-
-        @return true            Key or section was deleted.
-        @return false           Key or section was not found.
-     */
-    bool Delete(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        bool            a_bRemoveEmpty = false
-    );
-
-    /** Delete an entire section, or a key from a section. If value is
-        provided, only remove keys with the value. Note that the data
-        returned by GetSection is invalid and must not be used after
-        anything has been deleted from that section using this method.
-        Note when multiple keys is enabled, all keys with the value will
-        be deleted.
-
-        @param a_pSection       Section to delete key from, or if
-                                a_pKey is NULL, the section to remove.
-        @param a_pKey           Key to remove from the section. Set to
-                                NULL to remove the entire section.
-        @param a_pValue         Value of key to remove from the section.
-                                Set to NULL to remove all keys.
-        @param a_bRemoveEmpty   If the section is empty after this key has
-                                been deleted, should the empty section be
-                                removed?
-
-        @return true            Key/value or section was deleted.
-        @return false           Key/value or section was not found.
-     */
-    bool DeleteValue(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        const SI_CHAR* a_pValue,
-        bool            a_bRemoveEmpty = false
-    );
-
-    /*-----------------------------------------------------------------------*/
-    /** @}
-        @{ @name Converter */
-
-    /** Return a conversion object to convert text to the same encoding
-        as is used by the Save(), SaveFile() and SaveString() functions.
-        Use this to prepare the strings that you wish to append or prepend
-        to the output INI data.
-     */
-    Converter GetConverter() const
-    {
-        return Converter(m_bStoreIsUtf8);
-    }
-
-    /*-----------------------------------------------------------------------*/
-    /** @} */
-
-private:
-    // copying is not permitted
-    CSimpleIniTempl(const CSimpleIniTempl &); // disabled
-    CSimpleIniTempl & operator=(const CSimpleIniTempl &); // disabled
-
-    /** Parse the data looking for a file comment and store it if found.
-    */
-    SI_Error FindFileComment(
-        SI_CHAR*   &   a_pData,
-        bool            a_bCopyStrings
-    );
-
-    /** Parse the data looking for the next valid entry. The memory pointed to
-        by a_pData is modified by inserting NULL characters. The pointer is
-        updated to the current location in the block of text.
-    */
-    bool FindEntry(
-        SI_CHAR* & a_pData,
-        const SI_CHAR* & a_pSection,
-        const SI_CHAR* & a_pKey,
-        const SI_CHAR* & a_pVal,
-        const SI_CHAR* & a_pComment
-    ) const;
-
-    /** Add the section/key/value to our data.
-
-        @param a_pSection   Section name. Sections will be created if they
-                            don't already exist.
-        @param a_pKey       Key name. May be NULL to create an empty section.
-                            Existing entries will be updated. New entries will
-                            be created.
-        @param a_pValue     Value for the key.
-        @param a_pComment   Comment to be associated with the section or the
-                            key. If a_pKey is NULL then it will be associated
-                            with the section, otherwise the key. This must be
-                            a string in full comment form already (have a
-                            comment character starting every line).
-        @param a_bForceReplace  Should all existing values in a multi-key INI
-                            file be replaced with this entry. This option has
-                            no effect if not using multi-key files. The
-                            difference between Delete/AddEntry and AddEntry
-                            with a_bForceReplace = true, is that the load
-                            order and comment will be preserved this way.
-        @param a_bCopyStrings   Should copies of the strings be made or not.
-                            If false then the pointers will be used as is.
-    */
-    SI_Error AddEntry(
-        const SI_CHAR* a_pSection,
-        const SI_CHAR* a_pKey,
-        const SI_CHAR* a_pValue,
-        const SI_CHAR* a_pComment,
-        bool            a_bForceReplace,
-        bool            a_bCopyStrings
-    );
-
-    /** Is the supplied character a whitespace character? */
-    inline bool IsSpace(SI_CHAR ch) const
-    {
-        return (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n');
-    }
-
-    /** Does the supplied character start a comment line? */
-    inline bool IsComment(SI_CHAR ch) const
-    {
-        return (ch == ';' || ch == '#');
-    }
-
-
-    /** Skip over a newline character (or characters) for either DOS or UNIX */
-    inline void SkipNewLine(SI_CHAR* & a_pData) const
-    {
-        a_pData += (*a_pData == '\r' && *(a_pData + 1) == '\n') ? 2 : 1;
-    }
-
-    /** Make a copy of the supplied string, replacing the original pointer */
-    SI_Error CopyString(const SI_CHAR* & a_pString);
-
-    /** Delete a string from the copied strings buffer if necessary */
-    void DeleteString(const SI_CHAR* a_pString);
-
-    /** Internal use of our string comparison function */
-    bool IsLess(const SI_CHAR* a_pLeft, const SI_CHAR* a_pRight) const
-    {
-        const static SI_STRLESS isLess = SI_STRLESS();
-        return isLess(a_pLeft, a_pRight);
-    }
-
-    bool IsMultiLineTag(const SI_CHAR* a_pData) const;
-    bool IsMultiLineData(const SI_CHAR* a_pData) const;
-    bool LoadMultiLineText(
-        SI_CHAR*     &     a_pData,
-        const SI_CHAR*  &  a_pVal,
-        const SI_CHAR*      a_pTagName,
-        bool                a_bAllowBlankLinesInComment = false
-    ) const;
-    bool IsNewLineChar(SI_CHAR a_c) const;
-
-    bool OutputMultiLineText(
-        OutputWriter  & a_oOutput,
-        Converter   &   a_oConverter,
-        const SI_CHAR* a_pText
-    ) const;
-
-private:
-    /** Copy of the INI file data in our character format. This will be
-        modified when parsed to have NULL characters added after all
-        interesting string entries. All of the string pointers to sections,
-        keys and values point into this block of memory.
-     */
-    SI_CHAR* m_pData;
-
-    /** Length of the data that we have stored. Used when deleting strings
-        to determine if the string is stored here or in the allocated string
-        buffer.
-     */
-    size_t m_uDataLen;
-
-    /** File comment for this data, if one exists. */
-    const SI_CHAR* m_pFileComment;
-
-    /** Parsed INI data. Section -> (Key -> Value). */
-    TSection m_data;
-
-    /** This vector stores allocated memory for copies of strings that have
-        been supplied after the file load. It will be empty unless SetValue()
-        has been called.
-     */
-    TNamesDepend m_strings;
-
-    /** Is the format of our datafile UTF-8 or MBCS? */
-    bool m_bStoreIsUtf8;
-
-    /** Are multiple values permitted for the same key? */
-    bool m_bAllowMultiKey;
-
-    /** Are data values permitted to span multiple lines? */
-    bool m_bAllowMultiLine;
-
-    /** Should spaces be written out surrounding the equals sign? */
-    bool m_bSpaces;
-
-    /** Next order value, used to ensure sections and keys are output in the
-        same order that they are loaded/added.
-     */
-    int m_nOrder;
-};
-
-// ---------------------------------------------------------------------------
-//                                  IMPLEMENTATION
-// ---------------------------------------------------------------------------
-
-template
-CSimpleIniTempl::CSimpleIniTempl(
-    bool a_bIsUtf8,
-    bool a_bAllowMultiKey,
-    bool a_bAllowMultiLine
-)
-    : m_pData(0)
-    , m_uDataLen(0)
-    , m_pFileComment(NULL)
-    , m_bStoreIsUtf8(a_bIsUtf8)
-    , m_bAllowMultiKey(a_bAllowMultiKey)
-    , m_bAllowMultiLine(a_bAllowMultiLine)
-    , m_bSpaces(false)
-    , m_nOrder(0)
-{ }
-
-template
-CSimpleIniTempl::~CSimpleIniTempl()
-{
-    Reset();
-}
-
-template
-void
-CSimpleIniTempl::Reset()
-{
-    // remove all data
-    delete[] m_pData;
-    m_pData = NULL;
-    m_uDataLen = 0;
-    m_pFileComment = NULL;
-    if(!m_data.empty())
-    {
-        m_data.erase(m_data.begin(), m_data.end());
-    }
-
-    // remove all strings
-    if(!m_strings.empty())
-    {
-        typename TNamesDepend::iterator i = m_strings.begin();
-        for(; i != m_strings.end(); ++i)
-        {
-            delete[] const_cast(i->pItem);
-        }
-        m_strings.erase(m_strings.begin(), m_strings.end());
-    }
-}
-
-template
-SI_Error
-CSimpleIniTempl::LoadFile(
-    const char* a_pszFile
-)
-{
-    FILE* fp = NULL;
-#if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
-    fopen_s(&fp, a_pszFile, "rb");
-#else // !__STDC_WANT_SECURE_LIB__
-    fp = fopen(a_pszFile, "rb");
-#endif // __STDC_WANT_SECURE_LIB__
-    if(!fp)
-    {
-        return SI_FILE;
-    }
-    SI_Error rc = LoadFile(fp);
-    fclose(fp);
-    return rc;
-}
-
-#ifdef SI_HAS_WIDE_FILE
-template
-SI_Error
-CSimpleIniTempl::LoadFile(
-    const SI_WCHAR_T* a_pwszFile
-)
-{
-#ifdef _WIN32
-    FILE* fp = NULL;
-#if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
-    _wfopen_s(&fp, a_pwszFile, L"rb");
-#else // !__STDC_WANT_SECURE_LIB__
-    fp = _wfopen(a_pwszFile, L"rb");
-#endif // __STDC_WANT_SECURE_LIB__
-    if(!fp) return SI_FILE;
-    SI_Error rc = LoadFile(fp);
-    fclose(fp);
-    return rc;
-#else // !_WIN32 (therefore SI_CONVERT_ICU)
-    char szFile[256];
-    u_austrncpy(szFile, a_pwszFile, sizeof(szFile));
-    return LoadFile(szFile);
-#endif // _WIN32
-}
-#endif // SI_HAS_WIDE_FILE
-
-template
-SI_Error
-CSimpleIniTempl::LoadFile(
-    FILE* a_fpFile
-)
-{
-    // load the raw file data
-    int retval = fseek(a_fpFile, 0, SEEK_END);
-    if(retval != 0)
-    {
-        return SI_FILE;
-    }
-    long lSize = ftell(a_fpFile);
-    if(lSize < 0)
-    {
-        return SI_FILE;
-    }
-    if(lSize == 0)
-    {
-        return SI_OK;
-    }
-
-    // allocate and ensure NULL terminated
-    char* pData = new char[lSize + 1];
-    if(!pData)
-    {
-        return SI_NOMEM;
-    }
-    pData[lSize] = 0;
-
-    // load data into buffer
-    fseek(a_fpFile, 0, SEEK_SET);
-    size_t uRead = fread(pData, sizeof(char), lSize, a_fpFile);
-    if(uRead != (size_t) lSize)
-    {
-        delete[] pData;
-        return SI_FILE;
-    }
-
-    // convert the raw data to unicode
-    SI_Error rc = LoadData(pData, uRead);
-    delete[] pData;
-    return rc;
-}
-
-template
-SI_Error
-CSimpleIniTempl::LoadData(
-    const char*     a_pData,
-    size_t          a_uDataLen
-)
-{
-    SI_CONVERTER converter(m_bStoreIsUtf8);
-
-    if(a_uDataLen == 0)
-    {
-        return SI_OK;
-    }
-
-    // consume the UTF-8 BOM if it exists
-    if(m_bStoreIsUtf8 && a_uDataLen >= 3)
-    {
-        if(memcmp(a_pData, SI_UTF8_SIGNATURE, 3) == 0)
-        {
-            a_pData    += 3;
-            a_uDataLen -= 3;
-        }
-    }
-
-    // determine the length of the converted data
-    size_t uLen = converter.SizeFromStore(a_pData, a_uDataLen);
-    if(uLen == (size_t)(-1))
-    {
-        return SI_FAIL;
-    }
-
-    // allocate memory for the data, ensure that there is a NULL
-    // terminator wherever the converted data ends
-    SI_CHAR* pData = new SI_CHAR[uLen + 1];
-    if(!pData)
-    {
-        return SI_NOMEM;
-    }
-    memset(pData, 0, sizeof(SI_CHAR) * (uLen + 1));
-
-    // convert the data
-    if(!converter.ConvertFromStore(a_pData, a_uDataLen, pData, uLen))
-    {
-        delete[] pData;
-        return SI_FAIL;
-    }
-
-    // parse it
-    const static SI_CHAR empty = 0;
-    SI_CHAR* pWork = pData;
-    const SI_CHAR* pSection = ∅
-    const SI_CHAR* pItem = NULL;
-    const SI_CHAR* pVal = NULL;
-    const SI_CHAR* pComment = NULL;
-
-    // We copy the strings if we are loading data into this class when we
-    // already have stored some.
-    bool bCopyStrings = (m_pData != NULL);
-
-    // find a file comment if it exists, this is a comment that starts at the
-    // beginning of the file and continues until the first blank line.
-    SI_Error rc = FindFileComment(pWork, bCopyStrings);
-    if(rc < 0) return rc;
-
-    // add every entry in the file to the data table
-    while(FindEntry(pWork, pSection, pItem, pVal, pComment))
-    {
-        rc = AddEntry(pSection, pItem, pVal, pComment, false, bCopyStrings);
-        if(rc < 0) return rc;
-    }
-
-    // store these strings if we didn't copy them
-    if(bCopyStrings)
-    {
-        delete[] pData;
-    }
-    else
-    {
-        m_pData = pData;
-        m_uDataLen = uLen + 1;
-    }
-
-    return SI_OK;
-}
-
-#ifdef SI_SUPPORT_IOSTREAMS
-template
-SI_Error
-CSimpleIniTempl::LoadData(
-    std::istream & a_istream
-)
-{
-    std::string strData;
-    char szBuf[512];
-    do
-    {
-        a_istream.get(szBuf, sizeof(szBuf), '\0');
-        strData.append(szBuf);
-    }
-    while(a_istream.good());
-    return LoadData(strData);
-}
-#endif // SI_SUPPORT_IOSTREAMS
-
-template
-SI_Error
-CSimpleIniTempl::FindFileComment(
-    SI_CHAR*   &   a_pData,
-    bool            a_bCopyStrings
-)
-{
-    // there can only be a single file comment
-    if(m_pFileComment)
-    {
-        return SI_OK;
-    }
-
-    // Load the file comment as multi-line text, this will modify all of
-    // the newline characters to be single \n chars
-    if(!LoadMultiLineText(a_pData, m_pFileComment, NULL, false))
-    {
-        return SI_OK;
-    }
-
-    // copy the string if necessary
-    if(a_bCopyStrings)
-    {
-        SI_Error rc = CopyString(m_pFileComment);
-        if(rc < 0) return rc;
-    }
-
-    return SI_OK;
-}
-
-template
-bool
-CSimpleIniTempl::FindEntry(
-    SI_CHAR*    &    a_pData,
-    const SI_CHAR* & a_pSection,
-    const SI_CHAR* & a_pKey,
-    const SI_CHAR* & a_pVal,
-    const SI_CHAR* & a_pComment
-) const
-{
-    a_pComment = NULL;
-
-    SI_CHAR* pTrail = NULL;
-    while(*a_pData)
-    {
-        // skip spaces and empty lines
-        while(*a_pData && IsSpace(*a_pData))
-        {
-            ++a_pData;
-        }
-        if(!*a_pData)
-        {
-            break;
-        }
-
-        // skip processing of comment lines but keep a pointer to
-        // the start of the comment.
-        if(IsComment(*a_pData))
-        {
-            LoadMultiLineText(a_pData, a_pComment, NULL, true);
-            continue;
-        }
-
-        // process section names
-        if(*a_pData == '[')
-        {
-            // skip leading spaces
-            ++a_pData;
-            while(*a_pData && IsSpace(*a_pData))
-            {
-                ++a_pData;
-            }
-
-            // find the end of the section name (it may contain spaces)
-            // and convert it to lowercase as necessary
-            a_pSection = a_pData;
-            while(*a_pData && *a_pData != ']' && !IsNewLineChar(*a_pData))
-            {
-                ++a_pData;
-            }
-
-            // if it's an invalid line, just skip it
-            if(*a_pData != ']')
-            {
-                continue;
-            }
-
-            // remove trailing spaces from the section
-            pTrail = a_pData - 1;
-            while(pTrail >= a_pSection && IsSpace(*pTrail))
-            {
-                --pTrail;
-            }
-            ++pTrail;
-            *pTrail = 0;
-
-            // skip to the end of the line
-            ++a_pData;  // safe as checked that it == ']' above
-            while(*a_pData && !IsNewLineChar(*a_pData))
-            {
-                ++a_pData;
-            }
-
-            a_pKey = NULL;
-            a_pVal = NULL;
-            return true;
-        }
-
-        // find the end of the key name (it may contain spaces)
-        // and convert it to lowercase as necessary
-        a_pKey = a_pData;
-        while(*a_pData && *a_pData != '=' && !IsNewLineChar(*a_pData))
-        {
-            ++a_pData;
-        }
-
-        // if it's an invalid line, just skip it
-        if(*a_pData != '=')
-        {
-            continue;
-        }
-
-        // empty keys are invalid
-        if(a_pKey == a_pData)
-        {
-            while(*a_pData && !IsNewLineChar(*a_pData))
-            {
-                ++a_pData;
-            }
-            continue;
-        }
-
-        // remove trailing spaces from the key
-        pTrail = a_pData - 1;
-        while(pTrail >= a_pKey && IsSpace(*pTrail))
-        {
-            --pTrail;
-        }
-        ++pTrail;
-        *pTrail = 0;
-
-        // skip leading whitespace on the value
-        ++a_pData;  // safe as checked that it == '=' above
-        while(*a_pData && !IsNewLineChar(*a_pData) && IsSpace(*a_pData))
-        {
-            ++a_pData;
-        }
-
-        // find the end of the value which is the end of this line
-        a_pVal = a_pData;
-        while(*a_pData && !IsNewLineChar(*a_pData))
-        {
-            ++a_pData;
-        }
-
-        // remove trailing spaces from the value
-        pTrail = a_pData - 1;
-        if(*a_pData)    // prepare for the next round
-        {
-            SkipNewLine(a_pData);
-        }
-        while(pTrail >= a_pVal && IsSpace(*pTrail))
-        {
-            --pTrail;
-        }
-        ++pTrail;
-        *pTrail = 0;
-
-        // check for multi-line entries
-        if(m_bAllowMultiLine && IsMultiLineTag(a_pVal))
-        {
-            // skip the "<<<" to get the tag that will end the multiline
-            const SI_CHAR* pTagName = a_pVal + 3;
-            return LoadMultiLineText(a_pData, a_pVal, pTagName);
-        }
-
-        // return the standard entry
-        return true;
-    }
-
-    return false;
-}
-
-template
-bool
-CSimpleIniTempl::IsMultiLineTag(
-    const SI_CHAR* a_pVal
-) const
-{
-    // check for the "<<<" prefix for a multi-line entry
-    if(*a_pVal++ != '<') return false;
-    if(*a_pVal++ != '<') return false;
-    if(*a_pVal++ != '<') return false;
-    return true;
-}
-
-template
-bool
-CSimpleIniTempl::IsMultiLineData(
-    const SI_CHAR* a_pData
-) const
-{
-    // data is multi-line if it has any of the following features:
-    //  * whitespace prefix
-    //  * embedded newlines
-    //  * whitespace suffix
-
-    // empty string
-    if(!*a_pData)
-    {
-        return false;
-    }
-
-    // check for prefix
-    if(IsSpace(*a_pData))
-    {
-        return true;
-    }
-
-    // embedded newlines
-    while(*a_pData)
-    {
-        if(IsNewLineChar(*a_pData))
-        {
-            return true;
-        }
-        ++a_pData;
-    }
-
-    // check for suffix
-    if(IsSpace(*--a_pData))
-    {
-        return true;
-    }
-
-    return false;
-}
-
-template
-bool
-CSimpleIniTempl::IsNewLineChar(
-    SI_CHAR a_c
-) const
-{
-    return (a_c == '\n' || a_c == '\r');
-}
-
-template
-bool
-CSimpleIniTempl::LoadMultiLineText(
-    SI_CHAR*     &     a_pData,
-    const SI_CHAR*  &  a_pVal,
-    const SI_CHAR*      a_pTagName,
-    bool                a_bAllowBlankLinesInComment
-) const
-{
-    // we modify this data to strip all newlines down to a single '\n'
-    // character. This means that on Windows we need to strip out some
-    // characters which will make the data shorter.
-    // i.e.  LINE1-LINE1\r\nLINE2-LINE2\0 will become
-    //       LINE1-LINE1\nLINE2-LINE2\0
-    // The pDataLine entry is the pointer to the location in memory that
-    // the current line needs to start to run following the existing one.
-    // This may be the same as pCurrLine in which case no move is needed.
-    SI_CHAR* pDataLine = a_pData;
-    SI_CHAR* pCurrLine;
-
-    // value starts at the current line
-    a_pVal = a_pData;
-
-    // find the end tag. This tag must start in column 1 and be
-    // followed by a newline. No whitespace removal is done while
-    // searching for this tag.
-    SI_CHAR cEndOfLineChar = *a_pData;
-    for(;;)
-    {
-        // if we are loading comments then we need a comment character as
-        // the first character on every line
-        if(!a_pTagName && !IsComment(*a_pData))
-        {
-            // if we aren't allowing blank lines then we're done
-            if(!a_bAllowBlankLinesInComment)
-            {
-                break;
-            }
-
-            // if we are allowing blank lines then we only include them
-            // in this comment if another comment follows, so read ahead
-            // to find out.
-            SI_CHAR* pCurr = a_pData;
-            int nNewLines = 0;
-            while(IsSpace(*pCurr))
-            {
-                if(IsNewLineChar(*pCurr))
-                {
-                    ++nNewLines;
-                    SkipNewLine(pCurr);
-                }
-                else
-                {
-                    ++pCurr;
-                }
-            }
-
-            // we have a comment, add the blank lines to the output
-            // and continue processing from here
-            if(IsComment(*pCurr))
-            {
-                for(; nNewLines > 0; --nNewLines) *pDataLine++ = '\n';
-                a_pData = pCurr;
-                continue;
-            }
-
-            // the comment ends here
-            break;
-        }
-
-        // find the end of this line
-        pCurrLine = a_pData;
-        while(*a_pData && !IsNewLineChar(*a_pData)) ++a_pData;
-
-        // move this line down to the location that it should be if necessary
-        if(pDataLine < pCurrLine)
-        {
-            size_t nLen = (size_t)(a_pData - pCurrLine);
-            memmove(pDataLine, pCurrLine, nLen * sizeof(SI_CHAR));
-            pDataLine[nLen] = '\0';
-        }
-
-        // end the line with a NULL
-        cEndOfLineChar = *a_pData;
-        *a_pData = 0;
-
-        // if are looking for a tag then do the check now. This is done before
-        // checking for end of the data, so that if we have the tag at the end
-        // of the data then the tag is removed correctly.
-        if(a_pTagName &&
-                (!IsLess(pDataLine, a_pTagName) && !IsLess(a_pTagName, pDataLine)))
-        {
-            break;
-        }
-
-        // if we are at the end of the data then we just automatically end
-        // this entry and return the current data.
-        if(!cEndOfLineChar)
-        {
-            return true;
-        }
-
-        // otherwise we need to process this newline to ensure that it consists
-        // of just a single \n character.
-        pDataLine += (a_pData - pCurrLine);
-        *a_pData = cEndOfLineChar;
-        SkipNewLine(a_pData);
-        *pDataLine++ = '\n';
-    }
-
-    // if we didn't find a comment at all then return false
-    if(a_pVal == a_pData)
-    {
-        a_pVal = NULL;
-        return false;
-    }
-
-    // the data (which ends at the end of the last line) needs to be
-    // null-terminated BEFORE before the newline character(s). If the
-    // user wants a new line in the multi-line data then they need to
-    // add an empty line before the tag.
-    *--pDataLine = '\0';
-
-    // if looking for a tag and if we aren't at the end of the data,
-    // then move a_pData to the start of the next line.
-    if(a_pTagName && cEndOfLineChar)
-    {
-        SI_ASSERT(IsNewLineChar(cEndOfLineChar));
-        *a_pData = cEndOfLineChar;
-        SkipNewLine(a_pData);
-    }
-
-    return true;
-}
-
-template
-SI_Error
-CSimpleIniTempl::CopyString(
-    const SI_CHAR* & a_pString
-)
-{
-    size_t uLen = 0;
-    if(sizeof(SI_CHAR) == sizeof(char))
-    {
-        uLen = strlen((const char*)a_pString);
-    }
-    else if(sizeof(SI_CHAR) == sizeof(wchar_t))
-    {
-        uLen = wcslen((const wchar_t*)a_pString);
-    }
-    else
-    {
-        for(; a_pString[uLen]; ++uLen) /*loop*/ ;
-    }
-    ++uLen; // NULL character
-    SI_CHAR* pCopy = new SI_CHAR[uLen];
-    if(!pCopy)
-    {
-        return SI_NOMEM;
-    }
-    memcpy(pCopy, a_pString, sizeof(SI_CHAR)*uLen);
-    m_strings.push_back(pCopy);
-    a_pString = pCopy;
-    return SI_OK;
-}
-
-template
-SI_Error
-CSimpleIniTempl::AddEntry(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    const SI_CHAR* a_pValue,
-    const SI_CHAR* a_pComment,
-    bool            a_bForceReplace,
-    bool            a_bCopyStrings
-)
-{
-    SI_Error rc;
-    bool bInserted = false;
-
-    SI_ASSERT(!a_pComment || IsComment(*a_pComment));
-
-    // if we are copying strings then make a copy of the comment now
-    // because we will need it when we add the entry.
-    if(a_bCopyStrings && a_pComment)
-    {
-        rc = CopyString(a_pComment);
-        if(rc < 0) return rc;
-    }
-
-    // create the section entry if necessary
-    typename TSection::iterator iSection = m_data.find(a_pSection);
-    if(iSection == m_data.end())
-    {
-        // if the section doesn't exist then we need a copy as the
-        // string needs to last beyond the end of this function
-        if(a_bCopyStrings)
-        {
-            rc = CopyString(a_pSection);
-            if(rc < 0) return rc;
-        }
-
-        // only set the comment if this is a section only entry
-        Entry oSection(a_pSection, ++m_nOrder);
-        if(a_pComment && (!a_pKey || !a_pValue))
-        {
-            oSection.pComment = a_pComment;
-        }
-
-        typename TSection::value_type oEntry(oSection, TKeyVal());
-        typedef typename TSection::iterator SectionIterator;
-        std::pair i = m_data.insert(oEntry);
-        iSection = i.first;
-        bInserted = true;
-    }
-    if(!a_pKey || !a_pValue)
-    {
-        // section only entries are specified with pItem and pVal as NULL
-        return bInserted ? SI_INSERTED : SI_UPDATED;
-    }
-
-    // check for existence of the key
-    TKeyVal & keyval = iSection->second;
-    typename TKeyVal::iterator iKey = keyval.find(a_pKey);
-
-    // remove all existing entries but save the load order and
-    // comment of the first entry
-    int nLoadOrder = ++m_nOrder;
-    if(iKey != keyval.end() && m_bAllowMultiKey && a_bForceReplace)
-    {
-        const SI_CHAR* pComment = NULL;
-        while(iKey != keyval.end() && !IsLess(a_pKey, iKey->first.pItem))
-        {
-            if(iKey->first.nOrder < nLoadOrder)
-            {
-                nLoadOrder = iKey->first.nOrder;
-                pComment   = iKey->first.pComment;
-            }
-            ++iKey;
-        }
-        if(pComment)
-        {
-            DeleteString(a_pComment);
-            a_pComment = pComment;
-            rc = CopyString(a_pComment);
-            if(rc < 0) return rc;
-        }
-        Delete(a_pSection, a_pKey);
-        iKey = keyval.end();
-    }
-
-    // make string copies if necessary
-    bool bForceCreateNewKey = m_bAllowMultiKey && !a_bForceReplace;
-    if(a_bCopyStrings)
-    {
-        if(bForceCreateNewKey || iKey == keyval.end())
-        {
-            // if the key doesn't exist then we need a copy as the
-            // string needs to last beyond the end of this function
-            // because we will be inserting the key next
-            rc = CopyString(a_pKey);
-            if(rc < 0) return rc;
-        }
-
-        // we always need a copy of the value
-        rc = CopyString(a_pValue);
-        if(rc < 0) return rc;
-    }
-
-    // create the key entry
-    if(iKey == keyval.end() || bForceCreateNewKey)
-    {
-        Entry oKey(a_pKey, nLoadOrder);
-        if(a_pComment)
-        {
-            oKey.pComment = a_pComment;
-        }
-        typename TKeyVal::value_type oEntry(oKey, static_cast(NULL));
-        iKey = keyval.insert(oEntry);
-        bInserted = true;
-    }
-    iKey->second = a_pValue;
-    return bInserted ? SI_INSERTED : SI_UPDATED;
-}
-
-template
-const SI_CHAR*
-CSimpleIniTempl::GetValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    const SI_CHAR* a_pDefault,
-    bool*           a_pHasMultiple
-) const
-{
-    if(a_pHasMultiple)
-    {
-        *a_pHasMultiple = false;
-    }
-    if(!a_pSection || !a_pKey)
-    {
-        return a_pDefault;
-    }
-    typename TSection::const_iterator iSection = m_data.find(a_pSection);
-    if(iSection == m_data.end())
-    {
-        return a_pDefault;
-    }
-    typename TKeyVal::const_iterator iKeyVal = iSection->second.find(a_pKey);
-    if(iKeyVal == iSection->second.end())
-    {
-        return a_pDefault;
-    }
-
-    // check for multiple entries with the same key
-    if(m_bAllowMultiKey && a_pHasMultiple)
-    {
-        typename TKeyVal::const_iterator iTemp = iKeyVal;
-        if(++iTemp != iSection->second.end())
-        {
-            if(!IsLess(a_pKey, iTemp->first.pItem))
-            {
-                *a_pHasMultiple = true;
-            }
-        }
-    }
-
-    return iKeyVal->second;
-}
-
-template
-long
-CSimpleIniTempl::GetLongValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    long            a_nDefault,
-    bool*           a_pHasMultiple
-) const
-{
-    // return the default if we don't have a value
-    const SI_CHAR* pszValue = GetValue(a_pSection, a_pKey, NULL, a_pHasMultiple);
-    if(!pszValue || !*pszValue) return a_nDefault;
-
-    // convert to UTF-8/MBCS which for a numeric value will be the same as ASCII
-    char szValue[64] = { 0 };
-    SI_CONVERTER c(m_bStoreIsUtf8);
-    if(!c.ConvertToStore(pszValue, szValue, sizeof(szValue)))
-    {
-        return a_nDefault;
-    }
-
-    // handle the value as hex if prefaced with "0x"
-    long nValue = a_nDefault;
-    char* pszSuffix = szValue;
-    if(szValue[0] == '0' && (szValue[1] == 'x' || szValue[1] == 'X'))
-    {
-        if(!szValue[2]) return a_nDefault;
-        nValue = strtol(&szValue[2], &pszSuffix, 16);
-    }
-    else
-    {
-        nValue = strtol(szValue, &pszSuffix, 10);
-    }
-
-    // any invalid strings will return the default value
-    if(*pszSuffix)
-    {
-        return a_nDefault;
-    }
-
-    return nValue;
-}
-
-template
-SI_Error
-CSimpleIniTempl::SetLongValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    long            a_nValue,
-    const SI_CHAR* a_pComment,
-    bool            a_bUseHex,
-    bool            a_bForceReplace
-)
-{
-    // use SetValue to create sections
-    if(!a_pSection || !a_pKey) return SI_FAIL;
-
-    // convert to an ASCII string
-    char szInput[64];
-#if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
-    sprintf_s(szInput, a_bUseHex ? "0x%lx" : "%ld", a_nValue);
-#else // !__STDC_WANT_SECURE_LIB__
-    sprintf(szInput, a_bUseHex ? "0x%lx" : "%ld", a_nValue);
-#endif // __STDC_WANT_SECURE_LIB__
-
-    // convert to output text
-    SI_CHAR szOutput[64];
-    SI_CONVERTER c(m_bStoreIsUtf8);
-    c.ConvertFromStore(szInput, strlen(szInput) + 1,
-                       szOutput, sizeof(szOutput) / sizeof(SI_CHAR));
-
-    // actually add it
-    return AddEntry(a_pSection, a_pKey, szOutput, a_pComment, a_bForceReplace, true);
-}
-
-template
-double
-CSimpleIniTempl::GetDoubleValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    double          a_nDefault,
-    bool*           a_pHasMultiple
-) const
-{
-    // return the default if we don't have a value
-    const SI_CHAR* pszValue = GetValue(a_pSection, a_pKey, NULL, a_pHasMultiple);
-    if(!pszValue || !*pszValue) return a_nDefault;
-
-    // convert to UTF-8/MBCS which for a numeric value will be the same as ASCII
-    char szValue[64] = { 0 };
-    SI_CONVERTER c(m_bStoreIsUtf8);
-    if(!c.ConvertToStore(pszValue, szValue, sizeof(szValue)))
-    {
-        return a_nDefault;
-    }
-
-    char* pszSuffix = NULL;
-    double nValue = strtod(szValue, &pszSuffix);
-
-    // any invalid strings will return the default value
-    if(!pszSuffix || *pszSuffix)
-    {
-        return a_nDefault;
-    }
-
-    return nValue;
-}
-
-template
-SI_Error
-CSimpleIniTempl::SetDoubleValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    double          a_nValue,
-    const SI_CHAR* a_pComment,
-    bool            a_bForceReplace
-)
-{
-    // use SetValue to create sections
-    if(!a_pSection || !a_pKey) return SI_FAIL;
-
-    // convert to an ASCII string
-    char szInput[64];
-#if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
-    sprintf_s(szInput, "%f", a_nValue);
-#else // !__STDC_WANT_SECURE_LIB__
-    sprintf(szInput, "%f", a_nValue);
-#endif // __STDC_WANT_SECURE_LIB__
-
-    // convert to output text
-    SI_CHAR szOutput[64];
-    SI_CONVERTER c(m_bStoreIsUtf8);
-    c.ConvertFromStore(szInput, strlen(szInput) + 1,
-                       szOutput, sizeof(szOutput) / sizeof(SI_CHAR));
-
-    // actually add it
-    return AddEntry(a_pSection, a_pKey, szOutput, a_pComment, a_bForceReplace, true);
-}
-
-template
-bool
-CSimpleIniTempl::GetBoolValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    bool            a_bDefault,
-    bool*           a_pHasMultiple
-) const
-{
-    // return the default if we don't have a value
-    const SI_CHAR* pszValue = GetValue(a_pSection, a_pKey, NULL, a_pHasMultiple);
-    if(!pszValue || !*pszValue) return a_bDefault;
-
-    // we only look at the minimum number of characters
-    switch(pszValue[0])
-    {
-    case 't':
-    case 'T': // true
-    case 'y':
-    case 'Y': // yes
-    case '1':           // 1 (one)
-        return true;
-
-    case 'f':
-    case 'F': // false
-    case 'n':
-    case 'N': // no
-    case '0':           // 0 (zero)
-        return false;
-
-    case 'o':
-    case 'O':
-        if(pszValue[1] == 'n' || pszValue[1] == 'N') return true;   // on
-        if(pszValue[1] == 'f' || pszValue[1] == 'F') return false;  // off
-        break;
-    }
-
-    // no recognized value, return the default
-    return a_bDefault;
-}
-
-template
-SI_Error
-CSimpleIniTempl::SetBoolValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    bool            a_bValue,
-    const SI_CHAR* a_pComment,
-    bool            a_bForceReplace
-)
-{
-    // use SetValue to create sections
-    if(!a_pSection || !a_pKey) return SI_FAIL;
-
-    // convert to an ASCII string
-    const char* pszInput = a_bValue ? "true" : "false";
-
-    // convert to output text
-    SI_CHAR szOutput[64];
-    SI_CONVERTER c(m_bStoreIsUtf8);
-    c.ConvertFromStore(pszInput, strlen(pszInput) + 1,
-                       szOutput, sizeof(szOutput) / sizeof(SI_CHAR));
-
-    // actually add it
-    return AddEntry(a_pSection, a_pKey, szOutput, a_pComment, a_bForceReplace, true);
-}
-
-template
-bool
-CSimpleIniTempl::GetAllValues(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    TNamesDepend  & a_values
-) const
-{
-    a_values.clear();
-
-    if(!a_pSection || !a_pKey)
-    {
-        return false;
-    }
-    typename TSection::const_iterator iSection = m_data.find(a_pSection);
-    if(iSection == m_data.end())
-    {
-        return false;
-    }
-    typename TKeyVal::const_iterator iKeyVal = iSection->second.find(a_pKey);
-    if(iKeyVal == iSection->second.end())
-    {
-        return false;
-    }
-
-    // insert all values for this key
-    a_values.push_back(Entry(iKeyVal->second, iKeyVal->first.pComment, iKeyVal->first.nOrder));
-    if(m_bAllowMultiKey)
-    {
-        ++iKeyVal;
-        while(iKeyVal != iSection->second.end() && !IsLess(a_pKey, iKeyVal->first.pItem))
-        {
-            a_values.push_back(Entry(iKeyVal->second, iKeyVal->first.pComment, iKeyVal->first.nOrder));
-            ++iKeyVal;
-        }
-    }
-
-    return true;
-}
-
-template
-int
-CSimpleIniTempl::GetSectionSize(
-    const SI_CHAR* a_pSection
-) const
-{
-    if(!a_pSection)
-    {
-        return -1;
-    }
-
-    typename TSection::const_iterator iSection = m_data.find(a_pSection);
-    if(iSection == m_data.end())
-    {
-        return -1;
-    }
-    const TKeyVal & section = iSection->second;
-
-    // if multi-key isn't permitted then the section size is
-    // the number of keys that we have.
-    if(!m_bAllowMultiKey || section.empty())
-    {
-        return (int) section.size();
-    }
-
-    // otherwise we need to count them
-    int nCount = 0;
-    const SI_CHAR* pLastKey = NULL;
-    typename TKeyVal::const_iterator iKeyVal = section.begin();
-    for(int n = 0; iKeyVal != section.end(); ++iKeyVal, ++n)
-    {
-        if(!pLastKey || IsLess(pLastKey, iKeyVal->first.pItem))
-        {
-            ++nCount;
-            pLastKey = iKeyVal->first.pItem;
-        }
-    }
-    return nCount;
-}
-
-template
-const typename CSimpleIniTempl::TKeyVal*
-CSimpleIniTempl::GetSection(
-    const SI_CHAR* a_pSection
-) const
-{
-    if(a_pSection)
-    {
-        typename TSection::const_iterator i = m_data.find(a_pSection);
-        if(i != m_data.end())
-        {
-            return &(i->second);
-        }
-    }
-    return 0;
-}
-
-template
-void
-CSimpleIniTempl::GetAllSections(
-    TNamesDepend & a_names
-) const
-{
-    a_names.clear();
-    typename TSection::const_iterator i = m_data.begin();
-    for(int n = 0; i != m_data.end(); ++i, ++n)
-    {
-        a_names.push_back(i->first);
-    }
-}
-
-template
-bool
-CSimpleIniTempl::GetAllKeys(
-    const SI_CHAR* a_pSection,
-    TNamesDepend  & a_names
-) const
-{
-    a_names.clear();
-
-    if(!a_pSection)
-    {
-        return false;
-    }
-
-    typename TSection::const_iterator iSection = m_data.find(a_pSection);
-    if(iSection == m_data.end())
-    {
-        return false;
-    }
-
-    const TKeyVal & section = iSection->second;
-    const SI_CHAR* pLastKey = NULL;
-    typename TKeyVal::const_iterator iKeyVal = section.begin();
-    for(int n = 0; iKeyVal != section.end(); ++iKeyVal, ++n)
-    {
-        if(!pLastKey || IsLess(pLastKey, iKeyVal->first.pItem))
-        {
-            a_names.push_back(iKeyVal->first);
-            pLastKey = iKeyVal->first.pItem;
-        }
-    }
-
-    return true;
-}
-
-template
-SI_Error
-CSimpleIniTempl::SaveFile(
-    const char*     a_pszFile,
-    bool            a_bAddSignature
-) const
-{
-    FILE* fp = NULL;
-#if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
-    fopen_s(&fp, a_pszFile, "wb");
-#else // !__STDC_WANT_SECURE_LIB__
-    fp = fopen(a_pszFile, "wb");
-#endif // __STDC_WANT_SECURE_LIB__
-    if(!fp) return SI_FILE;
-    SI_Error rc = SaveFile(fp, a_bAddSignature);
-    fclose(fp);
-    return rc;
-}
-
-#ifdef SI_HAS_WIDE_FILE
-template
-SI_Error
-CSimpleIniTempl::SaveFile(
-    const SI_WCHAR_T*   a_pwszFile,
-    bool                a_bAddSignature
-) const
-{
-#ifdef _WIN32
-    FILE* fp = NULL;
-#if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
-    _wfopen_s(&fp, a_pwszFile, L"wb");
-#else // !__STDC_WANT_SECURE_LIB__
-    fp = _wfopen(a_pwszFile, L"wb");
-#endif // __STDC_WANT_SECURE_LIB__
-    if(!fp) return SI_FILE;
-    SI_Error rc = SaveFile(fp, a_bAddSignature);
-    fclose(fp);
-    return rc;
-#else // !_WIN32 (therefore SI_CONVERT_ICU)
-    char szFile[256];
-    u_austrncpy(szFile, a_pwszFile, sizeof(szFile));
-    return SaveFile(szFile, a_bAddSignature);
-#endif // _WIN32
-}
-#endif // SI_HAS_WIDE_FILE
-
-template
-SI_Error
-CSimpleIniTempl::SaveFile(
-    FILE*   a_pFile,
-    bool    a_bAddSignature
-) const
-{
-    FileWriter writer(a_pFile);
-    return Save(writer, a_bAddSignature);
-}
-
-template
-SI_Error
-CSimpleIniTempl::Save(
-    OutputWriter  & a_oOutput,
-    bool            a_bAddSignature
-) const
-{
-    Converter convert(m_bStoreIsUtf8);
-
-    // add the UTF-8 signature if it is desired
-    if(m_bStoreIsUtf8 && a_bAddSignature)
-    {
-        a_oOutput.Write(SI_UTF8_SIGNATURE);
-    }
-
-    // get all of the sections sorted in load order
-    TNamesDepend oSections;
-    GetAllSections(oSections);
-#if defined(_MSC_VER) && _MSC_VER <= 1200
-    oSections.sort();
-#elif defined(__BORLANDC__)
-    oSections.sort(Entry::LoadOrder());
-#else
-    oSections.sort(typename Entry::LoadOrder());
-#endif
-
-    // write the file comment if we have one
-    bool bNeedNewLine = false;
-    if(m_pFileComment)
-    {
-        if(!OutputMultiLineText(a_oOutput, convert, m_pFileComment))
-        {
-            return SI_FAIL;
-        }
-        bNeedNewLine = true;
-    }
-
-    // iterate through our sections and output the data
-    typename TNamesDepend::const_iterator iSection = oSections.begin();
-    for(; iSection != oSections.end(); ++iSection)
-    {
-        // write out the comment if there is one
-        if(iSection->pComment)
-        {
-            if(bNeedNewLine)
-            {
-                a_oOutput.Write(SI_NEWLINE_A);
-            }
-            if(!OutputMultiLineText(a_oOutput, convert, iSection->pComment))
-            {
-                return SI_FAIL;
-            }
-            bNeedNewLine = false;
-        }
-
-        if(bNeedNewLine)
-        {
-            a_oOutput.Write(SI_NEWLINE_A);
-            bNeedNewLine = false;
-        }
-
-        // write the section (unless there is no section name)
-        if(*iSection->pItem)
-        {
-            if(!convert.ConvertToStore(iSection->pItem))
-            {
-                return SI_FAIL;
-            }
-            a_oOutput.Write("[");
-            a_oOutput.Write(convert.Data());
-            a_oOutput.Write("]");
-            a_oOutput.Write(SI_NEWLINE_A);
-        }
-
-        // get all of the keys sorted in load order
-        TNamesDepend oKeys;
-        GetAllKeys(iSection->pItem, oKeys);
-#if defined(_MSC_VER) && _MSC_VER <= 1200
-        oKeys.sort();
-#elif defined(__BORLANDC__)
-        oKeys.sort(Entry::LoadOrder());
-#else
-        oKeys.sort(typename Entry::LoadOrder());
-#endif
-
-        // write all keys and values
-        typename TNamesDepend::const_iterator iKey = oKeys.begin();
-        for(; iKey != oKeys.end(); ++iKey)
-        {
-            // get all values for this key
-            TNamesDepend oValues;
-            GetAllValues(iSection->pItem, iKey->pItem, oValues);
-
-            typename TNamesDepend::const_iterator iValue = oValues.begin();
-            for(; iValue != oValues.end(); ++iValue)
-            {
-                // write out the comment if there is one
-                if(iValue->pComment)
-                {
-                    a_oOutput.Write(SI_NEWLINE_A);
-                    if(!OutputMultiLineText(a_oOutput, convert, iValue->pComment))
-                    {
-                        return SI_FAIL;
-                    }
-                }
-
-                // write the key
-                if(!convert.ConvertToStore(iKey->pItem))
-                {
-                    return SI_FAIL;
-                }
-                a_oOutput.Write(convert.Data());
-
-                // write the value
-                if(!convert.ConvertToStore(iValue->pItem))
-                {
-                    return SI_FAIL;
-                }
-                a_oOutput.Write(m_bSpaces ? " = " : "=");
-                if(m_bAllowMultiLine && IsMultiLineData(iValue->pItem))
-                {
-                    // multi-line data needs to be processed specially to ensure
-                    // that we use the correct newline format for the current system
-                    a_oOutput.Write("<<pItem))
-                    {
-                        return SI_FAIL;
-                    }
-                    a_oOutput.Write("END_OF_TEXT");
-                }
-                else
-                {
-                    a_oOutput.Write(convert.Data());
-                }
-                a_oOutput.Write(SI_NEWLINE_A);
-            }
-        }
-
-        bNeedNewLine = true;
-    }
-
-    return SI_OK;
-}
-
-template
-bool
-CSimpleIniTempl::OutputMultiLineText(
-    OutputWriter  & a_oOutput,
-    Converter   &   a_oConverter,
-    const SI_CHAR* a_pText
-) const
-{
-    const SI_CHAR* pEndOfLine;
-    SI_CHAR cEndOfLineChar = *a_pText;
-    while(cEndOfLineChar)
-    {
-        // find the end of this line
-        pEndOfLine = a_pText;
-        for(; *pEndOfLine && *pEndOfLine != '\n'; ++pEndOfLine) /*loop*/ ;
-        cEndOfLineChar = *pEndOfLine;
-
-        // temporarily null terminate, convert and output the line
-        *const_cast(pEndOfLine) = 0;
-        if(!a_oConverter.ConvertToStore(a_pText))
-        {
-            return false;
-        }
-        *const_cast(pEndOfLine) = cEndOfLineChar;
-        a_pText += (pEndOfLine - a_pText) + 1;
-        a_oOutput.Write(a_oConverter.Data());
-        a_oOutput.Write(SI_NEWLINE_A);
-    }
-    return true;
-}
-
-template
-bool
-CSimpleIniTempl::Delete(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    bool            a_bRemoveEmpty
-)
-{
-    return DeleteValue(a_pSection, a_pKey, NULL, a_bRemoveEmpty);
-}
-
-template
-bool
-CSimpleIniTempl::DeleteValue(
-    const SI_CHAR* a_pSection,
-    const SI_CHAR* a_pKey,
-    const SI_CHAR* a_pValue,
-    bool            a_bRemoveEmpty
-)
-{
-    if(!a_pSection)
-    {
-        return false;
-    }
-
-    typename TSection::iterator iSection = m_data.find(a_pSection);
-    if(iSection == m_data.end())
-    {
-        return false;
-    }
-
-    // remove a single key if we have a keyname
-    if(a_pKey)
-    {
-        typename TKeyVal::iterator iKeyVal = iSection->second.find(a_pKey);
-        if(iKeyVal == iSection->second.end())
-        {
-            return false;
-        }
-
-        const static SI_STRLESS isLess = SI_STRLESS();
-
-        // remove any copied strings and then the key
-        typename TKeyVal::iterator iDelete;
-        bool bDeleted = false;
-        do
-        {
-            iDelete = iKeyVal++;
-
-            if(a_pValue == NULL ||
-                    (isLess(a_pValue, iDelete->second) == false &&
-                     isLess(iDelete->second, a_pValue) == false))
-            {
-                DeleteString(iDelete->first.pItem);
-                DeleteString(iDelete->second);
-                iSection->second.erase(iDelete);
-                bDeleted = true;
-            }
-        }
-        while(iKeyVal != iSection->second.end()
-                && !IsLess(a_pKey, iKeyVal->first.pItem));
-
-        if(!bDeleted)
-        {
-            return false;
-        }
-
-        // done now if the section is not empty or we are not pruning away
-        // the empty sections. Otherwise let it fall through into the section
-        // deletion code
-        if(!a_bRemoveEmpty || !iSection->second.empty())
-        {
-            return true;
-        }
-    }
-    else
-    {
-        // delete all copied strings from this section. The actual
-        // entries will be removed when the section is removed.
-        typename TKeyVal::iterator iKeyVal = iSection->second.begin();
-        for(; iKeyVal != iSection->second.end(); ++iKeyVal)
-        {
-            DeleteString(iKeyVal->first.pItem);
-            DeleteString(iKeyVal->second);
-        }
-    }
-
-    // delete the section itself
-    DeleteString(iSection->first.pItem);
-    m_data.erase(iSection);
-
-    return true;
-}
-
-template
-void
-CSimpleIniTempl::DeleteString(
-    const SI_CHAR* a_pString
-)
-{
-    // strings may exist either inside the data block, or they will be
-    // individually allocated and stored in m_strings. We only physically
-    // delete those stored in m_strings.
-    if(a_pString < m_pData || a_pString >= m_pData + m_uDataLen)
-    {
-        typename TNamesDepend::iterator i = m_strings.begin();
-        for(; i != m_strings.end(); ++i)
-        {
-            if(a_pString == i->pItem)
-            {
-                delete[] const_cast(i->pItem);
-                m_strings.erase(i);
-                break;
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-//                              CONVERSION FUNCTIONS
-// ---------------------------------------------------------------------------
-
-// Defines the conversion classes for different libraries. Before including
-// SimpleIni.h, set the converter that you wish you use by defining one of the
-// following symbols.
-//
-//  SI_CONVERT_GENERIC      Use the Unicode reference conversion library in
-//                          the accompanying files ConvertUTF.h/c
-//  SI_CONVERT_ICU          Use the IBM ICU conversion library. Requires
-//                          ICU headers on include path and icuuc.lib
-//  SI_CONVERT_WIN32        Use the Win32 API functions for conversion.
-
-#if !defined(SI_CONVERT_GENERIC) && !defined(SI_CONVERT_WIN32) && !defined(SI_CONVERT_ICU)
-# ifdef _WIN32
-#  define SI_CONVERT_WIN32
-# else
-#  define SI_CONVERT_GENERIC
-# endif
-#endif
-
-/**
- * Generic case-sensitive less than comparison. This class returns numerically
- * ordered ASCII case-sensitive text for all possible sizes and types of
- * SI_CHAR.
- */
-template
-struct SI_GenericCase
-{
-    bool operator()(const SI_CHAR* pLeft, const SI_CHAR* pRight) const
-    {
-        long cmp;
-        for(; *pLeft && *pRight; ++pLeft, ++pRight)
-        {
-            cmp = (long) * pLeft - (long) * pRight;
-            if(cmp != 0)
-            {
-                return cmp < 0;
-            }
-        }
-        return *pRight != 0;
-    }
-};
-
-/**
- * Generic ASCII case-insensitive less than comparison. This class returns
- * numerically ordered ASCII case-insensitive text for all possible sizes
- * and types of SI_CHAR. It is not safe for MBCS text comparison where
- * ASCII A-Z characters are used in the encoding of multi-byte characters.
- */
-template
-struct SI_GenericNoCase
-{
-    inline SI_CHAR locase(SI_CHAR ch) const
-    {
-        return (ch < 'A' || ch > 'Z') ? ch : (ch - 'A' + 'a');
-    }
-    bool operator()(const SI_CHAR* pLeft, const SI_CHAR* pRight) const
-    {
-        long cmp;
-        for(; *pLeft && *pRight; ++pLeft, ++pRight)
-        {
-            cmp = (long) locase(*pLeft) - (long) locase(*pRight);
-            if(cmp != 0)
-            {
-                return cmp < 0;
-            }
-        }
-        return *pRight != 0;
-    }
-};
-
-/**
- * Null conversion class for MBCS/UTF-8 to char (or equivalent).
- */
-template
-class SI_ConvertA
-{
-    bool m_bStoreIsUtf8;
-protected:
-    SI_ConvertA() { }
-public:
-    SI_ConvertA(bool a_bStoreIsUtf8) : m_bStoreIsUtf8(a_bStoreIsUtf8) { }
-
-    /* copy and assignment */
-    SI_ConvertA(const SI_ConvertA & rhs)
-    {
-        operator=(rhs);
-    }
-    SI_ConvertA & operator=(const SI_ConvertA & rhs)
-    {
-        m_bStoreIsUtf8 = rhs.m_bStoreIsUtf8;
-        return *this;
-    }
-
-    /** Calculate the number of SI_CHAR required for converting the input
-     * from the storage format. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @return              Number of SI_CHAR required by the string when
-     *                      converted. If there are embedded NULL bytes in the
-     *                      input data, only the string up and not including
-     *                      the NULL byte will be converted.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen)
-    {
-        (void)a_pInputData;
-        SI_ASSERT(a_uInputDataLen != (size_t) - 1);
-
-        // ASCII/MBCS/UTF-8 needs no conversion
-        return a_uInputDataLen;
-    }
-
-    /** Convert the input string from the storage format to SI_CHAR.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @param a_pOutputData Pointer to the output buffer to received the
-     *                      converted data.
-     * @param a_uOutputDataSize Size of the output buffer in SI_CHAR.
-     * @return              true if all of the input data was successfully
-     *                      converted.
-     */
-    bool ConvertFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen,
-        SI_CHAR*        a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        // ASCII/MBCS/UTF-8 needs no conversion
-        if(a_uInputDataLen > a_uOutputDataSize)
-        {
-            return false;
-        }
-        memcpy(a_pOutputData, a_pInputData, a_uInputDataLen);
-        return true;
-    }
-
-    /** Calculate the number of char required by the storage format of this
-     * data. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated string to calculate the number of
-     *                      bytes required to be converted to storage format.
-     * @return              Number of bytes required by the string when
-     *                      converted to storage format. This size always
-     *                      includes space for the terminating NULL character.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeToStore(
-        const SI_CHAR* a_pInputData)
-    {
-        // ASCII/MBCS/UTF-8 needs no conversion
-        return strlen((const char*)a_pInputData) + 1;
-    }
-
-    /** Convert the input string to the storage format of this data.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated source string to convert. All of
-     *                      the data will be converted including the
-     *                      terminating NULL character.
-     * @param a_pOutputData Pointer to the buffer to receive the converted
-     *                      string.
-     * @param a_uOutputDataSize Size of the output buffer in char.
-     * @return              true if all of the input data, including the
-     *                      terminating NULL character was successfully
-     *                      converted.
-     */
-    bool ConvertToStore(
-        const SI_CHAR* a_pInputData,
-        char*           a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        // calc input string length (SI_CHAR type and size independent)
-        size_t uInputLen = strlen((const char*)a_pInputData) + 1;
-        if(uInputLen > a_uOutputDataSize)
-        {
-            return false;
-        }
-
-        // ascii/UTF-8 needs no conversion
-        memcpy(a_pOutputData, a_pInputData, uInputLen);
-        return true;
-    }
-};
-
-
-// ---------------------------------------------------------------------------
-//                              SI_CONVERT_GENERIC
-// ---------------------------------------------------------------------------
-#ifdef SI_CONVERT_GENERIC
-
-#define SI_Case     SI_GenericCase
-#define SI_NoCase   SI_GenericNoCase
-
-#include 
-#include "ConvertUTF.h"
-
-/**
- * Converts UTF-8 to a wchar_t (or equivalent) using the Unicode reference
- * library functions. This can be used on all platforms.
- */
-template
-class SI_ConvertW
-{
-    bool m_bStoreIsUtf8;
-protected:
-    SI_ConvertW() { }
-public:
-    SI_ConvertW(bool a_bStoreIsUtf8) : m_bStoreIsUtf8(a_bStoreIsUtf8) { }
-
-    /* copy and assignment */
-    SI_ConvertW(const SI_ConvertW & rhs)
-    {
-        operator=(rhs);
-    }
-    SI_ConvertW & operator=(const SI_ConvertW & rhs)
-    {
-        m_bStoreIsUtf8 = rhs.m_bStoreIsUtf8;
-        return *this;
-    }
-
-    /** Calculate the number of SI_CHAR required for converting the input
-     * from the storage format. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @return              Number of SI_CHAR required by the string when
-     *                      converted. If there are embedded NULL bytes in the
-     *                      input data, only the string up and not including
-     *                      the NULL byte will be converted.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen)
-    {
-        SI_ASSERT(a_uInputDataLen != (size_t) - 1);
-
-        if(m_bStoreIsUtf8)
-        {
-            // worst case scenario for UTF-8 to wchar_t is 1 char -> 1 wchar_t
-            // so we just return the same number of characters required as for
-            // the source text.
-            return a_uInputDataLen;
-        }
-
-#if defined(SI_NO_MBSTOWCS_NULL) || (!defined(_MSC_VER) && !defined(_linux))
-        // fall back processing for platforms that don't support a NULL dest to mbstowcs
-        // worst case scenario is 1:1, this will be a sufficient buffer size
-        (void)a_pInputData;
-        return a_uInputDataLen;
-#else
-        // get the actual required buffer size
-        return mbstowcs(NULL, a_pInputData, a_uInputDataLen);
-#endif
-    }
-
-    /** Convert the input string from the storage format to SI_CHAR.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                       must be the actual length of the data, including
-     *                       NULL byte if NULL terminated string is required.
-     * @param a_pOutputData Pointer to the output buffer to received the
-     *                       converted data.
-     * @param a_uOutputDataSize Size of the output buffer in SI_CHAR.
-     * @return              true if all of the input data was successfully
-     *                       converted.
-     */
-    bool ConvertFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen,
-        SI_CHAR*        a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        if(m_bStoreIsUtf8)
-        {
-            // This uses the Unicode reference implementation to do the
-            // conversion from UTF-8 to wchar_t. The required files are
-            // ConvertUTF.h and ConvertUTF.c which should be included in
-            // the distribution but are publically available from unicode.org
-            // at http://www.unicode.org/Public/PROGRAMS/CVTUTF/
-            ConversionResult retval;
-            const UTF8* pUtf8 = (const UTF8*) a_pInputData;
-            if(sizeof(wchar_t) == sizeof(UTF32))
-            {
-                UTF32* pUtf32 = (UTF32*) a_pOutputData;
-                retval = ConvertUTF8toUTF32(
-                             &pUtf8, pUtf8 + a_uInputDataLen,
-                             &pUtf32, pUtf32 + a_uOutputDataSize,
-                             lenientConversion);
-            }
-            else if(sizeof(wchar_t) == sizeof(UTF16))
-            {
-                UTF16* pUtf16 = (UTF16*) a_pOutputData;
-                retval = ConvertUTF8toUTF16(
-                             &pUtf8, pUtf8 + a_uInputDataLen,
-                             &pUtf16, pUtf16 + a_uOutputDataSize,
-                             lenientConversion);
-            }
-            return retval == conversionOK;
-        }
-
-        // convert to wchar_t
-        size_t retval = mbstowcs(a_pOutputData,
-                                 a_pInputData, a_uOutputDataSize);
-        return retval != (size_t)(-1);
-    }
-
-    /** Calculate the number of char required by the storage format of this
-     * data. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated string to calculate the number of
-     *                       bytes required to be converted to storage format.
-     * @return              Number of bytes required by the string when
-     *                       converted to storage format. This size always
-     *                       includes space for the terminating NULL character.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeToStore(
-        const SI_CHAR* a_pInputData)
-    {
-        if(m_bStoreIsUtf8)
-        {
-            // worst case scenario for wchar_t to UTF-8 is 1 wchar_t -> 6 char
-            size_t uLen = 0;
-            while(a_pInputData[uLen])
-            {
-                ++uLen;
-            }
-            return (6 * uLen) + 1;
-        }
-        else
-        {
-            size_t uLen = wcstombs(NULL, a_pInputData, 0);
-            if(uLen == (size_t)(-1))
-            {
-                return uLen;
-            }
-            return uLen + 1; // include NULL terminator
-        }
-    }
-
-    /** Convert the input string to the storage format of this data.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated source string to convert. All of
-     *                       the data will be converted including the
-     *                       terminating NULL character.
-     * @param a_pOutputData Pointer to the buffer to receive the converted
-     *                       string.
-     * @param a_uOutputDataSize Size of the output buffer in char.
-     * @return              true if all of the input data, including the
-     *                       terminating NULL character was successfully
-     *                       converted.
-     */
-    bool ConvertToStore(
-        const SI_CHAR* a_pInputData,
-        char*           a_pOutputData,
-        size_t          a_uOutputDataSize
-    )
-    {
-        if(m_bStoreIsUtf8)
-        {
-            // calc input string length (SI_CHAR type and size independent)
-            size_t uInputLen = 0;
-            while(a_pInputData[uInputLen])
-            {
-                ++uInputLen;
-            }
-            ++uInputLen; // include the NULL char
-
-            // This uses the Unicode reference implementation to do the
-            // conversion from wchar_t to UTF-8. The required files are
-            // ConvertUTF.h and ConvertUTF.c which should be included in
-            // the distribution but are publically available from unicode.org
-            // at http://www.unicode.org/Public/PROGRAMS/CVTUTF/
-            ConversionResult retval;
-            UTF8* pUtf8 = (UTF8*) a_pOutputData;
-            if(sizeof(wchar_t) == sizeof(UTF32))
-            {
-                const UTF32* pUtf32 = (const UTF32*) a_pInputData;
-                retval = ConvertUTF32toUTF8(
-                             &pUtf32, pUtf32 + uInputLen,
-                             &pUtf8, pUtf8 + a_uOutputDataSize,
-                             lenientConversion);
-            }
-            else if(sizeof(wchar_t) == sizeof(UTF16))
-            {
-                const UTF16* pUtf16 = (const UTF16*) a_pInputData;
-                retval = ConvertUTF16toUTF8(
-                             &pUtf16, pUtf16 + uInputLen,
-                             &pUtf8, pUtf8 + a_uOutputDataSize,
-                             lenientConversion);
-            }
-            return retval == conversionOK;
-        }
-        else
-        {
-            size_t retval = wcstombs(a_pOutputData,
-                                     a_pInputData, a_uOutputDataSize);
-            return retval != (size_t) - 1;
-        }
-    }
-};
-
-#endif // SI_CONVERT_GENERIC
-
-
-// ---------------------------------------------------------------------------
-//                              SI_CONVERT_ICU
-// ---------------------------------------------------------------------------
-#ifdef SI_CONVERT_ICU
-
-#define SI_Case     SI_GenericCase
-#define SI_NoCase   SI_GenericNoCase
-
-#include 
-
-/**
- * Converts MBCS/UTF-8 to UChar using ICU. This can be used on all platforms.
- */
-template
-class SI_ConvertW
-{
-    const char* m_pEncoding;
-    UConverter* m_pConverter;
-protected:
-    SI_ConvertW() : m_pEncoding(NULL), m_pConverter(NULL) { }
-public:
-    SI_ConvertW(bool a_bStoreIsUtf8) : m_pConverter(NULL)
-    {
-        m_pEncoding = a_bStoreIsUtf8 ? "UTF-8" : NULL;
-    }
-
-    /* copy and assignment */
-    SI_ConvertW(const SI_ConvertW & rhs)
-    {
-        operator=(rhs);
-    }
-    SI_ConvertW & operator=(const SI_ConvertW & rhs)
-    {
-        m_pEncoding = rhs.m_pEncoding;
-        m_pConverter = NULL;
-        return *this;
-    }
-    ~SI_ConvertW()
-    {
-        if(m_pConverter) ucnv_close(m_pConverter);
-    }
-
-    /** Calculate the number of UChar required for converting the input
-     * from the storage format. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to UChar.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @return              Number of UChar required by the string when
-     *                      converted. If there are embedded NULL bytes in the
-     *                      input data, only the string up and not including
-     *                      the NULL byte will be converted.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen)
-    {
-        SI_ASSERT(a_uInputDataLen != (size_t) - 1);
-
-        UErrorCode nError;
-
-        if(!m_pConverter)
-        {
-            nError = U_ZERO_ERROR;
-            m_pConverter = ucnv_open(m_pEncoding, &nError);
-            if(U_FAILURE(nError))
-            {
-                return (size_t) - 1;
-            }
-        }
-
-        nError = U_ZERO_ERROR;
-        int32_t nLen = ucnv_toUChars(m_pConverter, NULL, 0,
-                                     a_pInputData, (int32_t) a_uInputDataLen, &nError);
-        if(U_FAILURE(nError) && nError != U_BUFFER_OVERFLOW_ERROR)
-        {
-            return (size_t) - 1;
-        }
-
-        return (size_t) nLen;
-    }
-
-    /** Convert the input string from the storage format to UChar.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to UChar.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @param a_pOutputData Pointer to the output buffer to received the
-     *                      converted data.
-     * @param a_uOutputDataSize Size of the output buffer in UChar.
-     * @return              true if all of the input data was successfully
-     *                      converted.
-     */
-    bool ConvertFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen,
-        UChar*          a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        UErrorCode nError;
-
-        if(!m_pConverter)
-        {
-            nError = U_ZERO_ERROR;
-            m_pConverter = ucnv_open(m_pEncoding, &nError);
-            if(U_FAILURE(nError))
-            {
-                return false;
-            }
-        }
-
-        nError = U_ZERO_ERROR;
-        ucnv_toUChars(m_pConverter,
-                      a_pOutputData, (int32_t) a_uOutputDataSize,
-                      a_pInputData, (int32_t) a_uInputDataLen, &nError);
-        if(U_FAILURE(nError))
-        {
-            return false;
-        }
-
-        return true;
-    }
-
-    /** Calculate the number of char required by the storage format of this
-     * data. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated string to calculate the number of
-     *                      bytes required to be converted to storage format.
-     * @return              Number of bytes required by the string when
-     *                      converted to storage format. This size always
-     *                      includes space for the terminating NULL character.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeToStore(
-        const UChar* a_pInputData)
-    {
-        UErrorCode nError;
-
-        if(!m_pConverter)
-        {
-            nError = U_ZERO_ERROR;
-            m_pConverter = ucnv_open(m_pEncoding, &nError);
-            if(U_FAILURE(nError))
-            {
-                return (size_t) - 1;
-            }
-        }
-
-        nError = U_ZERO_ERROR;
-        int32_t nLen = ucnv_fromUChars(m_pConverter, NULL, 0,
-                                       a_pInputData, -1, &nError);
-        if(U_FAILURE(nError) && nError != U_BUFFER_OVERFLOW_ERROR)
-        {
-            return (size_t) - 1;
-        }
-
-        return (size_t) nLen + 1;
-    }
-
-    /** Convert the input string to the storage format of this data.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated source string to convert. All of
-     *                      the data will be converted including the
-     *                      terminating NULL character.
-     * @param a_pOutputData Pointer to the buffer to receive the converted
-     *                      string.
-     * @param a_pOutputDataSize Size of the output buffer in char.
-     * @return              true if all of the input data, including the
-     *                      terminating NULL character was successfully
-     *                      converted.
-     */
-    bool ConvertToStore(
-        const UChar*    a_pInputData,
-        char*           a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        UErrorCode nError;
-
-        if(!m_pConverter)
-        {
-            nError = U_ZERO_ERROR;
-            m_pConverter = ucnv_open(m_pEncoding, &nError);
-            if(U_FAILURE(nError))
-            {
-                return false;
-            }
-        }
-
-        nError = U_ZERO_ERROR;
-        ucnv_fromUChars(m_pConverter,
-                        a_pOutputData, (int32_t) a_uOutputDataSize,
-                        a_pInputData, -1, &nError);
-        if(U_FAILURE(nError))
-        {
-            return false;
-        }
-
-        return true;
-    }
-};
-
-#endif // SI_CONVERT_ICU
-
-
-// ---------------------------------------------------------------------------
-//                              SI_CONVERT_WIN32
-// ---------------------------------------------------------------------------
-#ifdef SI_CONVERT_WIN32
-
-#define SI_Case     SI_GenericCase
-
-// Windows CE doesn't have errno or MBCS libraries
-#ifdef _WIN32_WCE
-# ifndef SI_NO_MBCS
-#  define SI_NO_MBCS
-# endif
-#endif
-
-#include 
-#ifdef SI_NO_MBCS
-# define SI_NoCase   SI_GenericNoCase
-#else // !SI_NO_MBCS
-/**
- * Case-insensitive comparison class using Win32 MBCS functions. This class
- * returns a case-insensitive semi-collation order for MBCS text. It may not
- * be safe for UTF-8 text returned in char format as we don't know what
- * characters will be folded by the function! Therefore, if you are using
- * SI_CHAR == char and SetUnicode(true), then you need to use the generic
- * SI_NoCase class instead.
- */
-#include 
-template
-struct SI_NoCase
-{
-    bool operator()(const SI_CHAR* pLeft, const SI_CHAR* pRight) const
-    {
-        if(sizeof(SI_CHAR) == sizeof(char))
-        {
-            return _mbsicmp((const unsigned char*)pLeft,
-                            (const unsigned char*)pRight) < 0;
-        }
-        if(sizeof(SI_CHAR) == sizeof(wchar_t))
-        {
-            return _wcsicmp((const wchar_t*)pLeft,
-                            (const wchar_t*)pRight) < 0;
-        }
-        return SI_GenericNoCase()(pLeft, pRight);
-    }
-};
-#endif // SI_NO_MBCS
-
-/**
- * Converts MBCS and UTF-8 to a wchar_t (or equivalent) on Windows. This uses
- * only the Win32 functions and doesn't require the external Unicode UTF-8
- * conversion library. It will not work on Windows 95 without using Microsoft
- * Layer for Unicode in your application.
- */
-template
-class SI_ConvertW
-{
-    UINT m_uCodePage;
-protected:
-    SI_ConvertW() { }
-public:
-    SI_ConvertW(bool a_bStoreIsUtf8)
-    {
-        m_uCodePage = a_bStoreIsUtf8 ? CP_UTF8 : CP_ACP;
-    }
-
-    /* copy and assignment */
-    SI_ConvertW(const SI_ConvertW & rhs)
-    {
-        operator=(rhs);
-    }
-    SI_ConvertW & operator=(const SI_ConvertW & rhs)
-    {
-        m_uCodePage = rhs.m_uCodePage;
-        return *this;
-    }
-
-    /** Calculate the number of SI_CHAR required for converting the input
-     * from the storage format. The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @return              Number of SI_CHAR required by the string when
-     *                      converted. If there are embedded NULL bytes in the
-     *                      input data, only the string up and not including
-     *                      the NULL byte will be converted.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen)
-    {
-        SI_ASSERT(a_uInputDataLen != (size_t) - 1);
-
-        int retval = MultiByteToWideChar(
-                         m_uCodePage, 0,
-                         a_pInputData, (int) a_uInputDataLen,
-                         0, 0);
-        return (size_t)(retval > 0 ? retval : -1);
-    }
-
-    /** Convert the input string from the storage format to SI_CHAR.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  Data in storage format to be converted to SI_CHAR.
-     * @param a_uInputDataLen Length of storage format data in bytes. This
-     *                      must be the actual length of the data, including
-     *                      NULL byte if NULL terminated string is required.
-     * @param a_pOutputData Pointer to the output buffer to received the
-     *                      converted data.
-     * @param a_uOutputDataSize Size of the output buffer in SI_CHAR.
-     * @return              true if all of the input data was successfully
-     *                      converted.
-     */
-    bool ConvertFromStore(
-        const char*     a_pInputData,
-        size_t          a_uInputDataLen,
-        SI_CHAR*        a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        int nSize = MultiByteToWideChar(
-                        m_uCodePage, 0,
-                        a_pInputData, (int) a_uInputDataLen,
-                        (wchar_t*) a_pOutputData, (int) a_uOutputDataSize);
-        return (nSize > 0);
-    }
-
-    /** Calculate the number of char required by the storage format of this
-     * data. The storage format is always UTF-8.
-     *
-     * @param a_pInputData  NULL terminated string to calculate the number of
-     *                      bytes required to be converted to storage format.
-     * @return              Number of bytes required by the string when
-     *                      converted to storage format. This size always
-     *                      includes space for the terminating NULL character.
-     * @return              -1 cast to size_t on a conversion error.
-     */
-    size_t SizeToStore(
-        const SI_CHAR* a_pInputData)
-    {
-        int retval = WideCharToMultiByte(
-                         m_uCodePage, 0,
-                         (const wchar_t*) a_pInputData, -1,
-                         0, 0, 0, 0);
-        return (size_t)(retval > 0 ? retval : -1);
-    }
-
-    /** Convert the input string to the storage format of this data.
-     * The storage format is always UTF-8 or MBCS.
-     *
-     * @param a_pInputData  NULL terminated source string to convert. All of
-     *                      the data will be converted including the
-     *                      terminating NULL character.
-     * @param a_pOutputData Pointer to the buffer to receive the converted
-     *                      string.
-     * @param a_pOutputDataSize Size of the output buffer in char.
-     * @return              true if all of the input data, including the
-     *                      terminating NULL character was successfully
-     *                      converted.
-     */
-    bool ConvertToStore(
-        const SI_CHAR* a_pInputData,
-        char*           a_pOutputData,
-        size_t          a_uOutputDataSize)
-    {
-        int retval = WideCharToMultiByte(
-                         m_uCodePage, 0,
-                         (const wchar_t*) a_pInputData, -1,
-                         a_pOutputData, (int) a_uOutputDataSize, 0, 0);
-        return retval > 0;
-    }
-};
-
-#endif // SI_CONVERT_WIN32
-
-
-// ---------------------------------------------------------------------------
-//                                  TYPE DEFINITIONS
-// ---------------------------------------------------------------------------
-
-typedef CSimpleIniTempl, SI_ConvertA >                 CSimpleIniA;
-typedef CSimpleIniTempl, SI_ConvertA >                   CSimpleIniCaseA;
-
-#if defined(SI_CONVERT_ICU)
-typedef CSimpleIniTempl, SI_ConvertW >               CSimpleIniW;
-typedef CSimpleIniTempl, SI_ConvertW >                 CSimpleIniCaseW;
-#else
-typedef CSimpleIniTempl, SI_ConvertW >           CSimpleIniW;
-typedef CSimpleIniTempl, SI_ConvertW >             CSimpleIniCaseW;
-#endif
-
-#ifdef _UNICODE
-# define CSimpleIni      CSimpleIniW
-# define CSimpleIniCase  CSimpleIniCaseW
-# define SI_NEWLINE      SI_NEWLINE_W
-#else // !_UNICODE
-# define CSimpleIni      CSimpleIniA
-# define CSimpleIniCase  CSimpleIniCaseA
-# define SI_NEWLINE      SI_NEWLINE_A
-#endif // _UNICODE
-
-#ifdef _MSC_VER
-# pragma warning (pop)
-#endif
-
-#endif // INCLUDED_SimpleIni_h
-
diff --git a/x64_dbg_bridge/x64_dbg_bridge.vcxproj b/x64_dbg_bridge/x64_dbg_bridge.vcxproj
index a1eb095a..09b5a7b6 100644
--- a/x64_dbg_bridge/x64_dbg_bridge.vcxproj
+++ b/x64_dbg_bridge/x64_dbg_bridge.vcxproj
@@ -24,7 +24,7 @@
   
   
     
-    
+    
     
   
   
diff --git a/x64_dbg_bridge/x64_dbg_bridge.vcxproj.filters b/x64_dbg_bridge/x64_dbg_bridge.vcxproj.filters
index bdefd68a..7cf3c3d1 100644
--- a/x64_dbg_bridge/x64_dbg_bridge.vcxproj.filters
+++ b/x64_dbg_bridge/x64_dbg_bridge.vcxproj.filters
@@ -25,7 +25,7 @@
     
       Header Files
     
-    
+    
       Header Files
     
   
diff --git a/x64_dbg_gui/Project/Src/Gui/AppearanceDialog.cpp b/x64_dbg_gui/Project/Src/Gui/AppearanceDialog.cpp
index 95eb4daa..9a052bc7 100644
--- a/x64_dbg_gui/Project/Src/Gui/AppearanceDialog.cpp
+++ b/x64_dbg_gui/Project/Src/Gui/AppearanceDialog.cpp
@@ -326,6 +326,7 @@ void AppearanceDialog::on_buttonSave_clicked()
     Config()->writeColors();
     Config()->writeFonts();
     GuiUpdateAllViews();
+    BridgeSettingFlush();
     GuiAddStatusBarMessage("Settings saved!\n");
 }
 
diff --git a/x64_dbg_gui/Project/Src/Gui/SettingsDialog.cpp b/x64_dbg_gui/Project/Src/Gui/SettingsDialog.cpp
index 7f245bb4..86be1ea2 100644
--- a/x64_dbg_gui/Project/Src/Gui/SettingsDialog.cpp
+++ b/x64_dbg_gui/Project/Src/Gui/SettingsDialog.cpp
@@ -297,6 +297,7 @@ void SettingsDialog::SaveSettings()
     if(settings.miscSymbolCache)
         BridgeSettingSet("Symbols", "CachePath", ui->editSymbolCache->text().toUtf8().constData());
 
+    BridgeSettingFlush();
     Config()->load();
     DbgSettingsUpdated();
     GuiUpdateAllViews();