X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c801d85f158c4cba50b588807daabdcbd0ed3853..e09526489246ee620c62c1b5673d294fff89b736:/src/common/fileconf.cpp diff --git a/src/common/fileconf.cpp b/src/common/fileconf.cpp index d12bc8bf80..45ea8251d0 100644 --- a/src/common/fileconf.cpp +++ b/src/common/fileconf.cpp @@ -2,7 +2,7 @@ // Name: fileconf.cpp // Purpose: implementation of wxFileConfig derivation of wxConfig // Author: Vadim Zeitlin -// Modified by: +// Modified by: // Created: 07.04.98 (adapted from appconf.cpp) // RCS-ID: $Id$ // Copyright: (c) 1997 Karsten Ballüder & Vadim Zeitlin @@ -10,311 +10,244 @@ // Licence: wxWindows license /////////////////////////////////////////////////////////////////////////////// -// ============================================================================ -// declarations -// ============================================================================ +#ifdef __GNUG__ +#pragma implementation "fileconf.h" +#endif // ---------------------------------------------------------------------------- // headers // ---------------------------------------------------------------------------- + #include "wx/wxprec.h" #ifdef __BORLANDC__ #pragma hdrstop #endif //__BORLANDC__ +#if wxUSE_CONFIG + #ifndef WX_PRECOMP - #include - #include + #include "wx/string.h" + #include "wx/intl.h" #endif //WX_PRECOMP -#include -#include -#include -#include -#include +#include "wx/app.h" +#include "wx/dynarray.h" +#include "wx/file.h" +#include "wx/log.h" +#include "wx/textfile.h" +#include "wx/memtext.h" +#include "wx/config.h" +#include "wx/fileconf.h" + +#if wxUSE_STREAMS + #include "wx/stream.h" +#endif // wxUSE_STREAMS -#ifdef __WINDOWS__ -#include +#include "wx/utils.h" // for wxGetHomeDir + +#if defined(__WXMAC__) + #include "wx/mac/private.h" // includes mac headers +#endif + +#if defined(__WXMSW__) + #include "wx/msw/private.h" +#endif //windows.h +#if defined(__WXPM__) + #define INCL_DOS + #include #endif -#include -#include +#include +#include + +// headers needed for umask() +#ifdef __UNIX__ + #include + #include +#endif // __UNIX__ // ---------------------------------------------------------------------------- -// global functions declarations +// macros // ---------------------------------------------------------------------------- +#define CONST_CAST ((wxFileConfig *)this)-> -// is 'c' a valid character in group name? -// NB: APPCONF_IMMUTABLE_PREFIX and APPCONF_PATH_SEPARATOR must be valid chars, -// but _not_ ']' (group name delimiter) -inline bool IsValid(char c) { return isalnum(c) || strchr("_/-!.*%", c); } +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +#ifndef MAX_PATH + #define MAX_PATH 512 +#endif -// get the system wide and user configuration file full path -static const char *GetGlobalFileName(const char *szFile); -static const char *GetLocalFileName(const char *szFile); +// ---------------------------------------------------------------------------- +// global functions declarations +// ---------------------------------------------------------------------------- -// split path into parts removing '..' in progress -static void SplitPath(wxArrayString& aParts, const char *sz); +// compare functions for sorting the arrays +static int LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2); +static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2); // filter strings -static wxString FilterIn(const wxString& str); -static wxString FilterOut(const wxString& str); +static wxString FilterInValue(const wxString& str); +static wxString FilterOutValue(const wxString& str); + +static wxString FilterInEntryName(const wxString& str); +static wxString FilterOutEntryName(const wxString& str); + +// get the name to use in wxFileConfig ctor +static wxString GetAppName(const wxString& appname); + +// ============================================================================ +// private classes +// ============================================================================ // ---------------------------------------------------------------------------- -// wxFileConfig +// "template" array types // ---------------------------------------------------------------------------- -/* - FileConfig derives from BaseConfig and implements file based config class, - i.e. it uses ASCII disk files to store the information. These files are - alternatively called INI, .conf or .rc in the documentation. They are - organized in groups or sections, which can nest (i.e. a group contains - subgroups, which contain their own subgroups &c). Each group has some - number of entries, which are "key = value" pairs. More precisely, the format - is: - - # comments are allowed after either ';' or '#' (Win/UNIX standard) - - # blank lines (as above) are ignored - - # global entries are members of special (no name) top group - written_for = wxWindows - platform = Linux - - # the start of the group 'Foo' - [Foo] # may put comments like this also - # following 3 lines are entries - key = value - another_key = " strings with spaces in the beginning should be quoted, \ - otherwise the spaces are lost" - last_key = but you don't have to put " normally (nor quote them, like here) - - # subgroup of the group 'Foo' - # (order is not important, only the name is: separator is '/', as in paths) - [Foo/Bar] - # entries prefixed with "!" are immutable, i.e. can't be changed if they are - # set in the system-wide config file - !special_key = value - bar_entry = whatever - - [Foo/Bar/Fubar] # depth is (theoretically :-) unlimited - # may have the same name as key in another section - bar_entry = whatever not - - You have {read/write/delete}Entry functions (guess what they do) and also - setCurrentPath to select current group. enum{Subgroups/Entries} allow you - to get all entries in the config file (in the current group). Finally, - flush() writes immediately all changed entries to disk (otherwise it would - be done automatically in dtor) - - FileConfig manages not less than 2 config files for each program: global - and local (or system and user if you prefer). Entries are read from both of - them and the local entries override the global ones unless the latter is - immutable (prefixed with '!') in which case a warning message is generated - and local value is ignored. Of course, the changes are always written to local - file only. -*/ +WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries); +WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups); + +// ---------------------------------------------------------------------------- +// wxFileConfigLineList +// ---------------------------------------------------------------------------- -class wxFileConfig : public wxConfig +// we store all lines of the local config file as a linked list in memory +class wxFileConfigLineList { public: - // ctor & dtor - // the config file is searched in the following locations - // global local - // Unix /etc/file.ext ~/.file - // Win %windir%\file.ext %USERPROFILE%\file.ext - // - // where file is the basename of strFile, ext is it's extension - // or .conf (Unix) or .ini (Win) if it has none - wxFileConfig(const wxString& strFile, bool bLocalOnly = FALSE); - // dtor will save unsaved data - virtual ~wxFileConfig(); - - // implement inherited pure virtual functions - virtual void SetPath(const wxString& strPath); - virtual const wxString& GetPath() const { return m_strPath; } - - virtual bool GetFirstGroup(wxString& str, long& lIndex); - virtual bool GetNextGroup (wxString& str, long& lIndex); - virtual bool GetFirstEntry(wxString& str, long& lIndex); - virtual bool GetNextEntry (wxString& str, long& lIndex); - - virtual const char *Read(const char *szKey, const char *szDefault = 0) const; - virtual long Read(const char *szKey, long lDefault) const; - virtual bool Write(const char *szKey, const char *szValue); - virtual bool Write(const char *szKey, long Value); - virtual bool Flush(bool bCurrentOnly = FALSE); - - virtual bool DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso); - virtual bool DeleteGroup(const char *szKey); - virtual bool DeleteAll(); + void SetNext(wxFileConfigLineList *pNext) { m_pNext = pNext; } + void SetPrev(wxFileConfigLineList *pPrev) { m_pPrev = pPrev; } -public: - // fwd decl - class ConfigGroup; - class ConfigEntry; + // ctor + wxFileConfigLineList(const wxString& str, + wxFileConfigLineList *pNext = NULL) : m_strLine(str) + { SetNext(pNext); SetPrev(NULL); } - // we store all lines of the local config file as a linked list in memory - class LineList - { - public: - // ctor - LineList(const wxString& str, LineList *pNext = NULL) : m_strLine(str) - { SetNext(pNext); } - - // - LineList *Next() const { return m_pNext; } - void SetNext(LineList *pNext) { m_pNext = pNext; } + // next/prev nodes in the linked list + wxFileConfigLineList *Next() const { return m_pNext; } + wxFileConfigLineList *Prev() const { return m_pPrev; } - // - void SetText(const wxString& str) { m_strLine = str; } - const wxString& Text() const { return m_strLine; } - - private: - wxString m_strLine; // line contents - LineList *m_pNext; // next node - }; - - // functions to work with this list - LineList *LineListAppend(const wxString& str); - LineList *LineListInsert(const wxString& str, - LineList *pLine); // NULL => Append() - bool LineListIsEmpty(); + // get/change lines text + void SetText(const wxString& str) { m_strLine = str; } + const wxString& Text() const { return m_strLine; } private: - // put the object in the initial state - void Init(); + wxString m_strLine; // line contents + wxFileConfigLineList *m_pNext, // next node + *m_pPrev; // previous one +}; - // parse the whole file - void Parse(wxTextFile& file, bool bLocal); +// ---------------------------------------------------------------------------- +// wxFileConfigEntry: a name/value pair +// ---------------------------------------------------------------------------- - // the same as SetPath("/") - void SetRootPath(); +class wxFileConfigEntry +{ +private: + wxFileConfigGroup *m_pParent; // group that contains us - // member variables - // ---------------- - LineList *m_linesHead, // head of the linked list - *m_linesTail; // tail + wxString m_strName, // entry name + m_strValue; // value + bool m_bDirty:1, // changed since last read? + m_bImmutable:1, // can be overriden locally? + m_bHasValue:1; // set after first call to SetValue() - wxString m_strFile; // file name passed to ctor - wxString m_strPath; // current path (not '/' terminated) + int m_nLine; // used if m_pLine == NULL only - ConfigGroup *m_pRootGroup, // the top (unnamed) group - *m_pCurrentGroup; // the current group + // pointer to our line in the linked list or NULL if it was found in global + // file (which we don't modify) + wxFileConfigLineList *m_pLine; - // a handy little class which changes current path to the path of given entry - // and restores it in dtor: so if you declare a local variable of this type, - // you work in the entry directory and the path is automatically restored - // when function returns - class PathChanger - { - public: - // ctor/dtor do path changing/restorin - PathChanger(const wxFileConfig *pContainer, const wxString& strEntry); - ~PathChanger(); - - // get the key name - const wxString& Name() const { return m_strName; } - - private: - wxFileConfig *m_pContainer; // object we live in - wxString m_strName, // name of entry (i.e. name only) - m_strOldPath; // saved path - bool m_bChanged; // was the path changed? - }; - -//protected: --- if FileConfig::ConfigEntry is not public, functions in -// ConfigGroup such as Find/AddEntry can't return "ConfigEntry *" public: - WX_DEFINE_ARRAY(ConfigEntry *, ArrayEntries); - WX_DEFINE_ARRAY(ConfigGroup *, ArrayGroups); + wxFileConfigEntry(wxFileConfigGroup *pParent, + const wxString& strName, int nLine); + + // simple accessors + const wxString& Name() const { return m_strName; } + const wxString& Value() const { return m_strValue; } + wxFileConfigGroup *Group() const { return m_pParent; } + bool IsDirty() const { return m_bDirty; } + bool IsImmutable() const { return m_bImmutable; } + bool IsLocal() const { return m_pLine != 0; } + int Line() const { return m_nLine; } + wxFileConfigLineList * + GetLine() const { return m_pLine; } + + // modify entry attributes + void SetValue(const wxString& strValue, bool bUser = TRUE); + void SetDirty(); + void SetLine(wxFileConfigLineList *pLine); +}; - class ConfigEntry - { - private: - ConfigGroup *m_pParent; // group that contains us - wxString m_strName, // entry name - m_strValue; // value - bool m_bDirty, // changed since last read? - m_bImmutable; // can be overriden locally? - int m_nLine; // used if m_pLine == NULL only - LineList *m_pLine; // pointer to our line in the linked list - // or NULL if it was found in global file - - public: - ConfigEntry(ConfigGroup *pParent, const wxString& strName, int nLine); - - // simple accessors - const wxString& Name() const { return m_strName; } - const wxString& Value() const { return m_strValue; } - ConfigGroup *Group() const { return m_pParent; } - bool IsDirty() const { return m_bDirty; } - bool IsImmutable() const { return m_bImmutable; } - bool IsLocal() const { return m_pLine != 0; } - int Line() const { return m_nLine; } - LineList *GetLine() const { return m_pLine; } - - // modify entry attributes - void SetValue(const wxString& strValue, bool bUser = TRUE); - void SetDirty(); - void SetLine(LineList *pLine); - }; - -protected: - class ConfigGroup - { - private: - wxFileConfig *m_pConfig; // config object we belong to - ConfigGroup *m_pParent; // parent group (NULL for root group) - ArrayEntries m_aEntries; // entries in this group - ArrayGroups m_aSubgroups; // subgroups - wxString m_strName; // group's name - bool m_bDirty; // if FALSE => all subgroups are not dirty - LineList *m_pLine; // pointer to our line in the linked list - int m_nLastEntry, // last here means "last added" - m_nLastGroup; // - - public: - // ctor - ConfigGroup(ConfigGroup *pParent, const wxString& strName, wxFileConfig *); - - // dtor deletes all entries and subgroups also - ~ConfigGroup(); - - // simple accessors - const wxString& Name() const { return m_strName; } - ConfigGroup *Parent() const { return m_pParent; } - wxFileConfig *Config() const { return m_pConfig; } - bool IsDirty() const { return m_bDirty; } - - bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); } - const ArrayEntries& Entries() const { return m_aEntries; } - const ArrayGroups& Groups() const { return m_aSubgroups; } - - // find entry/subgroup (NULL if not found) - ConfigGroup *FindSubgroup(const char *szName) const; - ConfigEntry *FindEntry (const char *szName) const; - - // delete entry/subgroup, return FALSE if doesn't exist - bool DeleteSubgroup(const char *szName); - bool DeleteEntry(const char *szName); - - // create new entry/subgroup returning pointer to newly created element - ConfigGroup *AddSubgroup(const wxString& strName); - ConfigEntry *AddEntry (const wxString& strName, int nLine = NOT_FOUND); - - // will also recursively set parent's dirty flag - void SetDirty(); - void SetLine(LineList *pLine); - - wxString GetFullName() const; - - // get the last line belonging to an entry/subgroup of this group - LineList *GetGroupLine(); - LineList *GetLastEntryLine(); - LineList *GetLastGroupLine(); - }; +// ---------------------------------------------------------------------------- +// wxFileConfigGroup: container of entries and other groups +// ---------------------------------------------------------------------------- + +class wxFileConfigGroup +{ +private: + wxFileConfig *m_pConfig; // config object we belong to + wxFileConfigGroup *m_pParent; // parent group (NULL for root group) + ArrayEntries m_aEntries; // entries in this group + ArrayGroups m_aSubgroups; // subgroups + wxString m_strName; // group's name + bool m_bDirty; // if FALSE => all subgroups are not dirty + wxFileConfigLineList *m_pLine; // pointer to our line in the linked list + wxFileConfigEntry *m_pLastEntry; // last entry/subgroup of this group in the + wxFileConfigGroup *m_pLastGroup; // local file (we insert new ones after it) + + // DeleteSubgroupByName helper + bool DeleteSubgroup(wxFileConfigGroup *pGroup); + +public: + // ctor + wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *); + + // dtor deletes all entries and subgroups also + ~wxFileConfigGroup(); + + // simple accessors + const wxString& Name() const { return m_strName; } + wxFileConfigGroup *Parent() const { return m_pParent; } + wxFileConfig *Config() const { return m_pConfig; } + bool IsDirty() const { return m_bDirty; } + + const ArrayEntries& Entries() const { return m_aEntries; } + const ArrayGroups& Groups() const { return m_aSubgroups; } + bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); } + + // find entry/subgroup (NULL if not found) + wxFileConfigGroup *FindSubgroup(const wxChar *szName) const; + wxFileConfigEntry *FindEntry (const wxChar *szName) const; + + // delete entry/subgroup, return FALSE if doesn't exist + bool DeleteSubgroupByName(const wxChar *szName); + bool DeleteEntry(const wxChar *szName); + + // create new entry/subgroup returning pointer to newly created element + wxFileConfigGroup *AddSubgroup(const wxString& strName); + wxFileConfigEntry *AddEntry (const wxString& strName, int nLine = wxNOT_FOUND); + + // will also recursively set parent's dirty flag + void SetDirty(); + void SetLine(wxFileConfigLineList *pLine); + + // rename: no checks are done to ensure that the name is unique! + void Rename(const wxString& newName); + + // + wxString GetFullName() const; + + // get the last line belonging to an entry/subgroup of this group + wxFileConfigLineList *GetGroupLine(); // line which contains [group] + wxFileConfigLineList *GetLastEntryLine(); // after which our subgroups start + wxFileConfigLineList *GetLastGroupLine(); // after which the next group starts + + // called by entries/subgroups when they're created/deleted + void SetLastEntry(wxFileConfigEntry *pEntry) { m_pLastEntry = pEntry; } + void SetLastGroup(wxFileConfigGroup *pGroup) { m_pLastGroup = pGroup; } }; // ============================================================================ @@ -322,105 +255,338 @@ protected: // ============================================================================ // ---------------------------------------------------------------------------- -// ctor +// static functions // ---------------------------------------------------------------------------- +wxString wxFileConfig::GetGlobalDir() +{ + wxString strDir; + + #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined + strDir = wxT("sys$manager:"); + #elif defined(__WXMAC__) + strDir = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ; + #elif defined( __UNIX__ ) + strDir = wxT("/etc/"); + #elif defined(__WXPM__) + ULONG aulSysInfo[QSV_MAX] = {0}; + UINT drive; + APIRET rc; + + rc = DosQuerySysInfo( 1L, QSV_MAX, (PVOID)aulSysInfo, sizeof(ULONG)*QSV_MAX); + if (rc == 0) + { + drive = aulSysInfo[QSV_BOOT_DRIVE - 1]; + strDir.Printf(wxT("%c:\\OS2\\"), 'A'+drive-1); + } + #elif defined(__WXSTUBS__) + wxASSERT_MSG( FALSE, wxT("TODO") ) ; + #elif defined(__DOS__) + // There's no such thing as global cfg dir in MS-DOS, let's return + // current directory (FIXME_MGL?) + return wxT(".\\"); + #else // Windows + wxChar szWinDir[MAX_PATH]; + ::GetWindowsDirectory(szWinDir, MAX_PATH); + + strDir = szWinDir; + strDir << wxT('\\'); + #endif // Unix/Windows + + return strDir; +} -void wxFileConfig::Init() +wxString wxFileConfig::GetLocalDir() { - m_pCurrentGroup = - m_pRootGroup = new ConfigGroup(NULL, "", this); + wxString strDir; + +#if defined(__WXMAC__) || defined(__DOS__) + // no local dir concept on Mac OS 9 or MS-DOS + return GetGlobalDir() ; +#else + wxGetHomeDir(&strDir); + +# ifdef __UNIX__ +# ifdef __VMS + if (strDir.Last() != wxT(']')) +# endif + if (strDir.Last() != wxT('/')) strDir << wxT('/'); +# else + if (strDir.Last() != wxT('\\')) strDir << wxT('\\'); +# endif +#endif - m_linesHead = - m_linesTail = NULL; + return strDir; +} + +wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile) +{ + wxString str = GetGlobalDir(); + str << szFile; + + if ( wxStrchr(szFile, wxT('.')) == NULL ) + #if defined( __WXMAC__ ) + str << " Preferences"; + #elif defined( __UNIX__ ) + str << wxT(".conf"); + #else // Windows + str << wxT(".ini"); + #endif // UNIX/Win - m_bExpandEnvVars = TRUE; + return str; +} - m_strPath.Empty(); +wxString wxFileConfig::GetLocalFileName(const wxChar *szFile) +{ +#ifdef __VMS__ // On VMS I saw the problem that the home directory was appended + // twice for the configuration file. Does that also happen for other + // platforms? + wxString str = wxT( '.' ); +#else + wxString str = GetLocalDir(); +#endif + + #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ ) + str << wxT('.'); + #endif + + str << szFile; + + #if defined(__WINDOWS__) || defined(__DOS__) + if ( wxStrchr(szFile, wxT('.')) == NULL ) + str << wxT(".ini"); + #endif + + #ifdef __WXMAC__ + str << " Preferences"; + #endif + return str; } -wxFileConfig::wxFileConfig(const wxString& strFile, bool bLocalOnly) - : m_strFile(strFile) +// ---------------------------------------------------------------------------- +// ctor +// ---------------------------------------------------------------------------- + +void wxFileConfig::Init() { - Init(); + m_pCurrentGroup = + m_pRootGroup = new wxFileConfigGroup(NULL, "", this); - const char *szFile; + m_linesHead = + m_linesTail = NULL; // it's not an error if (one of the) file(s) doesn't exist // parse the global file - if ( !bLocalOnly ) { - szFile = GetGlobalFileName(strFile); - if ( wxFile::Exists(szFile) ) { - wxTextFile fileGlobal(szFile); - - if ( fileGlobal.Open() ) { - Parse(fileGlobal, FALSE /* global */); - SetRootPath(); - } - else - wxLogWarning("Can't open global configuration file."); + if ( !m_strGlobalFile.IsEmpty() && wxFile::Exists(m_strGlobalFile) ) { + wxTextFile fileGlobal(m_strGlobalFile); + + if ( fileGlobal.Open() ) { + Parse(fileGlobal, FALSE /* global */); + SetRootPath(); } + else + wxLogWarning(_("can't open global configuration file '%s'."), + m_strGlobalFile.c_str()); } // parse the local file - szFile = GetLocalFileName(strFile); - if ( wxFile::Exists(szFile) ) { - wxTextFile fileLocal(szFile); + if ( !m_strLocalFile.IsEmpty() && wxFile::Exists(m_strLocalFile) ) { + wxTextFile fileLocal(m_strLocalFile); if ( fileLocal.Open() ) { Parse(fileLocal, TRUE /* local */); SetRootPath(); } else - wxLogWarning("Can't open user configuration file."); + wxLogWarning(_("can't open user configuration file '%s'."), + m_strLocalFile.c_str()); + } +} + +// constructor supports creation of wxFileConfig objects of any type +wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName, + const wxString& strLocal, const wxString& strGlobal, + long style) + : wxConfigBase(::GetAppName(appName), vendorName, + strLocal, strGlobal, + style), + m_strLocalFile(strLocal), m_strGlobalFile(strGlobal) +{ + // Make up names for files if empty + if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) ) + { + m_strLocalFile = GetLocalFileName(GetAppName()); + } + + if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) ) + { + m_strGlobalFile = GetGlobalFileName(GetAppName()); + } + + // Check if styles are not supplied, but filenames are, in which case + // add the correct styles. + if ( !m_strLocalFile.IsEmpty() ) + SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE); + + if ( !m_strGlobalFile.IsEmpty() ) + SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE); + + // if the path is not absolute, prepend the standard directory to it + // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set + if ( !(style & wxCONFIG_USE_RELATIVE_PATH) ) + { + if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) ) + { + wxString strLocal = m_strLocalFile; + m_strLocalFile = GetLocalDir(); + m_strLocalFile << strLocal; + } + + if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) ) + { + wxString strGlobal = m_strGlobalFile; + m_strGlobalFile = GetGlobalDir(); + m_strGlobalFile << strGlobal; + } + } + + SetUmask(-1); + + Init(); +} + +#if wxUSE_STREAMS + +wxFileConfig::wxFileConfig(wxInputStream &inStream) +{ + // always local_file when this constructor is called (?) + SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE); + + m_pCurrentGroup = + m_pRootGroup = new wxFileConfigGroup(NULL, "", this); + + m_linesHead = + m_linesTail = NULL; + + // translate everything to the current (platform-dependent) line + // termination character + wxString strTrans; + { + wxString strTmp; + + char buf[1024]; + while ( !inStream.Read(buf, WXSIZEOF(buf)).Eof() ) + strTmp.append(wxConvertMB2WX(buf), inStream.LastRead()); + + strTmp.append(wxConvertMB2WX(buf), inStream.LastRead()); + + strTrans = wxTextBuffer::Translate(strTmp); + } + + wxMemoryText memText; + + // Now we can add the text to the memory text. To do this we extract line + // by line from the translated string, until we've reached the end. + // + // VZ: all this is horribly inefficient, we should do the translation on + // the fly in one pass saving both memory and time (TODO) + + const wxChar *pEOL = wxTextBuffer::GetEOL(wxTextBuffer::typeDefault); + const size_t EOLLen = wxStrlen(pEOL); + + int posLineStart = strTrans.Find(pEOL); + while ( posLineStart != -1 ) + { + wxString line(strTrans.Left(posLineStart)); + + memText.AddLine(line); + + strTrans = strTrans.Mid(posLineStart + EOLLen); + + posLineStart = strTrans.Find(pEOL); + } + + // also add whatever we have left in the translated string. + memText.AddLine(strTrans); + + // Finally we can parse it all. + Parse(memText, TRUE /* local */); + + SetRootPath(); +} + +#endif // wxUSE_STREAMS + +void wxFileConfig::CleanUp() +{ + delete m_pRootGroup; + + wxFileConfigLineList *pCur = m_linesHead; + while ( pCur != NULL ) { + wxFileConfigLineList *pNext = pCur->Next(); + delete pCur; + pCur = pNext; } } wxFileConfig::~wxFileConfig() { Flush(); - delete m_pRootGroup; + + CleanUp(); } // ---------------------------------------------------------------------------- // parse a config file // ---------------------------------------------------------------------------- -void wxFileConfig::Parse(wxTextFile& file, bool bLocal) +void wxFileConfig::Parse(wxTextBuffer& buffer, bool bLocal) { - const char *pStart; - const char *pEnd; - - for ( uint n = 0; n < file.GetLineCount(); n++ ) { + const wxChar *pStart; + const wxChar *pEnd; + wxString strLine; + + size_t nLineCount = buffer.GetLineCount(); + for ( size_t n = 0; n < nLineCount; n++ ) { + strLine = buffer[n]; + // add the line to linked list if ( bLocal ) - LineListAppend(file[n]); + LineListAppend(strLine); // skip leading spaces - for ( pStart = file[n]; isspace(*pStart); pStart++ ) + for ( pStart = strLine; wxIsspace(*pStart); pStart++ ) ; // skip blank/comment lines - if ( *pStart == '\0'|| *pStart == ';' || *pStart == '#' ) + if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') ) continue; - if ( *pStart == '[' ) { // a new group + if ( *pStart == wxT('[') ) { // a new group pEnd = pStart; - while ( *++pEnd != ']' ) { - if ( !IsValid(*pEnd) && *pEnd != ' ' ) // allow spaces in group names - break; + while ( *++pEnd != wxT(']') ) { + if ( *pEnd == wxT('\\') ) { + // the next char is escaped, so skip it even if it is ']' + pEnd++; + } + + if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) { + // we reached the end of line, break out of the loop + break; + } } - if ( *pEnd != ']' ) { - wxLogError("file '%s': unexpected character at line %d (missing ']'?)", - file.GetName(), n + 1); + if ( *pEnd != wxT(']') ) { + wxLogError(_("file '%s': unexpected character %c at line %d."), + buffer.GetName(), *pEnd, n + 1); continue; // skip this line } // group name here is always considered as abs path wxString strGroup; pStart++; - strGroup << APPCONF_PATH_SEPARATOR << wxString(pStart, pEnd - pStart); + strGroup << wxCONFIG_PATH_SEPARATOR + << FilterInEntryName(wxString(pStart, pEnd - pStart)); // will create it if doesn't yet exist SetPath(strGroup); @@ -430,41 +596,53 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) // check that there is nothing except comments left on this line bool bCont = TRUE; - while ( *++pEnd != '\0' && bCont ) { + while ( *++pEnd != wxT('\0') && bCont ) { switch ( *pEnd ) { - case '#': - case ';': + case wxT('#'): + case wxT(';'): bCont = FALSE; break; - - case ' ': - case '\t': + + case wxT(' '): + case wxT('\t'): // ignore whitespace ('\n' impossible here) break; - + default: - wxLogWarning("file '%s', line %d: '%s' ignored after group header.", - file.GetName(), n + 1, pEnd); + wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."), + buffer.GetName(), n + 1, pEnd); bCont = FALSE; } } } else { // a key - const char *pEnd = pStart; - while ( IsValid(*pEnd) ) + const wxChar *pEnd = pStart; + while ( *pEnd && *pEnd != wxT('=') && !wxIsspace(*pEnd) ) { + if ( *pEnd == wxT('\\') ) { + // next character may be space or not - still take it because it's + // quoted (unless there is nothing) + pEnd++; + if ( !*pEnd ) { + // the error message will be given below anyhow + break; + } + } + pEnd++; + } - wxString strKey(pStart, pEnd); + wxString strKey(FilterInEntryName(wxString(pStart, pEnd))); // skip whitespace - while ( isspace(*pEnd) ) + while ( wxIsspace(*pEnd) ) pEnd++; - if ( *pEnd++ != '=' ) { - wxLogError("file '%s', line %d: '=' expected.", file.GetName(), n + 1); + if ( *pEnd++ != wxT('=') ) { + wxLogError(_("file '%s', line %d: '=' expected."), + buffer.GetName(), n + 1); } else { - ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey); + wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey); if ( pEntry == NULL ) { // new entry @@ -476,8 +654,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) else { if ( bLocal && pEntry->IsImmutable() ) { // immutable keys can't be changed by user - wxLogWarning("file '%s', line %d: value for immutable key '%s' ignored.", - file.GetName(), n + 1, strKey.c_str()); + wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."), + buffer.GetName(), n + 1, strKey.c_str()); continue; } // the condition below catches the cases (a) and (b) but not (c): @@ -486,8 +664,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) // (c) key from global file now found in local one // which is exactly what we want. else if ( !bLocal || pEntry->IsLocal() ) { - wxLogWarning("file '%s', line %d: key '%s' was first found at line %d.", - file.GetName(), n + 1, strKey.c_str(), pEntry->Line()); + wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."), + buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line()); if ( bLocal ) pEntry->SetLine(m_linesTail); @@ -495,15 +673,10 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) } // skip whitespace - while ( isspace(*pEnd) ) + while ( wxIsspace(*pEnd) ) pEnd++; - wxString strValue; - if (m_bExpandEnvVars) - strValue = ExpandEnvVars(FilterIn(pEnd)); - else - strValue = FilterIn(pEnd); - pEntry->SetValue(strValue, FALSE); + pEntry->SetValue(FilterInValue(pEnd), FALSE /* read from file */); } } } @@ -523,25 +696,27 @@ void wxFileConfig::SetPath(const wxString& strPath) { wxArrayString aParts; - if ( strPath.IsEmpty() ) + if ( strPath.IsEmpty() ) { + SetRootPath(); return; + } - if ( strPath[0] == APPCONF_PATH_SEPARATOR ) { + if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) { // absolute path - SplitPath(aParts, strPath); + wxSplitPath(aParts, strPath); } else { // relative path, combine with current one wxString strFullPath = m_strPath; - strFullPath << APPCONF_PATH_SEPARATOR << strPath; - SplitPath(aParts, strFullPath); + strFullPath << wxCONFIG_PATH_SEPARATOR << strPath; + wxSplitPath(aParts, strFullPath); } // change current group - uint n; + size_t n; m_pCurrentGroup = m_pRootGroup; for ( n = 0; n < aParts.Count(); n++ ) { - ConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]); + wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]); if ( pNextGroup == NULL ) pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]); m_pCurrentGroup = pNextGroup; @@ -550,7 +725,7 @@ void wxFileConfig::SetPath(const wxString& strPath) // recombine path parts in one variable m_strPath.Empty(); for ( n = 0; n < aParts.Count(); n++ ) { - m_strPath << APPCONF_PATH_SEPARATOR << aParts[n]; + m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n]; } } @@ -558,119 +733,276 @@ void wxFileConfig::SetPath(const wxString& strPath) // enumeration // ---------------------------------------------------------------------------- -bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) +bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const { lIndex = 0; return GetNextGroup(str, lIndex); } -bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) +bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const { - if ( uint(lIndex) < m_pCurrentGroup->Groups().Count() ) { - str = m_pCurrentGroup->Groups()[lIndex++]->Name(); + if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) { + str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name(); return TRUE; } else return FALSE; } -bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) +bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const { lIndex = 0; return GetNextEntry(str, lIndex); } -bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) +bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const { - if ( uint(lIndex) < m_pCurrentGroup->Entries().Count() ) { - str = m_pCurrentGroup->Entries()[lIndex++]->Name(); + if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) { + str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name(); return TRUE; } else return FALSE; } +size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const +{ + size_t n = m_pCurrentGroup->Entries().Count(); + if ( bRecursive ) { + wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup; + size_t nSubgroups = m_pCurrentGroup->Groups().Count(); + for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) { + CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup]; + n += GetNumberOfEntries(TRUE); + CONST_CAST m_pCurrentGroup = pOldCurrentGroup; + } + } + + return n; +} + +size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const +{ + size_t n = m_pCurrentGroup->Groups().Count(); + if ( bRecursive ) { + wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup; + size_t nSubgroups = m_pCurrentGroup->Groups().Count(); + for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) { + CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup]; + n += GetNumberOfGroups(TRUE); + CONST_CAST m_pCurrentGroup = pOldCurrentGroup; + } + } + + return n; +} + +// ---------------------------------------------------------------------------- +// tests for existence +// ---------------------------------------------------------------------------- + +bool wxFileConfig::HasGroup(const wxString& strName) const +{ + wxConfigPathChanger path(this, strName); + + wxFileConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name()); + return pGroup != NULL; +} + +bool wxFileConfig::HasEntry(const wxString& strName) const +{ + wxConfigPathChanger path(this, strName); + + wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); + return pEntry != NULL; +} + // ---------------------------------------------------------------------------- // read/write values // ---------------------------------------------------------------------------- -const char *wxFileConfig::Read(const char *szKey, const char *szDefault) const +bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const { - PathChanger path(this, szKey); + wxConfigPathChanger path(this, key); - ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); - if (pEntry == NULL) - return szDefault; - else - return pEntry->Value(); -// return pEntry == NULL ? szDefault : pEntry->Value(); + wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); + if (pEntry == NULL) { + return FALSE; + } + + *pStr = pEntry->Value(); + + return TRUE; } -long wxFileConfig::Read(const char *szKey, long lDefault) const +bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const { - const char *pc = Read(szKey); - return pc == NULL ? lDefault : atol(pc); + wxString str; + if ( !Read(key, & str) ) + { + return FALSE; + } + return str.ToLong(pl) ; } -bool wxFileConfig::Write(const char *szKey, const char *szValue) +bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue) { - PathChanger path(this, szKey); + wxConfigPathChanger path(this, key); + + wxString strName = path.Name(); + if ( strName.IsEmpty() ) { + // setting the value of a group is an error + wxASSERT_MSG( wxIsEmpty(szValue), wxT("can't set value of a group!") ); + + // ... except if it's empty in which case it's a way to force it's creation + m_pCurrentGroup->SetDirty(); + + // this will add a line for this group if it didn't have it before + (void)m_pCurrentGroup->GetGroupLine(); + } + else { + // writing an entry + + // check that the name is reasonable + if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) { + wxLogError(_("Config entry name cannot start with '%c'."), + wxCONFIG_IMMUTABLE_PREFIX); + return FALSE; + } - ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); - if ( pEntry == NULL ) - pEntry = m_pCurrentGroup->AddEntry(path.Name()); - pEntry->SetValue(szValue); + wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName); + if ( pEntry == NULL ) + pEntry = m_pCurrentGroup->AddEntry(strName); + + pEntry->SetValue(szValue); + } return TRUE; } -bool wxFileConfig::Write(const char *szKey, long lValue) +bool wxFileConfig::DoWriteLong(const wxString& key, long lValue) { - // ltoa() is not ANSI :-( - char szBuf[40]; // should be good for sizeof(long) <= 16 (128 bits) - sprintf(szBuf, "%ld", lValue); - return Write(szKey, szBuf); + return Write(key, wxString::Format(_T("%ld"), lValue)); } bool wxFileConfig::Flush(bool /* bCurrentOnly */) { - if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() ) + if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() || !m_strLocalFile ) return TRUE; - wxTempFile file(GetLocalFileName(m_strFile)); +#ifdef __UNIX__ + // set the umask if needed + mode_t umaskOld = 0; + if ( m_umask != -1 ) + { + umaskOld = umask((mode_t)m_umask); + } +#endif // __UNIX__ + + wxTempFile file(m_strLocalFile); if ( !file.IsOpened() ) { - wxLogError("Can't open user configuration file."); + wxLogError(_("can't open user configuration file.")); return FALSE; } // write all strings to file - for ( LineList *p = m_linesHead; p != NULL; p = p->Next() ) { + for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() ) { if ( !file.Write(p->Text() + wxTextFile::GetEOL()) ) { - wxLogError("Can't write user configuration file."); + wxLogError(_("can't write user configuration file.")); return FALSE; } } - return file.Commit(); + bool ret = file.Commit(); + +#if defined(__WXMAC__) + if ( ret ) + { + FSSpec spec ; + + wxMacFilename2FSSpec( m_strLocalFile , &spec ) ; + FInfo finfo ; + if ( FSpGetFInfo( &spec , &finfo ) == noErr ) + { + finfo.fdType = 'TEXT' ; + finfo.fdCreator = 'ttxt' ; + FSpSetFInfo( &spec , &finfo ) ; + } + } +#endif // __WXMAC__ + +#ifdef __UNIX__ + // restore the old umask if we changed it + if ( m_umask != -1 ) + { + (void)umask(umaskOld); + } +#endif // __UNIX__ + + return ret; +} + +// ---------------------------------------------------------------------------- +// renaming groups/entries +// ---------------------------------------------------------------------------- + +bool wxFileConfig::RenameEntry(const wxString& oldName, + const wxString& newName) +{ + // check that the entry exists + wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName); + if ( !oldEntry ) + return FALSE; + + // check that the new entry doesn't already exist + if ( m_pCurrentGroup->FindEntry(newName) ) + return FALSE; + + // delete the old entry, create the new one + wxString value = oldEntry->Value(); + if ( !m_pCurrentGroup->DeleteEntry(oldName) ) + return FALSE; + + wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName); + newEntry->SetValue(value); + + return TRUE; +} + +bool wxFileConfig::RenameGroup(const wxString& oldName, + const wxString& newName) +{ + // check that the group exists + wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName); + if ( !group ) + return FALSE; + + // check that the new group doesn't already exist + if ( m_pCurrentGroup->FindSubgroup(newName) ) + return FALSE; + + group->Rename(newName); + + return TRUE; } // ---------------------------------------------------------------------------- // delete groups/entries // ---------------------------------------------------------------------------- -bool wxFileConfig::DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso) +bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso) { - PathChanger path(this, szKey); + wxConfigPathChanger path(this, key); if ( !m_pCurrentGroup->DeleteEntry(path.Name()) ) return FALSE; if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) { if ( m_pCurrentGroup != m_pRootGroup ) { - ConfigGroup *pGroup = m_pCurrentGroup; - SetPath(".."); // changes m_pCurrentGroup! - m_pCurrentGroup->DeleteSubgroup(pGroup->Name()); + wxFileConfigGroup *pGroup = m_pCurrentGroup; + SetPath(wxT("..")); // changes m_pCurrentGroup! + m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name()); } //else: never delete the root group } @@ -678,25 +1010,22 @@ bool wxFileConfig::DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso) return TRUE; } -bool wxFileConfig::DeleteGroup(const char *szKey) +bool wxFileConfig::DeleteGroup(const wxString& key) { - PathChanger path(this, szKey); + wxConfigPathChanger path(this, key); - return m_pCurrentGroup->DeleteSubgroup(path.Name()); + return m_pCurrentGroup->DeleteSubgroupByName(path.Name()); } bool wxFileConfig::DeleteAll() { - const char *szFile = GetLocalFileName(m_strFile); - delete m_pRootGroup; - Init(); + CleanUp(); - if ( remove(szFile) == -1 ) - wxLogSysError("Can't delete user configuration file '%s'", szFile); + if ( wxRemove(m_strLocalFile) == -1 ) + wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str()); - szFile = GetGlobalFileName(m_strFile); - if ( remove(szFile) ) - wxLogSysError("Can't delete system configuration file '%s'", szFile); + m_strLocalFile = m_strGlobalFile = wxT(""); + Init(); return TRUE; } @@ -706,9 +1035,9 @@ bool wxFileConfig::DeleteAll() // ---------------------------------------------------------------------------- // append a new line to the end of the list -wxFileConfig::LineList *wxFileConfig::LineListAppend(const wxString& str) +wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str) { - LineList *pLine = new LineList(str); + wxFileConfigLineList *pLine = new wxFileConfigLineList(str); if ( m_linesTail == NULL ) { // list is empty @@ -717,32 +1046,66 @@ wxFileConfig::LineList *wxFileConfig::LineListAppend(const wxString& str) else { // adjust pointers m_linesTail->SetNext(pLine); + pLine->SetPrev(m_linesTail); } m_linesTail = pLine; return m_linesTail; } -// insert a new line after the given one -wxFileConfig::LineList *wxFileConfig::LineListInsert(const wxString& str, - LineList *pLine) +// insert a new line after the given one or in the very beginning if !pLine +wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str, + wxFileConfigLineList *pLine) { - if ( pLine == NULL ) + if ( pLine == m_linesTail ) return LineListAppend(str); - LineList *pNewLine = new LineList(str, pLine->Next()); - pLine->SetNext(pNewLine); + wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str); + if ( pLine == NULL ) { + // prepend to the list + pNewLine->SetNext(m_linesHead); + m_linesHead->SetPrev(pNewLine); + m_linesHead = pNewLine; + } + else { + // insert before pLine + wxFileConfigLineList *pNext = pLine->Next(); + pNewLine->SetNext(pNext); + pNewLine->SetPrev(pLine); + pNext->SetPrev(pNewLine); + pLine->SetNext(pNewLine); + } return pNewLine; } +void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine) +{ + wxFileConfigLineList *pPrev = pLine->Prev(), + *pNext = pLine->Next(); + + // first entry? + if ( pPrev == NULL ) + m_linesHead = pNext; + else + pPrev->SetNext(pNext); + + // last entry? + if ( pNext == NULL ) + m_linesTail = pPrev; + else + pNext->SetPrev(pPrev); + + delete pLine; +} + bool wxFileConfig::LineListIsEmpty() { return m_linesHead == NULL; } // ============================================================================ -// wxFileConfig::ConfigGroup +// wxFileConfig::wxFileConfigGroup // ============================================================================ // ---------------------------------------------------------------------------- @@ -750,25 +1113,27 @@ bool wxFileConfig::LineListIsEmpty() // ---------------------------------------------------------------------------- // ctor -wxFileConfig::ConfigGroup::ConfigGroup(wxFileConfig::ConfigGroup *pParent, +wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *pConfig) - : m_strName(strName) + : m_aEntries(CompareEntries), + m_aSubgroups(CompareGroups), + m_strName(strName) { m_pConfig = pConfig; m_pParent = pParent; - m_pLine = NULL; m_bDirty = FALSE; + m_pLine = NULL; - m_nLastEntry = - m_nLastGroup = NOT_FOUND; + m_pLastEntry = NULL; + m_pLastGroup = NULL; } // dtor deletes all children -wxFileConfig::ConfigGroup::~ConfigGroup() +wxFileConfigGroup::~wxFileConfigGroup() { // entries - uint n, nCount = m_aEntries.Count(); + size_t n, nCount = m_aEntries.Count(); for ( n = 0; n < nCount; n++ ) delete m_aEntries[n]; @@ -782,98 +1147,190 @@ wxFileConfig::ConfigGroup::~ConfigGroup() // line // ---------------------------------------------------------------------------- -void wxFileConfig::ConfigGroup::SetLine(LineList *pLine) +void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine) { wxASSERT( m_pLine == NULL ); // shouldn't be called twice m_pLine = pLine; } -// return the line which contains "[our name]" -wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetGroupLine() +/* + This is a bit complicated, so let me explain it in details. All lines that + were read from the local file (the only one we will ever modify) are stored + in a (doubly) linked list. Our problem is to know at which position in this + list should we insert the new entries/subgroups. To solve it we keep three + variables for each group: m_pLine, m_pLastEntry and m_pLastGroup. + + m_pLine points to the line containing "[group_name]" + m_pLastEntry points to the last entry of this group in the local file. + m_pLastGroup subgroup + + Initially, they're NULL all three. When the group (an entry/subgroup) is read + from the local file, the corresponding variable is set. However, if the group + was read from the global file and then modified or created by the application + these variables are still NULL and we need to create the corresponding lines. + See the following functions (and comments preceding them) for the details of + how we do it. + + Also, when our last entry/group are deleted we need to find the new last + element - the code in DeleteEntry/Subgroup does this by backtracking the list + of lines until it either founds an entry/subgroup (and this is the new last + element) or the m_pLine of the group, in which case there are no more entries + (or subgroups) left and m_pLast becomes NULL. + + NB: This last problem could be avoided for entries if we added new entries + immediately after m_pLine, but in this case the entries would appear + backwards in the config file (OTOH, it's not that important) and as we + would still need to do it for the subgroups the code wouldn't have been + significantly less complicated. +*/ + +// Return the line which contains "[our name]". If we're still not in the list, +// add our line to it immediately after the last line of our parent group if we +// have it or in the very beginning if we're the root group. +wxFileConfigLineList *wxFileConfigGroup::GetGroupLine() { if ( m_pLine == NULL ) { + wxFileConfigGroup *pParent = Parent(); + // this group wasn't present in local config file, add it now - if ( Parent() != NULL ) { + if ( pParent != NULL ) { wxString strFullName; - strFullName << "[" << GetFullName().c_str() + 1 << "]"; // +1: no '/' - m_pLine = m_pConfig->LineListInsert(strFullName, - Parent()->GetLastGroupLine()); + strFullName << wxT("[") + // +1: no '/' + << FilterOutEntryName(GetFullName().c_str() + 1) + << wxT("]"); + m_pLine = m_pConfig->LineListInsert(strFullName, + pParent->GetLastGroupLine()); + pParent->SetLastGroup(this); // we're surely after all the others } else { - // we're the root group, yet we were not in the local file => there were - // only comments and blank lines in config file or nothing at all - // we return NULL, so that LineListInsert() will do Append() + // we return NULL, so that LineListInsert() will insert us in the + // very beginning } } return m_pLine; } -// return the last line belonging to the subgroups of this group -// (after which we can add a new subgroup) -wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastGroupLine() +// Return the last line belonging to the subgroups of this group (after which +// we can add a new subgroup), if we don't have any subgroups or entries our +// last line is the group line (m_pLine) itself. +wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine() { // if we have any subgroups, our last line is the last line of the last // subgroup - if ( m_nLastGroup != NOT_FOUND ) { - return m_aSubgroups[m_nLastGroup]->GetLastGroupLine(); - } + if ( m_pLastGroup != NULL ) { + wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine(); - // if we have any entries, our last line is the last entry - if ( m_nLastEntry != NOT_FOUND ) { - return m_aEntries[m_nLastEntry]->GetLine(); + wxASSERT( pLine != NULL ); // last group must have !NULL associated line + return pLine; } - // nothing at all: last line is the first one - return GetGroupLine(); + // no subgroups, so the last line is the line of thelast entry (if any) + return GetLastEntryLine(); } -// return the last line belonging to the entries of this group -// (after which we can add a new entry) -wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastEntryLine() +// return the last line belonging to the entries of this group (after which +// we can add a new entry), if we don't have any entries we will add the new +// one immediately after the group line itself. +wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine() { - if ( m_nLastEntry != NOT_FOUND ) - return m_aEntries[m_nLastEntry]->GetLine(); - else - return GetGroupLine(); + if ( m_pLastEntry != NULL ) { + wxFileConfigLineList *pLine = m_pLastEntry->GetLine(); + + wxASSERT( pLine != NULL ); // last entry must have !NULL associated line + return pLine; + } + + // no entries: insert after the group header + return GetGroupLine(); } // ---------------------------------------------------------------------------- // group name // ---------------------------------------------------------------------------- -wxString wxFileConfig::ConfigGroup::GetFullName() const +void wxFileConfigGroup::Rename(const wxString& newName) +{ + m_strName = newName; + + wxFileConfigLineList *line = GetGroupLine(); + wxString strFullName; + strFullName << wxT("[") << (GetFullName().c_str() + 1) << wxT("]"); // +1: no '/' + line->SetText(strFullName); + + SetDirty(); +} + +wxString wxFileConfigGroup::GetFullName() const { if ( Parent() ) - return Parent()->GetFullName() + APPCONF_PATH_SEPARATOR + Name(); + return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name(); else - return ""; + return wxT(""); } // ---------------------------------------------------------------------------- // find an item // ---------------------------------------------------------------------------- -wxFileConfig::ConfigEntry * -wxFileConfig::ConfigGroup::FindEntry(const char *szName) const +// use binary search because the array is sorted +wxFileConfigEntry * +wxFileConfigGroup::FindEntry(const wxChar *szName) const { - uint nCount = m_aEntries.Count(); - for ( uint n = 0; n < nCount; n++ ) { - if ( m_aEntries[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - return m_aEntries[n]; + size_t i, + lo = 0, + hi = m_aEntries.Count(); + int res; + wxFileConfigEntry *pEntry; + + while ( lo < hi ) { + i = (lo + hi)/2; + pEntry = m_aEntries[i]; + + #if wxCONFIG_CASE_SENSITIVE + res = wxStrcmp(pEntry->Name(), szName); + #else + res = wxStricmp(pEntry->Name(), szName); + #endif + + if ( res > 0 ) + hi = i; + else if ( res < 0 ) + lo = i + 1; + else + return pEntry; } return NULL; } -wxFileConfig::ConfigGroup * -wxFileConfig::ConfigGroup::FindSubgroup(const char *szName) const +wxFileConfigGroup * +wxFileConfigGroup::FindSubgroup(const wxChar *szName) const { - uint nCount = m_aSubgroups.Count(); - for ( uint n = 0; n < nCount; n++ ) { - if ( m_aSubgroups[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - return m_aSubgroups[n]; + size_t i, + lo = 0, + hi = m_aSubgroups.Count(); + int res; + wxFileConfigGroup *pGroup; + + while ( lo < hi ) { + i = (lo + hi)/2; + pGroup = m_aSubgroups[i]; + + #if wxCONFIG_CASE_SENSITIVE + res = wxStrcmp(pGroup->Name(), szName); + #else + res = wxStricmp(pGroup->Name(), szName); + #endif + + if ( res > 0 ) + hi = i; + else if ( res < 0 ) + lo = i + 1; + else + return pGroup; } return NULL; @@ -884,24 +1341,24 @@ wxFileConfig::ConfigGroup::FindSubgroup(const char *szName) const // ---------------------------------------------------------------------------- // create a new entry and add it to the current group -wxFileConfig::ConfigEntry * -wxFileConfig::ConfigGroup::AddEntry(const wxString& strName, int nLine) +wxFileConfigEntry * +wxFileConfigGroup::AddEntry(const wxString& strName, int nLine) { wxASSERT( FindEntry(strName) == NULL ); - ConfigEntry *pEntry = new ConfigEntry(this, strName, nLine); + wxFileConfigEntry *pEntry = new wxFileConfigEntry(this, strName, nLine); m_aEntries.Add(pEntry); return pEntry; } // create a new group and add it to the current group -wxFileConfig::ConfigGroup * -wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName) +wxFileConfigGroup * +wxFileConfigGroup::AddSubgroup(const wxString& strName) { wxASSERT( FindSubgroup(strName) == NULL ); - ConfigGroup *pGroup = new ConfigGroup(this, strName, m_pConfig); + wxFileConfigGroup *pGroup = new wxFileConfigGroup(this, strName, m_pConfig); m_aSubgroups.Add(pGroup); return pGroup; @@ -911,42 +1368,139 @@ wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName) // delete an item // ---------------------------------------------------------------------------- -bool wxFileConfig::ConfigGroup::DeleteSubgroup(const char *szName) +/* + The delete operations are _very_ slow if we delete the last item of this + group (see comments before GetXXXLineXXX functions for more details), + so it's much better to start with the first entry/group if we want to + delete several of them. + */ + +bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar *szName) { - uint n, nCount = m_aSubgroups.Count(); - for ( n = 0; n < nCount; n++ ) { - if ( m_aSubgroups[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - break; + return DeleteSubgroup(FindSubgroup(szName)); +} + +// doesn't delete the subgroup itself, but does remove references to it from +// all other data structures (and normally the returned pointer should be +// deleted a.s.a.p. because there is nothing much to be done with it anyhow) +bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup) +{ + wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group? + + // delete all entries + size_t nCount = pGroup->m_aEntries.Count(); + for ( size_t nEntry = 0; nEntry < nCount; nEntry++ ) { + wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine(); + if ( pLine != NULL ) + m_pConfig->LineListRemove(pLine); } - if ( n == nCount ) - return FALSE; + // and subgroups of this sungroup + nCount = pGroup->m_aSubgroups.Count(); + for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) { + pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]); + } + + wxFileConfigLineList *pLine = pGroup->m_pLine; + if ( pLine != NULL ) { + // notice that we may do this test inside the previous "if" because the + // last entry's line is surely !NULL + if ( pGroup == m_pLastGroup ) { + // our last entry is being deleted - find the last one which stays + wxASSERT( m_pLine != NULL ); // we have a subgroup with !NULL pLine... + + // go back until we find a subgroup or reach the group's line + wxFileConfigGroup *pNewLast = NULL; + size_t n, nSubgroups = m_aSubgroups.Count(); + wxFileConfigLineList *pl; + for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) { + // is it our subgroup? + for ( n = 0; (pNewLast == NULL) && (n < nSubgroups); n++ ) { + // do _not_ call GetGroupLine! we don't want to add it to the local + // file if it's not already there + if ( m_aSubgroups[n]->m_pLine == m_pLine ) + pNewLast = m_aSubgroups[n]; + } + + if ( pNewLast != NULL ) // found? + break; + } + + if ( pl == m_pLine ) { + wxASSERT( !pNewLast ); // how comes it has the same line as we? + + // we've reached the group line without finding any subgroups + m_pLastGroup = NULL; + } + else + m_pLastGroup = pNewLast; + } + + m_pConfig->LineListRemove(pLine); + } + + SetDirty(); + + m_aSubgroups.Remove(pGroup); + delete pGroup; - delete m_aSubgroups[n]; - m_aSubgroups.Remove(n); return TRUE; } -bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName) +bool wxFileConfigGroup::DeleteEntry(const wxChar *szName) { - uint n, nCount = m_aEntries.Count(); - for ( n = 0; n < nCount; n++ ) { - if ( m_aEntries[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - break; + wxFileConfigEntry *pEntry = FindEntry(szName); + wxCHECK( pEntry != NULL, FALSE ); // deleting non existing item? + + wxFileConfigLineList *pLine = pEntry->GetLine(); + if ( pLine != NULL ) { + // notice that we may do this test inside the previous "if" because the + // last entry's line is surely !NULL + if ( pEntry == m_pLastEntry ) { + // our last entry is being deleted - find the last one which stays + wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine... + + // go back until we find another entry or reach the group's line + wxFileConfigEntry *pNewLast = NULL; + size_t n, nEntries = m_aEntries.Count(); + wxFileConfigLineList *pl; + for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) { + // is it our subgroup? + for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) { + if ( m_aEntries[n]->GetLine() == m_pLine ) + pNewLast = m_aEntries[n]; + } + + if ( pNewLast != NULL ) // found? + break; + } + + if ( pl == m_pLine ) { + wxASSERT( !pNewLast ); // how comes it has the same line as we? + + // we've reached the group line without finding any subgroups + m_pLastEntry = NULL; + } + else + m_pLastEntry = pNewLast; + } + + m_pConfig->LineListRemove(pLine); } - if ( n == nCount ) - return FALSE; + // we must be written back for the changes to be saved + SetDirty(); + + m_aEntries.Remove(pEntry); + delete pEntry; - delete m_aEntries[n]; - m_aEntries.Remove(n); return TRUE; } // ---------------------------------------------------------------------------- -// +// // ---------------------------------------------------------------------------- -void wxFileConfig::ConfigGroup::SetDirty() +void wxFileConfigGroup::SetDirty() { m_bDirty = TRUE; if ( Parent() != NULL ) // propagate upwards @@ -954,24 +1508,27 @@ void wxFileConfig::ConfigGroup::SetDirty() } // ============================================================================ -// wxFileConfig::ConfigEntry +// wxFileConfig::wxFileConfigEntry // ============================================================================ // ---------------------------------------------------------------------------- // ctor // ---------------------------------------------------------------------------- -wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent, +wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent, const wxString& strName, int nLine) : m_strName(strName) { + wxASSERT( !strName.IsEmpty() ); + m_pParent = pParent; m_nLine = nLine; m_pLine = NULL; - m_bDirty = FALSE; + m_bDirty = + m_bHasValue = FALSE; - m_bImmutable = strName[0] == APPCONF_IMMUTABLE_PREFIX; + m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX; if ( m_bImmutable ) m_strName.erase(0, 1); // remove first character } @@ -980,33 +1537,39 @@ wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent, // set value // ---------------------------------------------------------------------------- -void wxFileConfig::ConfigEntry::SetLine(LineList *pLine) +void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine) { - wxASSERT( m_pLine == NULL ); + if ( m_pLine != NULL ) { + wxLogWarning(_("entry '%s' appears more than once in group '%s'"), + Name().c_str(), m_pParent->GetFullName().c_str()); + } m_pLine = pLine; + Group()->SetLastEntry(this); } // second parameter is FALSE if we read the value from file and prevents the // entry from being marked as 'dirty' -void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser) +void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser) { if ( bUser && IsImmutable() ) { - wxLogWarning("Attempt to change immutable key '%s' ignored.", + wxLogWarning(_("attempt to change immutable key '%s' ignored."), Name().c_str()); return; } - // do nothing if it's the same value - if ( strValue == m_strValue ) + // do nothing if it's the same value: but don't test for it if m_bHasValue + // hadn't been set yet or we'd never write empty values to the file + if ( m_bHasValue && strValue == m_strValue ) return; + m_bHasValue = TRUE; m_strValue = strValue; if ( bUser ) { - wxString strVal = FilterOut(strValue); + wxString strVal = FilterOutValue(strValue); wxString strLine; - strLine << m_strName << " = " << strVal; + strLine << FilterOutEntryName(m_strName) << wxT('=') << strVal; if ( m_pLine != NULL ) { // entry was read from the local config file, just modify the line @@ -1014,181 +1577,92 @@ void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser) } else { // add a new line to the file - wxASSERT( m_nLine == NOT_FOUND ); // consistency check + wxASSERT( m_nLine == wxNOT_FOUND ); // consistency check - Group()->Config()->LineListInsert(strLine, Group()->GetLastEntryLine()); + m_pLine = Group()->Config()->LineListInsert(strLine, + Group()->GetLastEntryLine()); + Group()->SetLastEntry(this); } SetDirty(); } } -void wxFileConfig::ConfigEntry::SetDirty() +void wxFileConfigEntry::SetDirty() { m_bDirty = TRUE; Group()->SetDirty(); } -// ============================================================================ -// wxFileConfig::PathChanger -// ============================================================================ - -wxFileConfig::PathChanger::PathChanger(const wxFileConfig *pContainer, - const wxString& strEntry) -{ - m_pContainer = (wxFileConfig *)pContainer; - wxString strPath = strEntry.Before(APPCONF_PATH_SEPARATOR); - if ( !strPath.IsEmpty() ) { - // do change the path - m_bChanged = TRUE; - m_strName = strEntry.Right(APPCONF_PATH_SEPARATOR); - m_strOldPath = m_pContainer->GetPath(); - m_strOldPath += APPCONF_PATH_SEPARATOR; - m_pContainer->SetPath(strPath); - } - else { - // it's a name only, without path - nothing to do - m_bChanged = FALSE; - m_strName = strEntry; - } -} - -wxFileConfig::PathChanger::~PathChanger() -{ - // only restore path if it was changed - if ( m_bChanged ) { - m_pContainer->SetPath(m_strOldPath); - } -} - // ============================================================================ // global functions // ============================================================================ -const char *GetGlobalFileName(const char *szFile) -{ - static wxString s_str; - s_str.Empty(); - - bool bNoExt = strchr(szFile, '.') == NULL; - - #ifdef __UNIX__ - s_str << "/etc/" << szFile; - if ( bNoExt ) - s_str << ".conf"; - #else // Windows -#ifndef _MAX_PATH -#define _MAX_PATH 512 -#endif - char szWinDir[_MAX_PATH]; - ::GetWindowsDirectory(szWinDir, _MAX_PATH); - s_str << szWinDir << "\\" << szFile; - if ( bNoExt ) - s_str << ".INI"; - #endif // UNIX/Win - - return s_str.c_str(); -} +// ---------------------------------------------------------------------------- +// compare functions for array sorting +// ---------------------------------------------------------------------------- -const char *GetLocalFileName(const char *szFile) +int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2) { - static wxString s_str; - s_str.Empty(); - - #ifdef __UNIX__ - const char *szHome = getenv("HOME"); - if ( szHome == NULL ) { - // we're homeless... - wxLogWarning("can't find user's HOME, using current directory."); - szHome = "."; - } - s_str << szHome << "/." << szFile; - #else // Windows - #ifdef __WIN32__ - const char *szHome = getenv("HOMEDRIVE"); - if ( szHome == NULL ) - szHome = ""; - s_str << szHome; - szHome = getenv("HOMEPATH"); - s_str << ( szHome == NULL ? "." : szHome ) << szFile; - if ( strchr(szFile, '.') == NULL ) - s_str << ".INI"; - #else // Win16 - // Win16 has no idea about home, so use the current directory instead - s_str << ".\\" << szFile; - #endif // WIN16/32 - #endif // UNIX/Win - - return s_str.c_str(); + #if wxCONFIG_CASE_SENSITIVE + return wxStrcmp(p1->Name(), p2->Name()); + #else + return wxStricmp(p1->Name(), p2->Name()); + #endif } -void SplitPath(wxArrayString& aParts, const char *sz) +int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2) { - aParts.Empty(); - - wxString strCurrent; - const char *pc = sz; - for ( ;; ) { - if ( *pc == '\0' || *pc == APPCONF_PATH_SEPARATOR ) { - if ( strCurrent == "." ) { - // ignore - } - else if ( strCurrent == ".." ) { - // go up one level - if ( aParts.IsEmpty() ) - wxLogWarning("'%s' has extra '..', ignored.", sz); - else - aParts.Remove(aParts.Count() - 1); - } - else if ( !strCurrent.IsEmpty() ) { - aParts.Add(strCurrent); - strCurrent.Empty(); - } - //else: - // could log an error here, but we prefer to ignore extra '/' - - if ( *pc == '\0' ) - return; - } - else - strCurrent += *pc; - - pc++; - } + #if wxCONFIG_CASE_SENSITIVE + return wxStrcmp(p1->Name(), p2->Name()); + #else + return wxStricmp(p1->Name(), p2->Name()); + #endif } -// undo FilterOut -wxString FilterIn(const wxString& str) +// ---------------------------------------------------------------------------- +// filter functions +// ---------------------------------------------------------------------------- + +// undo FilterOutValue +static wxString FilterInValue(const wxString& str) { wxString strResult; + strResult.Alloc(str.Len()); - bool bQuoted = str[0] == '"'; + bool bQuoted = !str.IsEmpty() && str[0] == '"'; - for ( uint n = bQuoted ? 1 : 0; n < str.Len(); n++ ) { - if ( str[n] == '\\' ) { + for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) { + if ( str[n] == wxT('\\') ) { switch ( str[++n] ) { - case 'n': - strResult += '\n'; + case wxT('n'): + strResult += wxT('\n'); break; - case 't': - strResult += '\t'; + case wxT('r'): + strResult += wxT('\r'); break; - case '\\': - strResult += '\\'; + case wxT('t'): + strResult += wxT('\t'); break; - case '"': - strResult += '"'; + case wxT('\\'): + strResult += wxT('\\'); + break; + + case wxT('"'): + strResult += wxT('"'); break; } } else { - if ( str[n] != '"' || !bQuoted ) + if ( str[n] != wxT('"') || !bQuoted ) strResult += str[n]; - else if ( n != str.Len() - 1 ) - wxLogWarning("unexpected \" at position %d in '%s'.", n, str.c_str()); + else if ( n != str.Len() - 1 ) { + wxLogWarning(_("unexpected \" at position %d in '%s'."), + n, str.c_str()); + } //else: it's the last quote of a quoted string, ok } } @@ -1197,34 +1671,44 @@ wxString FilterIn(const wxString& str) } // quote the string before writing it to file -wxString FilterOut(const wxString& str) +static wxString FilterOutValue(const wxString& str) { + if ( !str ) + return str; + wxString strResult; + strResult.Alloc(str.Len()); // quoting is necessary to preserve spaces in the beginning of the string - bool bQuote = isspace(str[0]) || str[0] == '"'; + bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"'); if ( bQuote ) - strResult += '"'; + strResult += wxT('"'); - char c; - for ( uint n = 0; n < str.Len(); n++ ) { + wxChar c; + for ( size_t n = 0; n < str.Len(); n++ ) { switch ( str[n] ) { - case '\n': - c = 'n'; + case wxT('\n'): + c = wxT('n'); + break; + + case wxT('\r'): + c = wxT('r'); break; - case '\t': - c = 't'; + case wxT('\t'): + c = wxT('t'); break; - case '\\': - c = '\\'; + case wxT('\\'): + c = wxT('\\'); break; - case '"': - if ( bQuote ) - c = '"'; + case wxT('"'): + if ( bQuote ) { + c = wxT('"'); + break; + } //else: fall through default: @@ -1233,16 +1717,62 @@ wxString FilterOut(const wxString& str) } // we get here only for special characters - strResult << '\\' << c; + strResult << wxT('\\') << c; } if ( bQuote ) - strResult += '"'; + strResult += wxT('"'); return strResult; } -wxConfig *CreateFileConfig(const wxString& strFile, bool bLocalOnly) +// undo FilterOutEntryName +static wxString FilterInEntryName(const wxString& str) { - return new wxFileConfig(strFile, bLocalOnly); -} \ No newline at end of file + wxString strResult; + strResult.Alloc(str.Len()); + + for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) { + if ( *pc == wxT('\\') ) + pc++; + + strResult += *pc; + } + + return strResult; +} + +// sanitize entry or group name: insert '\\' before any special characters +static wxString FilterOutEntryName(const wxString& str) +{ + wxString strResult; + strResult.Alloc(str.Len()); + + for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) { + wxChar c = *pc; + + // we explicitly allow some of "safe" chars and 8bit ASCII characters + // which will probably never have special meaning + // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR + // should *not* be quoted + if ( !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) && ((c & 0x80) == 0) ) + strResult += wxT('\\'); + + strResult += c; + } + + return strResult; +} + +// we can't put ?: in the ctor initializer list because it confuses some +// broken compilers (Borland C++) +static wxString GetAppName(const wxString& appName) +{ + if ( !appName && wxTheApp ) + return wxTheApp->GetAppName(); + else + return appName; +} + +#endif // wxUSE_CONFIG +