src/common/fileconf.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/fileconf.cpp
   3 // Purpose:     implementation of wxFileConfig derivation of wxConfig
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     07.04.98 (adapted from appconf.cpp)
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997 Karsten Ballueder  &  Vadim Zeitlin
   9 //                       Ballueder@usa.net     <zeitlin@dptmaths.ens-cachan.fr>
  10 // Licence:     wxWindows licence
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 // ----------------------------------------------------------------------------
  14 // headers
  15 // ----------------------------------------------------------------------------
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include  "wx/wxprec.h"
  19
  20 #ifdef    __BORLANDC__
  21     #pragma hdrstop
  22 #endif  //__BORLANDC__
  23
  24 #if wxUSE_CONFIG && wxUSE_FILECONFIG
  25
  26 #ifndef   WX_PRECOMP
  27     #include  "wx/dynarray.h"
  28     #include  "wx/string.h"
  29     #include  "wx/intl.h"
  30     #include  "wx/log.h"
  31     #include  "wx/app.h"
  32     #include  "wx/utils.h"    // for wxGetHomeDir
  33     #if wxUSE_STREAMS
  34         #include  "wx/stream.h"
  35     #endif // wxUSE_STREAMS
  36 #endif  //WX_PRECOMP
  37
  38 #include  "wx/file.h"
  39 #include  "wx/textfile.h"
  40 #include  "wx/memtext.h"
  41 #include  "wx/config.h"
  42 #include  "wx/fileconf.h"
  43 #include  "wx/filefn.h"
  44
  45 #include "wx/base64.h"
  46
  47 #include  "wx/stdpaths.h"
  48
  49 #if defined(__WXMSW__)
  50     #include "wx/msw/private.h"
  51 #endif  //windows.h
  52 #if defined(__WXPM__)
  53     #define INCL_DOS
  54     #include <os2.h>
  55 #endif
  56
  57 #include  <stdlib.h>
  58 #include  <ctype.h>
  59
  60 // ----------------------------------------------------------------------------
  61 // constants
  62 // ----------------------------------------------------------------------------
  63
  64 #ifndef MAX_PATH
  65     #define MAX_PATH 512
  66 #endif
  67
  68 #define FILECONF_TRACE_MASK wxT("fileconf")
  69
  70 // ----------------------------------------------------------------------------
  71 // global functions declarations
  72 // ----------------------------------------------------------------------------
  73
  74 // compare functions for sorting the arrays
  75 static int LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2);
  76 static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2);
  77
  78 // filter strings
  79 static wxString FilterInValue(const wxString& str);
  80 static wxString FilterOutValue(const wxString& str);
  81
  82 static wxString FilterInEntryName(const wxString& str);
  83 static wxString FilterOutEntryName(const wxString& str);
  84
  85 // get the name to use in wxFileConfig ctor
  86 static wxString GetAppName(const wxString& appname);
  87
  88 // ============================================================================
  89 // private classes
  90 // ============================================================================
  91
  92 // ----------------------------------------------------------------------------
  93 // "template" array types
  94 // ----------------------------------------------------------------------------
  95
  96 #ifdef WXMAKINGDLL_BASE
  97     WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries,
  98                                          WXDLLIMPEXP_BASE);
  99     WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups,
 100                                          WXDLLIMPEXP_BASE);
 101 #else
 102     WX_DEFINE_SORTED_ARRAY(wxFileConfigEntry *, ArrayEntries);
 103     WX_DEFINE_SORTED_ARRAY(wxFileConfigGroup *, ArrayGroups);
 104 #endif
 105
 106 // ----------------------------------------------------------------------------
 107 // wxFileConfigLineList
 108 // ----------------------------------------------------------------------------
 109
 110 // we store all lines of the local config file as a linked list in memory
 111 class wxFileConfigLineList
 112 {
 113 public:
 114   void SetNext(wxFileConfigLineList *pNext)  { m_pNext = pNext; }
 115   void SetPrev(wxFileConfigLineList *pPrev)  { m_pPrev = pPrev; }
 116
 117   // ctor
 118   wxFileConfigLineList(const wxString& str,
 119                        wxFileConfigLineList *pNext = NULL) : m_strLine(str)
 120     { SetNext(pNext); SetPrev(NULL); }
 121
 122   // next/prev nodes in the linked list
 123   wxFileConfigLineList *Next() const { return m_pNext;  }
 124   wxFileConfigLineList *Prev() const { return m_pPrev;  }
 125
 126   // get/change lines text
 127   void SetText(const wxString& str) { m_strLine = str;  }
 128   const wxString& Text() const { return m_strLine; }
 129
 130 private:
 131   wxString  m_strLine;                  // line contents
 132   wxFileConfigLineList *m_pNext,        // next node
 133                        *m_pPrev;        // previous one
 134
 135     wxDECLARE_NO_COPY_CLASS(wxFileConfigLineList);
 136 };
 137
 138 // ----------------------------------------------------------------------------
 139 // wxFileConfigEntry: a name/value pair
 140 // ----------------------------------------------------------------------------
 141
 142 class wxFileConfigEntry
 143 {
 144 private:
 145   wxFileConfigGroup *m_pParent; // group that contains us
 146
 147   wxString      m_strName,      // entry name
 148                 m_strValue;     //       value
 149   bool          m_bImmutable:1, // can be overriden locally?
 150                 m_bHasValue:1;  // set after first call to SetValue()
 151
 152   int           m_nLine;        // used if m_pLine == NULL only
 153
 154   // pointer to our line in the linked list or NULL if it was found in global
 155   // file (which we don't modify)
 156   wxFileConfigLineList *m_pLine;
 157
 158 public:
 159   wxFileConfigEntry(wxFileConfigGroup *pParent,
 160                     const wxString& strName, int nLine);
 161
 162   // simple accessors
 163   const wxString& Name()        const { return m_strName;    }
 164   const wxString& Value()       const { return m_strValue;   }
 165   wxFileConfigGroup *Group()    const { return m_pParent;    }
 166   bool            IsImmutable() const { return m_bImmutable; }
 167   bool            IsLocal()     const { return m_pLine != 0; }
 168   int             Line()        const { return m_nLine;      }
 169   wxFileConfigLineList *
 170                   GetLine()     const { return m_pLine;      }
 171
 172   // modify entry attributes
 173   void SetValue(const wxString& strValue, bool bUser = true);
 174   void SetLine(wxFileConfigLineList *pLine);
 175
 176     wxDECLARE_NO_COPY_CLASS(wxFileConfigEntry);
 177 };
 178
 179 // ----------------------------------------------------------------------------
 180 // wxFileConfigGroup: container of entries and other groups
 181 // ----------------------------------------------------------------------------
 182
 183 class wxFileConfigGroup
 184 {
 185 private:
 186   wxFileConfig *m_pConfig;          // config object we belong to
 187   wxFileConfigGroup  *m_pParent;    // parent group (NULL for root group)
 188   ArrayEntries  m_aEntries;         // entries in this group
 189   ArrayGroups   m_aSubgroups;       // subgroups
 190   wxString      m_strName;          // group's name
 191   wxFileConfigLineList *m_pLine;    // pointer to our line in the linked list
 192   wxFileConfigEntry *m_pLastEntry;  // last entry/subgroup of this group in the
 193   wxFileConfigGroup *m_pLastGroup;  // local file (we insert new ones after it)
 194
 195   // DeleteSubgroupByName helper
 196   bool DeleteSubgroup(wxFileConfigGroup *pGroup);
 197
 198   // used by Rename()
 199   void UpdateGroupAndSubgroupsLines();
 200
 201 public:
 202   // ctor
 203   wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *);
 204
 205   // dtor deletes all entries and subgroups also
 206   ~wxFileConfigGroup();
 207
 208   // simple accessors
 209   const wxString& Name()    const { return m_strName; }
 210   wxFileConfigGroup    *Parent()  const { return m_pParent; }
 211   wxFileConfig   *Config()  const { return m_pConfig; }
 212
 213   const ArrayEntries& Entries() const { return m_aEntries;   }
 214   const ArrayGroups&  Groups()  const { return m_aSubgroups; }
 215   bool  IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
 216
 217   // find entry/subgroup (NULL if not found)
 218   wxFileConfigGroup *FindSubgroup(const wxString& name) const;
 219   wxFileConfigEntry *FindEntry   (const wxString& name) const;
 220
 221   // delete entry/subgroup, return false if doesn't exist
 222   bool DeleteSubgroupByName(const wxString& name);
 223   bool DeleteEntry(const wxString& name);
 224
 225   // create new entry/subgroup returning pointer to newly created element
 226   wxFileConfigGroup *AddSubgroup(const wxString& strName);
 227   wxFileConfigEntry *AddEntry   (const wxString& strName, int nLine = wxNOT_FOUND);
 228
 229   void SetLine(wxFileConfigLineList *pLine);
 230
 231   // rename: no checks are done to ensure that the name is unique!
 232   void Rename(const wxString& newName);
 233
 234   //
 235   wxString GetFullName() const;
 236
 237   // get the last line belonging to an entry/subgroup of this group
 238   wxFileConfigLineList *GetGroupLine();     // line which contains [group]
 239                                             // may be NULL for "/" only
 240   wxFileConfigLineList *GetLastEntryLine(); // after which our subgroups start
 241   wxFileConfigLineList *GetLastGroupLine(); // after which the next group starts
 242
 243   // called by entries/subgroups when they're created/deleted
 244   void SetLastEntry(wxFileConfigEntry *pEntry);
 245   void SetLastGroup(wxFileConfigGroup *pGroup)
 246     { m_pLastGroup = pGroup; }
 247
 248   wxDECLARE_NO_COPY_CLASS(wxFileConfigGroup);
 249 };
 250
 251 // ============================================================================
 252 // implementation
 253 // ============================================================================
 254
 255 // ----------------------------------------------------------------------------
 256 // static functions
 257 // ----------------------------------------------------------------------------
 258
 259 // this function modifies in place the given wxFileName object if it doesn't
 260 // already have an extension
 261 //
 262 // note that it's slightly misnamed under Mac as there it doesn't add an
 263 // extension but modifies the file name instead, so you shouldn't suppose that
 264 // fn.HasExt() is true after it returns
 265 static void AddConfFileExtIfNeeded(wxFileName& fn)
 266 {
 267     if ( !fn.HasExt() )
 268     {
 269 #if defined( __WXMAC__ )
 270         fn.SetName(fn.GetName() + wxT(" Preferences"));
 271 #elif defined( __UNIX__ )
 272         fn.SetExt(wxT("conf"));
 273 #else   // Windows
 274         fn.SetExt(wxT("ini"));
 275 #endif  // UNIX/Win
 276     }
 277 }
 278
 279 wxString wxFileConfig::GetGlobalDir()
 280 {
 281     return wxStandardPaths::Get().GetConfigDir();
 282 }
 283
 284 wxString wxFileConfig::GetLocalDir(int style)
 285 {
 286     wxUnusedVar(style);
 287
 288     wxStandardPathsBase& stdp = wxStandardPaths::Get();
 289
 290     // it so happens that user data directory is a subdirectory of user config
 291     // directory on all supported platforms, which explains why we use it here
 292     return style & wxCONFIG_USE_SUBDIR ? stdp.GetUserDataDir()
 293                                        : stdp.GetUserConfigDir();
 294 }
 295
 296 wxFileName wxFileConfig::GetGlobalFile(const wxString& szFile)
 297 {
 298     wxFileName fn(GetGlobalDir(), szFile);
 299
 300     AddConfFileExtIfNeeded(fn);
 301
 302     return fn;
 303 }
 304
 305 wxFileName wxFileConfig::GetLocalFile(const wxString& szFile, int style)
 306 {
 307     wxFileName fn(GetLocalDir(style), szFile);
 308
 309 #if defined( __UNIX__ ) && !defined( __WXMAC__ )
 310     if ( !(style & wxCONFIG_USE_SUBDIR) )
 311     {
 312         // dot-files under Unix start with, well, a dot (but OTOH they usually
 313         // don't have any specific extension)
 314         fn.SetName(wxT('.') + fn.GetName());
 315     }
 316     else // we do append ".conf" extension to config files in subdirectories
 317 #endif // defined( __UNIX__ ) && !defined( __WXMAC__ )
 318     {
 319         AddConfFileExtIfNeeded(fn);
 320     }
 321
 322     return fn;
 323 }
 324
 325 // ----------------------------------------------------------------------------
 326 // ctor
 327 // ----------------------------------------------------------------------------
 328 IMPLEMENT_ABSTRACT_CLASS(wxFileConfig, wxConfigBase)
 329
 330 void wxFileConfig::Init()
 331 {
 332     m_pCurrentGroup =
 333     m_pRootGroup    = new wxFileConfigGroup(NULL, wxEmptyString, this);
 334
 335     m_linesHead =
 336     m_linesTail = NULL;
 337
 338     // It's not an error if (one of the) file(s) doesn't exist.
 339
 340     // parse the global file
 341     if ( m_fnGlobalFile.IsOk() && m_fnGlobalFile.FileExists() )
 342     {
 343         wxTextFile fileGlobal(m_fnGlobalFile.GetFullPath());
 344
 345         if ( fileGlobal.Open(*m_conv/*ignored in ANSI build*/) )
 346         {
 347             Parse(fileGlobal, false /* global */);
 348             SetRootPath();
 349         }
 350         else
 351         {
 352             wxLogWarning(_("can't open global configuration file '%s'."), m_fnGlobalFile.GetFullPath().c_str());
 353         }
 354     }
 355
 356     // parse the local file
 357     if ( m_fnLocalFile.IsOk() && m_fnLocalFile.FileExists() )
 358     {
 359         wxTextFile fileLocal(m_fnLocalFile.GetFullPath());
 360         if ( fileLocal.Open(*m_conv/*ignored in ANSI build*/) )
 361         {
 362             Parse(fileLocal, true /* local */);
 363             SetRootPath();
 364         }
 365         else
 366         {
 367             const wxString path = m_fnLocalFile.GetFullPath();
 368             wxLogWarning(_("can't open user configuration file '%s'."),
 369                          path.c_str());
 370
 371             if ( m_fnLocalFile.FileExists() )
 372             {
 373                 wxLogWarning(_("Changes won't be saved to avoid overwriting the existing file \"%s\""),
 374                              path.c_str());
 375                 m_fnLocalFile.Clear();
 376             }
 377         }
 378     }
 379
 380     m_isDirty = false;
 381 }
 382
 383 // constructor supports creation of wxFileConfig objects of any type
 384 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
 385                            const wxString& strLocal, const wxString& strGlobal,
 386                            long style,
 387                            const wxMBConv& conv)
 388             : wxConfigBase(::GetAppName(appName), vendorName,
 389                            strLocal, strGlobal,
 390                            style),
 391               m_fnLocalFile(strLocal),
 392               m_fnGlobalFile(strGlobal),
 393               m_conv(conv.Clone())
 394 {
 395     // Make up names for files if empty
 396     if ( !m_fnLocalFile.IsOk() && (style & wxCONFIG_USE_LOCAL_FILE) )
 397         m_fnLocalFile = GetLocalFile(GetAppName(), style);
 398
 399     if ( !m_fnGlobalFile.IsOk() && (style & wxCONFIG_USE_GLOBAL_FILE) )
 400         m_fnGlobalFile = GetGlobalFile(GetAppName());
 401
 402     // Check if styles are not supplied, but filenames are, in which case
 403     // add the correct styles.
 404     if ( m_fnLocalFile.IsOk() )
 405         SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
 406
 407     if ( m_fnGlobalFile.IsOk() )
 408         SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
 409
 410     // if the path is not absolute, prepend the standard directory to it
 411     // unless explicitly asked not to
 412     if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
 413     {
 414         if ( m_fnLocalFile.IsOk() )
 415             m_fnLocalFile.MakeAbsolute(GetLocalDir(style));
 416
 417         if ( m_fnGlobalFile.IsOk() )
 418             m_fnGlobalFile.MakeAbsolute(GetGlobalDir());
 419     }
 420
 421     SetUmask(-1);
 422
 423     Init();
 424 }
 425
 426 #if wxUSE_STREAMS
 427
 428 wxFileConfig::wxFileConfig(wxInputStream &inStream, const wxMBConv& conv)
 429             : m_conv(conv.Clone())
 430 {
 431     // always local_file when this constructor is called (?)
 432     SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
 433
 434     m_pCurrentGroup =
 435     m_pRootGroup    = new wxFileConfigGroup(NULL, wxEmptyString, this);
 436
 437     m_linesHead =
 438     m_linesTail = NULL;
 439
 440     // read the entire stream contents in memory
 441     wxWxCharBuffer cbuf;
 442     static const size_t chunkLen = 1024;
 443
 444     wxMemoryBuffer buf(chunkLen);
 445     do
 446     {
 447         inStream.Read(buf.GetAppendBuf(chunkLen), chunkLen);
 448         buf.UngetAppendBuf(inStream.LastRead());
 449
 450         const wxStreamError err = inStream.GetLastError();
 451
 452         if ( err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF )
 453         {
 454             wxLogError(_("Error reading config options."));
 455             break;
 456         }
 457     }
 458     while ( !inStream.Eof() );
 459
 460 #if wxUSE_UNICODE
 461     size_t len;
 462     cbuf = conv.cMB2WC((char *)buf.GetData(), buf.GetDataLen() + 1, &len);
 463     if ( !len && buf.GetDataLen() )
 464     {
 465         wxLogError(_("Failed to read config options."));
 466     }
 467 #else // !wxUSE_UNICODE
 468     // no need for conversion
 469     cbuf = wxCharBuffer::CreateNonOwned((char *)buf.GetData(), buf.GetDataLen());
 470 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 471
 472
 473     // now break it into lines
 474     wxMemoryText memText;
 475     for ( const wxChar *s = cbuf; ; ++s )
 476     {
 477         const wxChar *e = s;
 478         while ( *e != '\0' && *e != '\n' && *e != '\r' )
 479             ++e;
 480
 481         // notice that we throw away the original EOL kind here, maybe we
 482         // should preserve it?
 483         if ( e != s )
 484             memText.AddLine(wxString(s, e));
 485
 486         if ( *e == '\0' )
 487             break;
 488
 489         // skip the second EOL byte if it's a DOS one
 490         if ( *e == '\r' && e[1] == '\n' )
 491             ++e;
 492
 493         s = e;
 494     }
 495
 496     // Finally we can parse it all.
 497     Parse(memText, true /* local */);
 498
 499     SetRootPath();
 500     ResetDirty();
 501 }
 502
 503 #endif // wxUSE_STREAMS
 504
 505 void wxFileConfig::CleanUp()
 506 {
 507     delete m_pRootGroup;
 508
 509     wxFileConfigLineList *pCur = m_linesHead;
 510     while ( pCur != NULL ) {
 511         wxFileConfigLineList *pNext = pCur->Next();
 512         delete pCur;
 513         pCur = pNext;
 514     }
 515 }
 516
 517 wxFileConfig::~wxFileConfig()
 518 {
 519     Flush();
 520
 521     CleanUp();
 522
 523     delete m_conv;
 524 }
 525
 526 // ----------------------------------------------------------------------------
 527 // parse a config file
 528 // ----------------------------------------------------------------------------
 529
 530 void wxFileConfig::Parse(const wxTextBuffer& buffer, bool bLocal)
 531 {
 532
 533   size_t nLineCount = buffer.GetLineCount();
 534
 535   for ( size_t n = 0; n < nLineCount; n++ )
 536   {
 537     wxString strLine = buffer[n];
 538     // FIXME-UTF8: rewrite using iterators, without this buffer
 539     wxWxCharBuffer buf(strLine.c_str());
 540     const wxChar *pStart;
 541     const wxChar *pEnd;
 542
 543     // add the line to linked list
 544     if ( bLocal )
 545       LineListAppend(strLine);
 546
 547
 548     // skip leading spaces
 549     for ( pStart = buf; wxIsspace(*pStart); pStart++ )
 550       ;
 551
 552     // skip blank/comment lines
 553     if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
 554       continue;
 555
 556     if ( *pStart == wxT('[') ) {          // a new group
 557       pEnd = pStart;
 558
 559       while ( *++pEnd != wxT(']') ) {
 560         if ( *pEnd == wxT('\\') ) {
 561             // the next char is escaped, so skip it even if it is ']'
 562             pEnd++;
 563         }
 564
 565         if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
 566             // we reached the end of line, break out of the loop
 567             break;
 568         }
 569       }
 570
 571       if ( *pEnd != wxT(']') ) {
 572         wxLogError(_("file '%s': unexpected character %c at line %d."),
 573                    buffer.GetName(), *pEnd, n + 1);
 574         continue; // skip this line
 575       }
 576
 577       // group name here is always considered as abs path
 578       wxString strGroup;
 579       pStart++;
 580       strGroup << wxCONFIG_PATH_SEPARATOR
 581                << FilterInEntryName(wxString(pStart, pEnd - pStart));
 582
 583       // will create it if doesn't yet exist
 584       SetPath(strGroup);
 585
 586       if ( bLocal )
 587       {
 588         if ( m_pCurrentGroup->Parent() )
 589           m_pCurrentGroup->Parent()->SetLastGroup(m_pCurrentGroup);
 590         m_pCurrentGroup->SetLine(m_linesTail);
 591       }
 592
 593       // check that there is nothing except comments left on this line
 594       bool bCont = true;
 595       while ( *++pEnd != wxT('\0') && bCont ) {
 596         switch ( *pEnd ) {
 597           case wxT('#'):
 598           case wxT(';'):
 599             bCont = false;
 600             break;
 601
 602           case wxT(' '):
 603           case wxT('\t'):
 604             // ignore whitespace ('\n' impossible here)
 605             break;
 606
 607           default:
 608             wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
 609                          buffer.GetName(), n + 1, pEnd);
 610             bCont = false;
 611         }
 612       }
 613     }
 614     else {                        // a key
 615       pEnd = pStart;
 616       while ( *pEnd && *pEnd != wxT('=') /* && !wxIsspace(*pEnd)*/ ) {
 617         if ( *pEnd == wxT('\\') ) {
 618           // next character may be space or not - still take it because it's
 619           // quoted (unless there is nothing)
 620           pEnd++;
 621           if ( !*pEnd ) {
 622             // the error message will be given below anyhow
 623             break;
 624           }
 625         }
 626
 627         pEnd++;
 628       }
 629
 630       wxString strKey(FilterInEntryName(wxString(pStart, pEnd).Trim()));
 631
 632       // skip whitespace
 633       while ( wxIsspace(*pEnd) )
 634         pEnd++;
 635
 636       if ( *pEnd++ != wxT('=') ) {
 637         wxLogError(_("file '%s', line %d: '=' expected."),
 638                    buffer.GetName(), n + 1);
 639       }
 640       else {
 641         wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
 642
 643         if ( pEntry == NULL ) {
 644           // new entry
 645           pEntry = m_pCurrentGroup->AddEntry(strKey, n);
 646         }
 647         else {
 648           if ( bLocal && pEntry->IsImmutable() ) {
 649             // immutable keys can't be changed by user
 650             wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
 651                          buffer.GetName(), n + 1, strKey.c_str());
 652             continue;
 653           }
 654           // the condition below catches the cases (a) and (b) but not (c):
 655           //  (a) global key found second time in global file
 656           //  (b) key found second (or more) time in local file
 657           //  (c) key from global file now found in local one
 658           // which is exactly what we want.
 659           else if ( !bLocal || pEntry->IsLocal() ) {
 660             wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
 661                          buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
 662
 663           }
 664         }
 665
 666         if ( bLocal )
 667           pEntry->SetLine(m_linesTail);
 668
 669         // skip whitespace
 670         while ( wxIsspace(*pEnd) )
 671           pEnd++;
 672
 673         wxString value = pEnd;
 674         if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
 675             value = FilterInValue(value);
 676
 677         pEntry->SetValue(value, false);
 678       }
 679     }
 680   }
 681 }
 682
 683 // ----------------------------------------------------------------------------
 684 // set/retrieve path
 685 // ----------------------------------------------------------------------------
 686
 687 void wxFileConfig::SetRootPath()
 688 {
 689     m_strPath.Empty();
 690     m_pCurrentGroup = m_pRootGroup;
 691 }
 692
 693 bool
 694 wxFileConfig::DoSetPath(const wxString& strPath, bool createMissingComponents)
 695 {
 696     wxArrayString aParts;
 697
 698     if ( strPath.empty() ) {
 699         SetRootPath();
 700         return true;
 701     }
 702
 703     if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
 704         // absolute path
 705         wxSplitPath(aParts, strPath);
 706     }
 707     else {
 708         // relative path, combine with current one
 709         wxString strFullPath = m_strPath;
 710         strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
 711         wxSplitPath(aParts, strFullPath);
 712     }
 713
 714     // change current group
 715     size_t n;
 716     m_pCurrentGroup = m_pRootGroup;
 717     for ( n = 0; n < aParts.GetCount(); n++ ) {
 718         wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
 719         if ( pNextGroup == NULL )
 720         {
 721             if ( !createMissingComponents )
 722                 return false;
 723
 724             pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
 725         }
 726
 727         m_pCurrentGroup = pNextGroup;
 728     }
 729
 730     // recombine path parts in one variable
 731     m_strPath.Empty();
 732     for ( n = 0; n < aParts.GetCount(); n++ ) {
 733         m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
 734     }
 735
 736     return true;
 737 }
 738
 739 void wxFileConfig::SetPath(const wxString& strPath)
 740 {
 741     DoSetPath(strPath, true /* create missing path components */);
 742 }
 743
 744 const wxString& wxFileConfig::GetPath() const
 745 {
 746     return m_strPath;
 747 }
 748
 749 // ----------------------------------------------------------------------------
 750 // enumeration
 751 // ----------------------------------------------------------------------------
 752
 753 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
 754 {
 755     lIndex = 0;
 756     return GetNextGroup(str, lIndex);
 757 }
 758
 759 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
 760 {
 761     if ( size_t(lIndex) < m_pCurrentGroup->Groups().GetCount() ) {
 762         str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
 763         return true;
 764     }
 765     else
 766         return false;
 767 }
 768
 769 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
 770 {
 771     lIndex = 0;
 772     return GetNextEntry(str, lIndex);
 773 }
 774
 775 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
 776 {
 777     if ( size_t(lIndex) < m_pCurrentGroup->Entries().GetCount() ) {
 778         str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
 779         return true;
 780     }
 781     else
 782         return false;
 783 }
 784
 785 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
 786 {
 787     size_t n = m_pCurrentGroup->Entries().GetCount();
 788     if ( bRecursive ) {
 789         wxFileConfig * const self = const_cast<wxFileConfig *>(this);
 790
 791         wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 792         size_t nSubgroups = m_pCurrentGroup->Groups().GetCount();
 793         for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 794             self->m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 795             n += GetNumberOfEntries(true);
 796             self->m_pCurrentGroup = pOldCurrentGroup;
 797         }
 798     }
 799
 800     return n;
 801 }
 802
 803 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
 804 {
 805     size_t n = m_pCurrentGroup->Groups().GetCount();
 806     if ( bRecursive ) {
 807         wxFileConfig * const self = const_cast<wxFileConfig *>(this);
 808
 809         wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 810         size_t nSubgroups = m_pCurrentGroup->Groups().GetCount();
 811         for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 812             self->m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 813             n += GetNumberOfGroups(true);
 814             self->m_pCurrentGroup = pOldCurrentGroup;
 815         }
 816     }
 817
 818     return n;
 819 }
 820
 821 // ----------------------------------------------------------------------------
 822 // tests for existence
 823 // ----------------------------------------------------------------------------
 824
 825 bool wxFileConfig::HasGroup(const wxString& strName) const
 826 {
 827     // special case: DoSetPath("") does work as it's equivalent to DoSetPath("/")
 828     // but there is no group with empty name so treat this separately
 829     if ( strName.empty() )
 830         return false;
 831
 832     const wxString pathOld = GetPath();
 833
 834     wxFileConfig *self = const_cast<wxFileConfig *>(this);
 835     const bool
 836         rc = self->DoSetPath(strName, false /* don't create missing components */);
 837
 838     self->SetPath(pathOld);
 839
 840     return rc;
 841 }
 842
 843 bool wxFileConfig::HasEntry(const wxString& entry) const
 844 {
 845     // path is the part before the last "/"
 846     wxString path = entry.BeforeLast(wxCONFIG_PATH_SEPARATOR);
 847
 848     // except in the special case of "/keyname" when there is nothing before "/"
 849     if ( path.empty() && *entry.c_str() == wxCONFIG_PATH_SEPARATOR )
 850     {
 851         path = wxCONFIG_PATH_SEPARATOR;
 852     }
 853
 854     // change to the path of the entry if necessary and remember the old path
 855     // to restore it later
 856     wxString pathOld;
 857     wxFileConfig * const self = const_cast<wxFileConfig *>(this);
 858     if ( !path.empty() )
 859     {
 860         pathOld = GetPath();
 861         if ( pathOld.empty() )
 862             pathOld = wxCONFIG_PATH_SEPARATOR;
 863
 864         if ( !self->DoSetPath(path, false /* don't create if doesn't exist */) )
 865         {
 866             return false;
 867         }
 868     }
 869
 870     // check if the entry exists in this group
 871     const bool exists = m_pCurrentGroup->FindEntry(
 872                             entry.AfterLast(wxCONFIG_PATH_SEPARATOR)) != NULL;
 873
 874     // restore the old path if we changed it above
 875     if ( !pathOld.empty() )
 876     {
 877         self->SetPath(pathOld);
 878     }
 879
 880     return exists;
 881 }
 882
 883 // ----------------------------------------------------------------------------
 884 // read/write values
 885 // ----------------------------------------------------------------------------
 886
 887 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
 888 {
 889     wxConfigPathChanger path(this, key);
 890
 891     wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
 892     if (pEntry == NULL) {
 893         return false;
 894     }
 895
 896     *pStr = pEntry->Value();
 897
 898     return true;
 899 }
 900
 901 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
 902 {
 903     wxString str;
 904     if ( !Read(key, &str) )
 905         return false;
 906
 907     // extra spaces shouldn't prevent us from reading numeric values
 908     str.Trim();
 909
 910     return str.ToLong(pl);
 911 }
 912
 913 #if wxUSE_BASE64
 914
 915 bool wxFileConfig::DoReadBinary(const wxString& key, wxMemoryBuffer* buf) const
 916 {
 917     wxCHECK_MSG( buf, false, wxT("NULL buffer") );
 918
 919     wxString str;
 920     if ( !Read(key, &str) )
 921         return false;
 922
 923     *buf = wxBase64Decode(str);
 924     return true;
 925 }
 926
 927 #endif // wxUSE_BASE64
 928
 929 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
 930 {
 931     wxConfigPathChanger     path(this, key);
 932     wxString                strName = path.Name();
 933
 934     wxLogTrace( FILECONF_TRACE_MASK,
 935                 wxT("  Writing String '%s' = '%s' to Group '%s'"),
 936                 strName.c_str(),
 937                 szValue.c_str(),
 938                 GetPath().c_str() );
 939
 940     if ( strName.empty() )
 941     {
 942             // setting the value of a group is an error
 943
 944         wxASSERT_MSG( szValue.empty(), wxT("can't set value of a group!") );
 945
 946             // ... except if it's empty in which case it's a way to force it's creation
 947
 948         wxLogTrace( FILECONF_TRACE_MASK,
 949                     wxT("  Creating group %s"),
 950                     m_pCurrentGroup->Name().c_str() );
 951
 952         SetDirty();
 953
 954         // this will add a line for this group if it didn't have it before (or
 955         // do nothing for the root but it's ok as it always exists anyhow)
 956         (void)m_pCurrentGroup->GetGroupLine();
 957     }
 958     else
 959     {
 960         // writing an entry check that the name is reasonable
 961         if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX )
 962         {
 963             wxLogError( _("Config entry name cannot start with '%c'."),
 964                         wxCONFIG_IMMUTABLE_PREFIX);
 965             return false;
 966         }
 967
 968         wxFileConfigEntry   *pEntry = m_pCurrentGroup->FindEntry(strName);
 969
 970         if ( pEntry == 0 )
 971         {
 972             wxLogTrace( FILECONF_TRACE_MASK,
 973                         wxT("  Adding Entry %s"),
 974                         strName.c_str() );
 975             pEntry = m_pCurrentGroup->AddEntry(strName);
 976         }
 977
 978         wxLogTrace( FILECONF_TRACE_MASK,
 979                     wxT("  Setting value %s"),
 980                     szValue.c_str() );
 981         pEntry->SetValue(szValue);
 982
 983         SetDirty();
 984     }
 985
 986     return true;
 987 }
 988
 989 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
 990 {
 991   return Write(key, wxString::Format(wxT("%ld"), lValue));
 992 }
 993
 994 #if wxUSE_BASE64
 995
 996 bool wxFileConfig::DoWriteBinary(const wxString& key, const wxMemoryBuffer& buf)
 997 {
 998   return Write(key, wxBase64Encode(buf));
 999 }
1000
1001 #endif // wxUSE_BASE64
1002
1003 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
1004 {
1005   if ( !IsDirty() || !m_fnLocalFile.GetFullPath() )
1006     return true;
1007
1008   // set the umask if needed
1009   wxCHANGE_UMASK(m_umask);
1010
1011   wxTempFile file(m_fnLocalFile.GetFullPath());
1012
1013   if ( !file.IsOpened() )
1014   {
1015     wxLogError(_("can't open user configuration file."));
1016     return false;
1017   }
1018
1019   // write all strings to file
1020   wxString filetext;
1021   filetext.reserve(4096);
1022   for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1023   {
1024     filetext << p->Text() << wxTextFile::GetEOL();
1025   }
1026
1027   if ( !file.Write(filetext, *m_conv) )
1028   {
1029     wxLogError(_("can't write user configuration file."));
1030     return false;
1031   }
1032
1033   if ( !file.Commit() )
1034   {
1035       wxLogError(_("Failed to update user configuration file."));
1036
1037       return false;
1038   }
1039
1040   ResetDirty();
1041
1042 #if defined( __WXOSX_MAC__ ) && wxOSX_USE_CARBON
1043   m_fnLocalFile.MacSetTypeAndCreator('TEXT', 'ttxt');
1044 #endif // __WXMAC__
1045
1046   return true;
1047 }
1048
1049 #if wxUSE_STREAMS
1050
1051 bool wxFileConfig::Save(wxOutputStream& os, const wxMBConv& conv)
1052 {
1053     // save unconditionally, even if not dirty
1054     for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1055     {
1056         wxString line = p->Text();
1057         line += wxTextFile::GetEOL();
1058
1059         wxCharBuffer buf(line.mb_str(conv));
1060         if ( !os.Write(buf, strlen(buf)) )
1061         {
1062             wxLogError(_("Error saving user configuration data."));
1063
1064             return false;
1065         }
1066     }
1067
1068     ResetDirty();
1069
1070     return true;
1071 }
1072
1073 #endif // wxUSE_STREAMS
1074
1075 // ----------------------------------------------------------------------------
1076 // renaming groups/entries
1077 // ----------------------------------------------------------------------------
1078
1079 bool wxFileConfig::RenameEntry(const wxString& oldName,
1080                                const wxString& newName)
1081 {
1082     wxASSERT_MSG( oldName.find(wxCONFIG_PATH_SEPARATOR) == wxString::npos,
1083                    wxT("RenameEntry(): paths are not supported") );
1084
1085     // check that the entry exists
1086     wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
1087     if ( !oldEntry )
1088         return false;
1089
1090     // check that the new entry doesn't already exist
1091     if ( m_pCurrentGroup->FindEntry(newName) )
1092         return false;
1093
1094     // delete the old entry, create the new one
1095     wxString value = oldEntry->Value();
1096     if ( !m_pCurrentGroup->DeleteEntry(oldName) )
1097         return false;
1098
1099     SetDirty();
1100
1101     wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
1102     newEntry->SetValue(value);
1103
1104     return true;
1105 }
1106
1107 bool wxFileConfig::RenameGroup(const wxString& oldName,
1108                                const wxString& newName)
1109 {
1110     // check that the group exists
1111     wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
1112     if ( !group )
1113         return false;
1114
1115     // check that the new group doesn't already exist
1116     if ( m_pCurrentGroup->FindSubgroup(newName) )
1117         return false;
1118
1119     group->Rename(newName);
1120
1121     SetDirty();
1122
1123     return true;
1124 }
1125
1126 // ----------------------------------------------------------------------------
1127 // delete groups/entries
1128 // ----------------------------------------------------------------------------
1129
1130 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
1131 {
1132   wxConfigPathChanger path(this, key);
1133
1134   if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
1135     return false;
1136
1137   SetDirty();
1138
1139   if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1140     if ( m_pCurrentGroup != m_pRootGroup ) {
1141       wxFileConfigGroup *pGroup = m_pCurrentGroup;
1142       SetPath(wxT(".."));  // changes m_pCurrentGroup!
1143       m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
1144     }
1145     //else: never delete the root group
1146   }
1147
1148   return true;
1149 }
1150
1151 bool wxFileConfig::DeleteGroup(const wxString& key)
1152 {
1153   wxConfigPathChanger path(this, RemoveTrailingSeparator(key));
1154
1155   if ( !m_pCurrentGroup->DeleteSubgroupByName(path.Name()) )
1156       return false;
1157
1158   path.UpdateIfDeleted();
1159
1160   SetDirty();
1161
1162   return true;
1163 }
1164
1165 bool wxFileConfig::DeleteAll()
1166 {
1167   CleanUp();
1168
1169   if ( m_fnLocalFile.IsOk() )
1170   {
1171       if ( m_fnLocalFile.FileExists() &&
1172            !wxRemoveFile(m_fnLocalFile.GetFullPath()) )
1173       {
1174           wxLogSysError(_("can't delete user configuration file '%s'"),
1175                         m_fnLocalFile.GetFullPath().c_str());
1176           return false;
1177       }
1178   }
1179
1180   Init();
1181
1182   return true;
1183 }
1184
1185 // ----------------------------------------------------------------------------
1186 // linked list functions
1187 // ----------------------------------------------------------------------------
1188
1189     // append a new line to the end of the list
1190
1191 wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
1192 {
1193     wxLogTrace( FILECONF_TRACE_MASK,
1194                 wxT("    ** Adding Line '%s'"),
1195                 str.c_str() );
1196     wxLogTrace( FILECONF_TRACE_MASK,
1197                 wxT("        head: %s"),
1198                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1199                                : wxEmptyString) );
1200     wxLogTrace( FILECONF_TRACE_MASK,
1201                 wxT("        tail: %s"),
1202                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1203                                : wxEmptyString) );
1204
1205     wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
1206
1207     if ( m_linesTail == NULL )
1208     {
1209         // list is empty
1210         m_linesHead = pLine;
1211     }
1212     else
1213     {
1214         // adjust pointers
1215         m_linesTail->SetNext(pLine);
1216         pLine->SetPrev(m_linesTail);
1217     }
1218
1219     m_linesTail = pLine;
1220
1221     wxLogTrace( FILECONF_TRACE_MASK,
1222                 wxT("        head: %s"),
1223                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1224                                : wxEmptyString) );
1225     wxLogTrace( FILECONF_TRACE_MASK,
1226                 wxT("        tail: %s"),
1227                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1228                                : wxEmptyString) );
1229
1230     return m_linesTail;
1231 }
1232
1233 // insert a new line after the given one or in the very beginning if !pLine
1234 wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
1235                                                    wxFileConfigLineList *pLine)
1236 {
1237     wxLogTrace( FILECONF_TRACE_MASK,
1238                 wxT("    ** Inserting Line '%s' after '%s'"),
1239                 str.c_str(),
1240                 ((pLine) ? (const wxChar*)pLine->Text().c_str()
1241                          : wxEmptyString) );
1242     wxLogTrace( FILECONF_TRACE_MASK,
1243                 wxT("        head: %s"),
1244                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1245                                : wxEmptyString) );
1246     wxLogTrace( FILECONF_TRACE_MASK,
1247                 wxT("        tail: %s"),
1248                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1249                                : wxEmptyString) );
1250
1251     if ( pLine == m_linesTail )
1252         return LineListAppend(str);
1253
1254     wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
1255     if ( pLine == NULL )
1256     {
1257         // prepend to the list
1258         pNewLine->SetNext(m_linesHead);
1259         m_linesHead->SetPrev(pNewLine);
1260         m_linesHead = pNewLine;
1261     }
1262     else
1263     {
1264         // insert before pLine
1265         wxFileConfigLineList *pNext = pLine->Next();
1266         pNewLine->SetNext(pNext);
1267         pNewLine->SetPrev(pLine);
1268         pNext->SetPrev(pNewLine);
1269         pLine->SetNext(pNewLine);
1270     }
1271
1272     wxLogTrace( FILECONF_TRACE_MASK,
1273                 wxT("        head: %s"),
1274                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1275                                : wxEmptyString) );
1276     wxLogTrace( FILECONF_TRACE_MASK,
1277                 wxT("        tail: %s"),
1278                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1279                                : wxEmptyString) );
1280
1281     return pNewLine;
1282 }
1283
1284 void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
1285 {
1286     wxLogTrace( FILECONF_TRACE_MASK,
1287                 wxT("    ** Removing Line '%s'"),
1288                 pLine->Text().c_str() );
1289     wxLogTrace( FILECONF_TRACE_MASK,
1290                 wxT("        head: %s"),
1291                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1292                                : wxEmptyString) );
1293     wxLogTrace( FILECONF_TRACE_MASK,
1294                 wxT("        tail: %s"),
1295                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1296                                : wxEmptyString) );
1297
1298     wxFileConfigLineList    *pPrev = pLine->Prev(),
1299                             *pNext = pLine->Next();
1300
1301         // first entry?
1302
1303     if ( pPrev == NULL )
1304         m_linesHead = pNext;
1305     else
1306         pPrev->SetNext(pNext);
1307
1308         // last entry?
1309
1310     if ( pNext == NULL )
1311         m_linesTail = pPrev;
1312     else
1313         pNext->SetPrev(pPrev);
1314
1315     wxLogTrace( FILECONF_TRACE_MASK,
1316                 wxT("        head: %s"),
1317                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1318                                : wxEmptyString) );
1319     wxLogTrace( FILECONF_TRACE_MASK,
1320                 wxT("        tail: %s"),
1321                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1322                                : wxEmptyString) );
1323
1324     delete pLine;
1325 }
1326
1327 bool wxFileConfig::LineListIsEmpty()
1328 {
1329     return m_linesHead == NULL;
1330 }
1331
1332 // ============================================================================
1333 // wxFileConfig::wxFileConfigGroup
1334 // ============================================================================
1335
1336 // ----------------------------------------------------------------------------
1337 // ctor/dtor
1338 // ----------------------------------------------------------------------------
1339
1340 // ctor
1341 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1342                                        const wxString& strName,
1343                                        wxFileConfig *pConfig)
1344                          : m_aEntries(CompareEntries),
1345                            m_aSubgroups(CompareGroups),
1346                            m_strName(strName)
1347 {
1348   m_pConfig = pConfig;
1349   m_pParent = pParent;
1350   m_pLine   = NULL;
1351
1352   m_pLastEntry = NULL;
1353   m_pLastGroup = NULL;
1354 }
1355
1356 // dtor deletes all children
1357 wxFileConfigGroup::~wxFileConfigGroup()
1358 {
1359   // entries
1360   size_t n, nCount = m_aEntries.GetCount();
1361   for ( n = 0; n < nCount; n++ )
1362     delete m_aEntries[n];
1363
1364   // subgroups
1365   nCount = m_aSubgroups.GetCount();
1366   for ( n = 0; n < nCount; n++ )
1367     delete m_aSubgroups[n];
1368 }
1369
1370 // ----------------------------------------------------------------------------
1371 // line
1372 // ----------------------------------------------------------------------------
1373
1374 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1375 {
1376     // for a normal (i.e. not root) group this method shouldn't be called twice
1377     // unless we are resetting the line
1378     wxASSERT_MSG( !m_pParent || !m_pLine || !pLine,
1379                    wxT("changing line for a non-root group?") );
1380
1381     m_pLine = pLine;
1382 }
1383
1384 /*
1385   This is a bit complicated, so let me explain it in details. All lines that
1386   were read from the local file (the only one we will ever modify) are stored
1387   in a (doubly) linked list. Our problem is to know at which position in this
1388   list should we insert the new entries/subgroups. To solve it we keep three
1389   variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1390
1391   m_pLine points to the line containing "[group_name]"
1392   m_pLastEntry points to the last entry of this group in the local file.
1393   m_pLastGroup                   subgroup
1394
1395   Initially, they're NULL all three. When the group (an entry/subgroup) is read
1396   from the local file, the corresponding variable is set. However, if the group
1397   was read from the global file and then modified or created by the application
1398   these variables are still NULL and we need to create the corresponding lines.
1399   See the following functions (and comments preceding them) for the details of
1400   how we do it.
1401
1402   Also, when our last entry/group are deleted we need to find the new last
1403   element - the code in DeleteEntry/Subgroup does this by backtracking the list
1404   of lines until it either founds an entry/subgroup (and this is the new last
1405   element) or the m_pLine of the group, in which case there are no more entries
1406   (or subgroups) left and m_pLast<element> becomes NULL.
1407
1408   NB: This last problem could be avoided for entries if we added new entries
1409       immediately after m_pLine, but in this case the entries would appear
1410       backwards in the config file (OTOH, it's not that important) and as we
1411       would still need to do it for the subgroups the code wouldn't have been
1412       significantly less complicated.
1413 */
1414
1415 // Return the line which contains "[our name]". If we're still not in the list,
1416 // add our line to it immediately after the last line of our parent group if we
1417 // have it or in the very beginning if we're the root group.
1418 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1419 {
1420     wxLogTrace( FILECONF_TRACE_MASK,
1421                 wxT("  GetGroupLine() for Group '%s'"),
1422                 Name().c_str() );
1423
1424     if ( !m_pLine )
1425     {
1426         wxLogTrace( FILECONF_TRACE_MASK,
1427                     wxT("    Getting Line item pointer") );
1428
1429         wxFileConfigGroup   *pParent = Parent();
1430
1431         // this group wasn't present in local config file, add it now
1432         if ( pParent )
1433         {
1434             wxLogTrace( FILECONF_TRACE_MASK,
1435                         wxT("    checking parent '%s'"),
1436                         pParent->Name().c_str() );
1437
1438             wxString    strFullName;
1439
1440             // add 1 to the name because we don't want to start with '/'
1441             strFullName << wxT("[")
1442                         << FilterOutEntryName(GetFullName().c_str() + 1)
1443                         << wxT("]");
1444             m_pLine = m_pConfig->LineListInsert(strFullName,
1445                                                 pParent->GetLastGroupLine());
1446             pParent->SetLastGroup(this);  // we're surely after all the others
1447         }
1448         //else: this is the root group and so we return NULL because we don't
1449         //      have any group line
1450     }
1451
1452     return m_pLine;
1453 }
1454
1455 // Return the last line belonging to the subgroups of this group (after which
1456 // we can add a new subgroup), if we don't have any subgroups or entries our
1457 // last line is the group line (m_pLine) itself.
1458 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1459 {
1460     // if we have any subgroups, our last line is the last line of the last
1461     // subgroup
1462     if ( m_pLastGroup )
1463     {
1464         wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1465
1466         wxASSERT_MSG( pLine, wxT("last group must have !NULL associated line") );
1467
1468         return pLine;
1469     }
1470
1471     // no subgroups, so the last line is the line of thelast entry (if any)
1472     return GetLastEntryLine();
1473 }
1474
1475 // return the last line belonging to the entries of this group (after which
1476 // we can add a new entry), if we don't have any entries we will add the new
1477 // one immediately after the group line itself.
1478 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1479 {
1480     wxLogTrace( FILECONF_TRACE_MASK,
1481                 wxT("  GetLastEntryLine() for Group '%s'"),
1482                 Name().c_str() );
1483
1484     if ( m_pLastEntry )
1485     {
1486         wxFileConfigLineList    *pLine = m_pLastEntry->GetLine();
1487
1488         wxASSERT_MSG( pLine, wxT("last entry must have !NULL associated line") );
1489
1490         return pLine;
1491     }
1492
1493     // no entries: insert after the group header, if any
1494     return GetGroupLine();
1495 }
1496
1497 void wxFileConfigGroup::SetLastEntry(wxFileConfigEntry *pEntry)
1498 {
1499     m_pLastEntry = pEntry;
1500
1501     if ( !m_pLine )
1502     {
1503         // the only situation in which a group without its own line can have
1504         // an entry is when the first entry is added to the initially empty
1505         // root pseudo-group
1506         wxASSERT_MSG( !m_pParent, wxT("unexpected for non root group") );
1507
1508         // let the group know that it does have a line in the file now
1509         m_pLine = pEntry->GetLine();
1510     }
1511 }
1512
1513 // ----------------------------------------------------------------------------
1514 // group name
1515 // ----------------------------------------------------------------------------
1516
1517 void wxFileConfigGroup::UpdateGroupAndSubgroupsLines()
1518 {
1519     // update the line of this group
1520     wxFileConfigLineList *line = GetGroupLine();
1521     wxCHECK_RET( line, wxT("a non root group must have a corresponding line!") );
1522
1523     // +1: skip the leading '/'
1524     line->SetText(wxString::Format(wxT("[%s]"), GetFullName().c_str() + 1));
1525
1526
1527     // also update all subgroups as they have this groups name in their lines
1528     const size_t nCount = m_aSubgroups.GetCount();
1529     for ( size_t n = 0; n < nCount; n++ )
1530     {
1531         m_aSubgroups[n]->UpdateGroupAndSubgroupsLines();
1532     }
1533 }
1534
1535 void wxFileConfigGroup::Rename(const wxString& newName)
1536 {
1537     wxCHECK_RET( m_pParent, wxT("the root group can't be renamed") );
1538
1539     if ( newName == m_strName )
1540         return;
1541
1542     // we need to remove the group from the parent and it back under the new
1543     // name to keep the parents array of subgroups alphabetically sorted
1544     m_pParent->m_aSubgroups.Remove(this);
1545
1546     m_strName = newName;
1547
1548     m_pParent->m_aSubgroups.Add(this);
1549
1550     // update the group lines recursively
1551     UpdateGroupAndSubgroupsLines();
1552 }
1553
1554 wxString wxFileConfigGroup::GetFullName() const
1555 {
1556     wxString fullname;
1557     if ( Parent() )
1558         fullname = Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1559
1560     return fullname;
1561 }
1562
1563 // ----------------------------------------------------------------------------
1564 // find an item
1565 // ----------------------------------------------------------------------------
1566
1567 // use binary search because the array is sorted
1568 wxFileConfigEntry *
1569 wxFileConfigGroup::FindEntry(const wxString& name) const
1570 {
1571   size_t i,
1572        lo = 0,
1573        hi = m_aEntries.GetCount();
1574   int res;
1575   wxFileConfigEntry *pEntry;
1576
1577   while ( lo < hi ) {
1578     i = (lo + hi)/2;
1579     pEntry = m_aEntries[i];
1580
1581     #if wxCONFIG_CASE_SENSITIVE
1582       res = pEntry->Name().compare(name);
1583     #else
1584       res = pEntry->Name().CmpNoCase(name);
1585     #endif
1586
1587     if ( res > 0 )
1588       hi = i;
1589     else if ( res < 0 )
1590       lo = i + 1;
1591     else
1592       return pEntry;
1593   }
1594
1595   return NULL;
1596 }
1597
1598 wxFileConfigGroup *
1599 wxFileConfigGroup::FindSubgroup(const wxString& name) const
1600 {
1601   size_t i,
1602        lo = 0,
1603        hi = m_aSubgroups.GetCount();
1604   int res;
1605   wxFileConfigGroup *pGroup;
1606
1607   while ( lo < hi ) {
1608     i = (lo + hi)/2;
1609     pGroup = m_aSubgroups[i];
1610
1611     #if wxCONFIG_CASE_SENSITIVE
1612       res = pGroup->Name().compare(name);
1613     #else
1614       res = pGroup->Name().CmpNoCase(name);
1615     #endif
1616
1617     if ( res > 0 )
1618       hi = i;
1619     else if ( res < 0 )
1620       lo = i + 1;
1621     else
1622       return pGroup;
1623   }
1624
1625   return NULL;
1626 }
1627
1628 // ----------------------------------------------------------------------------
1629 // create a new item
1630 // ----------------------------------------------------------------------------
1631
1632 // create a new entry and add it to the current group
1633 wxFileConfigEntry *wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1634 {
1635     wxASSERT( FindEntry(strName) == 0 );
1636
1637     wxFileConfigEntry   *pEntry = new wxFileConfigEntry(this, strName, nLine);
1638
1639     m_aEntries.Add(pEntry);
1640     return pEntry;
1641 }
1642
1643 // create a new group and add it to the current group
1644 wxFileConfigGroup *wxFileConfigGroup::AddSubgroup(const wxString& strName)
1645 {
1646     wxASSERT( FindSubgroup(strName) == 0 );
1647
1648     wxFileConfigGroup   *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1649
1650     m_aSubgroups.Add(pGroup);
1651     return pGroup;
1652 }
1653
1654 // ----------------------------------------------------------------------------
1655 // delete an item
1656 // ----------------------------------------------------------------------------
1657
1658 /*
1659   The delete operations are _very_ slow if we delete the last item of this
1660   group (see comments before GetXXXLineXXX functions for more details),
1661   so it's much better to start with the first entry/group if we want to
1662   delete several of them.
1663  */
1664
1665 bool wxFileConfigGroup::DeleteSubgroupByName(const wxString& name)
1666 {
1667     wxFileConfigGroup * const pGroup = FindSubgroup(name);
1668
1669     return pGroup ? DeleteSubgroup(pGroup) : false;
1670 }
1671
1672 // Delete the subgroup and remove all references to it from
1673 // other data structures.
1674 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1675 {
1676     wxCHECK_MSG( pGroup, false, wxT("deleting non existing group?") );
1677
1678     wxLogTrace( FILECONF_TRACE_MASK,
1679                 wxT("Deleting group '%s' from '%s'"),
1680                 pGroup->Name().c_str(),
1681                 Name().c_str() );
1682
1683     wxLogTrace( FILECONF_TRACE_MASK,
1684                 wxT("  (m_pLine) = prev: %p, this %p, next %p"),
1685                 m_pLine ? static_cast<void*>(m_pLine->Prev()) : 0,
1686                 static_cast<void*>(m_pLine),
1687                 m_pLine ? static_cast<void*>(m_pLine->Next()) : 0 );
1688     wxLogTrace( FILECONF_TRACE_MASK,
1689                 wxT("  text: '%s'"),
1690                 m_pLine ? (const wxChar*)m_pLine->Text().c_str()
1691                         : wxEmptyString );
1692
1693     // delete all entries...
1694     size_t nCount = pGroup->m_aEntries.GetCount();
1695
1696     wxLogTrace(FILECONF_TRACE_MASK,
1697                wxT("Removing %lu entries"), (unsigned long)nCount );
1698
1699     for ( size_t nEntry = 0; nEntry < nCount; nEntry++ )
1700     {
1701         wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1702
1703         if ( pLine )
1704         {
1705             wxLogTrace( FILECONF_TRACE_MASK,
1706                         wxT("    '%s'"),
1707                         pLine->Text().c_str() );
1708             m_pConfig->LineListRemove(pLine);
1709         }
1710     }
1711
1712     // ...and subgroups of this subgroup
1713     nCount = pGroup->m_aSubgroups.GetCount();
1714
1715     wxLogTrace( FILECONF_TRACE_MASK,
1716                 wxT("Removing %lu subgroups"), (unsigned long)nCount );
1717
1718     for ( size_t nGroup = 0; nGroup < nCount; nGroup++ )
1719     {
1720         pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1721     }
1722
1723     // and then finally the group itself
1724     wxFileConfigLineList *pLine = pGroup->m_pLine;
1725     if ( pLine )
1726     {
1727         wxLogTrace( FILECONF_TRACE_MASK,
1728                     wxT("  Removing line for group '%s' : '%s'"),
1729                     pGroup->Name().c_str(),
1730                     pLine->Text().c_str() );
1731         wxLogTrace( FILECONF_TRACE_MASK,
1732                     wxT("  Removing from group '%s' : '%s'"),
1733                     Name().c_str(),
1734                     ((m_pLine) ? (const wxChar*)m_pLine->Text().c_str()
1735                                : wxEmptyString) );
1736
1737         // notice that we may do this test inside the previous "if"
1738         // because the last entry's line is surely !NULL
1739         if ( pGroup == m_pLastGroup )
1740         {
1741             wxLogTrace( FILECONF_TRACE_MASK,
1742                         wxT("  Removing last group") );
1743
1744             // our last entry is being deleted, so find the last one which
1745             // stays by going back until we find a subgroup or reach the
1746             // group line
1747             const size_t nSubgroups = m_aSubgroups.GetCount();
1748
1749             m_pLastGroup = NULL;
1750             for ( wxFileConfigLineList *pl = pLine->Prev();
1751                   pl && !m_pLastGroup;
1752                   pl = pl->Prev() )
1753             {
1754                 // does this line belong to our subgroup?
1755                 for ( size_t n = 0; n < nSubgroups; n++ )
1756                 {
1757                     // do _not_ call GetGroupLine! we don't want to add it to
1758                     // the local file if it's not already there
1759                     if ( m_aSubgroups[n]->m_pLine == pl )
1760                     {
1761                         m_pLastGroup = m_aSubgroups[n];
1762                         break;
1763                     }
1764                 }
1765
1766                 if ( pl == m_pLine )
1767                     break;
1768             }
1769         }
1770
1771         m_pConfig->LineListRemove(pLine);
1772     }
1773     else
1774     {
1775         wxLogTrace( FILECONF_TRACE_MASK,
1776                     wxT("  No line entry for Group '%s'?"),
1777                     pGroup->Name().c_str() );
1778     }
1779
1780     m_aSubgroups.Remove(pGroup);
1781     delete pGroup;
1782
1783     return true;
1784 }
1785
1786 bool wxFileConfigGroup::DeleteEntry(const wxString& name)
1787 {
1788   wxFileConfigEntry *pEntry = FindEntry(name);
1789   if ( !pEntry )
1790   {
1791       // entry doesn't exist, nothing to do
1792       return false;
1793   }
1794
1795   wxFileConfigLineList *pLine = pEntry->GetLine();
1796   if ( pLine != NULL ) {
1797     // notice that we may do this test inside the previous "if" because the
1798     // last entry's line is surely !NULL
1799     if ( pEntry == m_pLastEntry ) {
1800       // our last entry is being deleted - find the last one which stays
1801       wxASSERT( m_pLine != NULL );  // if we have an entry with !NULL pLine...
1802
1803       // find the previous entry (if any)
1804       wxFileConfigEntry *pNewLast = NULL;
1805       const wxFileConfigLineList * const
1806         pNewLastLine = m_pLastEntry->GetLine()->Prev();
1807       const size_t nEntries = m_aEntries.GetCount();
1808       for ( size_t n = 0; n < nEntries; n++ ) {
1809         if ( m_aEntries[n]->GetLine() == pNewLastLine ) {
1810           pNewLast = m_aEntries[n];
1811           break;
1812         }
1813       }
1814
1815       // pNewLast can be NULL here -- it's ok and can happen if we have no
1816       // entries left
1817       m_pLastEntry = pNewLast;
1818     }
1819
1820     m_pConfig->LineListRemove(pLine);
1821   }
1822
1823   m_aEntries.Remove(pEntry);
1824   delete pEntry;
1825
1826   return true;
1827 }
1828
1829 // ============================================================================
1830 // wxFileConfig::wxFileConfigEntry
1831 // ============================================================================
1832
1833 // ----------------------------------------------------------------------------
1834 // ctor
1835 // ----------------------------------------------------------------------------
1836 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1837                                        const wxString& strName,
1838                                        int nLine)
1839                          : m_strName(strName)
1840 {
1841   wxASSERT( !strName.empty() );
1842
1843   m_pParent = pParent;
1844   m_nLine   = nLine;
1845   m_pLine   = NULL;
1846
1847   m_bHasValue = false;
1848
1849   m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1850   if ( m_bImmutable )
1851     m_strName.erase(0, 1);  // remove first character
1852 }
1853
1854 // ----------------------------------------------------------------------------
1855 // set value
1856 // ----------------------------------------------------------------------------
1857
1858 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1859 {
1860   if ( m_pLine != NULL ) {
1861     wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1862                  Name().c_str(), m_pParent->GetFullName().c_str());
1863   }
1864
1865   m_pLine = pLine;
1866   Group()->SetLastEntry(this);
1867 }
1868
1869 // second parameter is false if we read the value from file and prevents the
1870 // entry from being marked as 'dirty'
1871 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1872 {
1873     if ( bUser && IsImmutable() )
1874     {
1875         wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1876                       Name().c_str());
1877         return;
1878     }
1879
1880     // do nothing if it's the same value: but don't test for it if m_bHasValue
1881     // hadn't been set yet or we'd never write empty values to the file
1882     if ( m_bHasValue && strValue == m_strValue )
1883         return;
1884
1885     m_bHasValue = true;
1886     m_strValue = strValue;
1887
1888     if ( bUser )
1889     {
1890         wxString strValFiltered;
1891
1892         if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS )
1893         {
1894             strValFiltered = strValue;
1895         }
1896         else {
1897             strValFiltered = FilterOutValue(strValue);
1898         }
1899
1900         wxString    strLine;
1901         strLine << FilterOutEntryName(m_strName) << wxT('=') << strValFiltered;
1902
1903         if ( m_pLine )
1904         {
1905             // entry was read from the local config file, just modify the line
1906             m_pLine->SetText(strLine);
1907         }
1908         else // this entry didn't exist in the local file
1909         {
1910             // add a new line to the file: note that line returned by
1911             // GetLastEntryLine() may be NULL if we're in the root group and it
1912             // doesn't have any entries yet, but this is ok as passing NULL
1913             // line to LineListInsert() means to prepend new line to the list
1914             wxFileConfigLineList *line = Group()->GetLastEntryLine();
1915             m_pLine = Group()->Config()->LineListInsert(strLine, line);
1916
1917             Group()->SetLastEntry(this);
1918         }
1919     }
1920 }
1921
1922 // ============================================================================
1923 // global functions
1924 // ============================================================================
1925
1926 // ----------------------------------------------------------------------------
1927 // compare functions for array sorting
1928 // ----------------------------------------------------------------------------
1929
1930 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1931 {
1932 #if wxCONFIG_CASE_SENSITIVE
1933     return p1->Name().compare(p2->Name());
1934 #else
1935     return p1->Name().CmpNoCase(p2->Name());
1936 #endif
1937 }
1938
1939 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1940 {
1941 #if wxCONFIG_CASE_SENSITIVE
1942     return p1->Name().compare(p2->Name());
1943 #else
1944     return p1->Name().CmpNoCase(p2->Name());
1945 #endif
1946 }
1947
1948 // ----------------------------------------------------------------------------
1949 // filter functions
1950 // ----------------------------------------------------------------------------
1951
1952 // undo FilterOutValue
1953 static wxString FilterInValue(const wxString& str)
1954 {
1955     wxString strResult;
1956     if ( str.empty() )
1957         return strResult;
1958
1959     strResult.reserve(str.length());
1960
1961     wxString::const_iterator i = str.begin();
1962     const bool bQuoted = *i == '"';
1963     if ( bQuoted )
1964         ++i;
1965
1966     for ( const wxString::const_iterator end = str.end(); i != end; ++i )
1967     {
1968         if ( *i == wxT('\\') )
1969         {
1970             if ( ++i == end )
1971             {
1972                 wxLogWarning(_("trailing backslash ignored in '%s'"), str.c_str());
1973                 break;
1974             }
1975
1976             switch ( (*i).GetValue() )
1977             {
1978                 case wxT('n'):
1979                     strResult += wxT('\n');
1980                     break;
1981
1982                 case wxT('r'):
1983                     strResult += wxT('\r');
1984                     break;
1985
1986                 case wxT('t'):
1987                     strResult += wxT('\t');
1988                     break;
1989
1990                 case wxT('\\'):
1991                     strResult += wxT('\\');
1992                     break;
1993
1994                 case wxT('"'):
1995                     strResult += wxT('"');
1996                     break;
1997             }
1998         }
1999         else // not a backslash
2000         {
2001             if ( *i != wxT('"') || !bQuoted )
2002             {
2003                 strResult += *i;
2004             }
2005             else if ( i != end - 1 )
2006             {
2007                 wxLogWarning(_("unexpected \" at position %d in '%s'."),
2008                              i - str.begin(), str.c_str());
2009             }
2010             //else: it's the last quote of a quoted string, ok
2011         }
2012     }
2013
2014     return strResult;
2015 }
2016
2017 // quote the string before writing it to file
2018 static wxString FilterOutValue(const wxString& str)
2019 {
2020    if ( !str )
2021       return str;
2022
2023   wxString strResult;
2024   strResult.Alloc(str.Len());
2025
2026   // quoting is necessary to preserve spaces in the beginning of the string
2027   bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
2028
2029   if ( bQuote )
2030     strResult += wxT('"');
2031
2032   wxChar c;
2033   for ( size_t n = 0; n < str.Len(); n++ ) {
2034     switch ( str[n].GetValue() ) {
2035       case wxT('\n'):
2036         c = wxT('n');
2037         break;
2038
2039       case wxT('\r'):
2040         c = wxT('r');
2041         break;
2042
2043       case wxT('\t'):
2044         c = wxT('t');
2045         break;
2046
2047       case wxT('\\'):
2048         c = wxT('\\');
2049         break;
2050
2051       case wxT('"'):
2052         if ( bQuote ) {
2053           c = wxT('"');
2054           break;
2055         }
2056         //else: fall through
2057
2058       default:
2059         strResult += str[n];
2060         continue;   // nothing special to do
2061     }
2062
2063     // we get here only for special characters
2064     strResult << wxT('\\') << c;
2065   }
2066
2067   if ( bQuote )
2068     strResult += wxT('"');
2069
2070   return strResult;
2071 }
2072
2073 // undo FilterOutEntryName
2074 static wxString FilterInEntryName(const wxString& str)
2075 {
2076   wxString strResult;
2077   strResult.Alloc(str.Len());
2078
2079   for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
2080     if ( *pc == wxT('\\') ) {
2081       // we need to test it here or we'd skip past the NUL in the loop line
2082       if ( *++pc == wxT('\0') )
2083         break;
2084     }
2085
2086     strResult += *pc;
2087   }
2088
2089   return strResult;
2090 }
2091
2092 // sanitize entry or group name: insert '\\' before any special characters
2093 static wxString FilterOutEntryName(const wxString& str)
2094 {
2095   wxString strResult;
2096   strResult.Alloc(str.Len());
2097
2098   for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
2099     const wxChar c = *pc;
2100
2101     // we explicitly allow some of "safe" chars and 8bit ASCII characters
2102     // which will probably never have special meaning and with which we can't
2103     // use isalnum() anyhow (in ASCII built, in Unicode it's just fine)
2104     //
2105     // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2106     //     should *not* be quoted
2107     if (
2108 #if !wxUSE_UNICODE
2109             ((unsigned char)c < 127) &&
2110 #endif // ANSI
2111          !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) )
2112     {
2113       strResult += wxT('\\');
2114     }
2115
2116     strResult += c;
2117   }
2118
2119   return strResult;
2120 }
2121
2122 // we can't put ?: in the ctor initializer list because it confuses some
2123 // broken compilers (Borland C++)
2124 static wxString GetAppName(const wxString& appName)
2125 {
2126     if ( !appName && wxTheApp )
2127         return wxTheApp->GetAppName();
2128     else
2129         return appName;
2130 }
2131
2132 #endif // wxUSE_CONFIG