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 Ballüder   &  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(__WXMAC__)
  50     #include  "wx/mac/private.h"  // includes mac headers
  51 #endif
  52
  53 #if defined(__WXMSW__)
  54     #include "wx/msw/private.h"
  55 #endif  //windows.h
  56 #if defined(__WXPM__)
  57     #define INCL_DOS
  58     #include <os2.h>
  59 #endif
  60
  61 #include  <stdlib.h>
  62 #include  <ctype.h>
  63
  64 // ----------------------------------------------------------------------------
  65 // macros
  66 // ----------------------------------------------------------------------------
  67 #define CONST_CAST ((wxFileConfig *)this)->
  68
  69 // ----------------------------------------------------------------------------
  70 // constants
  71 // ----------------------------------------------------------------------------
  72
  73 #ifndef MAX_PATH
  74     #define MAX_PATH 512
  75 #endif
  76
  77 #define FILECONF_TRACE_MASK _T("fileconf")
  78
  79 // ----------------------------------------------------------------------------
  80 // global functions declarations
  81 // ----------------------------------------------------------------------------
  82
  83 // compare functions for sorting the arrays
  84 static int LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2);
  85 static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2);
  86
  87 // filter strings
  88 static wxString FilterInValue(const wxString& str);
  89 static wxString FilterOutValue(const wxString& str);
  90
  91 static wxString FilterInEntryName(const wxString& str);
  92 static wxString FilterOutEntryName(const wxString& str);
  93
  94 // get the name to use in wxFileConfig ctor
  95 static wxString GetAppName(const wxString& appname);
  96
  97 // ============================================================================
  98 // private classes
  99 // ============================================================================
 100
 101 // ----------------------------------------------------------------------------
 102 // "template" array types
 103 // ----------------------------------------------------------------------------
 104
 105 #ifdef WXMAKINGDLL_BASE
 106     WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries,
 107                                          WXDLLIMPEXP_BASE);
 108     WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups,
 109                                          WXDLLIMPEXP_BASE);
 110 #else
 111     WX_DEFINE_SORTED_ARRAY(wxFileConfigEntry *, ArrayEntries);
 112     WX_DEFINE_SORTED_ARRAY(wxFileConfigGroup *, ArrayGroups);
 113 #endif
 114
 115 // ----------------------------------------------------------------------------
 116 // wxFileConfigLineList
 117 // ----------------------------------------------------------------------------
 118
 119 // we store all lines of the local config file as a linked list in memory
 120 class wxFileConfigLineList
 121 {
 122 public:
 123   void SetNext(wxFileConfigLineList *pNext)  { m_pNext = pNext; }
 124   void SetPrev(wxFileConfigLineList *pPrev)  { m_pPrev = pPrev; }
 125
 126   // ctor
 127   wxFileConfigLineList(const wxString& str,
 128                        wxFileConfigLineList *pNext = NULL) : m_strLine(str)
 129     { SetNext(pNext); SetPrev(NULL); }
 130
 131   // next/prev nodes in the linked list
 132   wxFileConfigLineList *Next() const { return m_pNext;  }
 133   wxFileConfigLineList *Prev() const { return m_pPrev;  }
 134
 135   // get/change lines text
 136   void SetText(const wxString& str) { m_strLine = str;  }
 137   const wxString& Text() const { return m_strLine; }
 138
 139 private:
 140   wxString  m_strLine;                  // line contents
 141   wxFileConfigLineList *m_pNext,        // next node
 142                        *m_pPrev;        // previous one
 143
 144     DECLARE_NO_COPY_CLASS(wxFileConfigLineList)
 145 };
 146
 147 // ----------------------------------------------------------------------------
 148 // wxFileConfigEntry: a name/value pair
 149 // ----------------------------------------------------------------------------
 150
 151 class wxFileConfigEntry
 152 {
 153 private:
 154   wxFileConfigGroup *m_pParent; // group that contains us
 155
 156   wxString      m_strName,      // entry name
 157                 m_strValue;     //       value
 158   bool          m_bImmutable:1, // can be overriden locally?
 159                 m_bHasValue:1;  // set after first call to SetValue()
 160
 161   int           m_nLine;        // used if m_pLine == NULL only
 162
 163   // pointer to our line in the linked list or NULL if it was found in global
 164   // file (which we don't modify)
 165   wxFileConfigLineList *m_pLine;
 166
 167 public:
 168   wxFileConfigEntry(wxFileConfigGroup *pParent,
 169                     const wxString& strName, int nLine);
 170
 171   // simple accessors
 172   const wxString& Name()        const { return m_strName;    }
 173   const wxString& Value()       const { return m_strValue;   }
 174   wxFileConfigGroup *Group()    const { return m_pParent;    }
 175   bool            IsImmutable() const { return m_bImmutable; }
 176   bool            IsLocal()     const { return m_pLine != 0; }
 177   int             Line()        const { return m_nLine;      }
 178   wxFileConfigLineList *
 179                   GetLine()     const { return m_pLine;      }
 180
 181   // modify entry attributes
 182   void SetValue(const wxString& strValue, bool bUser = true);
 183   void SetLine(wxFileConfigLineList *pLine);
 184
 185     DECLARE_NO_COPY_CLASS(wxFileConfigEntry)
 186 };
 187
 188 // ----------------------------------------------------------------------------
 189 // wxFileConfigGroup: container of entries and other groups
 190 // ----------------------------------------------------------------------------
 191
 192 class wxFileConfigGroup
 193 {
 194 private:
 195   wxFileConfig *m_pConfig;          // config object we belong to
 196   wxFileConfigGroup  *m_pParent;    // parent group (NULL for root group)
 197   ArrayEntries  m_aEntries;         // entries in this group
 198   ArrayGroups   m_aSubgroups;       // subgroups
 199   wxString      m_strName;          // group's name
 200   wxFileConfigLineList *m_pLine;    // pointer to our line in the linked list
 201   wxFileConfigEntry *m_pLastEntry;  // last entry/subgroup of this group in the
 202   wxFileConfigGroup *m_pLastGroup;  // local file (we insert new ones after it)
 203
 204   // DeleteSubgroupByName helper
 205   bool DeleteSubgroup(wxFileConfigGroup *pGroup);
 206
 207   // used by Rename()
 208   void UpdateGroupAndSubgroupsLines();
 209
 210 public:
 211   // ctor
 212   wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *);
 213
 214   // dtor deletes all entries and subgroups also
 215   ~wxFileConfigGroup();
 216
 217   // simple accessors
 218   const wxString& Name()    const { return m_strName; }
 219   wxFileConfigGroup    *Parent()  const { return m_pParent; }
 220   wxFileConfig   *Config()  const { return m_pConfig; }
 221
 222   const ArrayEntries& Entries() const { return m_aEntries;   }
 223   const ArrayGroups&  Groups()  const { return m_aSubgroups; }
 224   bool  IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
 225
 226   // find entry/subgroup (NULL if not found)
 227   wxFileConfigGroup *FindSubgroup(const wxString& name) const;
 228   wxFileConfigEntry *FindEntry   (const wxString& name) const;
 229
 230   // delete entry/subgroup, return false if doesn't exist
 231   bool DeleteSubgroupByName(const wxString& name);
 232   bool DeleteEntry(const wxString& name);
 233
 234   // create new entry/subgroup returning pointer to newly created element
 235   wxFileConfigGroup *AddSubgroup(const wxString& strName);
 236   wxFileConfigEntry *AddEntry   (const wxString& strName, int nLine = wxNOT_FOUND);
 237
 238   void SetLine(wxFileConfigLineList *pLine);
 239
 240   // rename: no checks are done to ensure that the name is unique!
 241   void Rename(const wxString& newName);
 242
 243   //
 244   wxString GetFullName() const;
 245
 246   // get the last line belonging to an entry/subgroup of this group
 247   wxFileConfigLineList *GetGroupLine();     // line which contains [group]
 248                                             // may be NULL for "/" only
 249   wxFileConfigLineList *GetLastEntryLine(); // after which our subgroups start
 250   wxFileConfigLineList *GetLastGroupLine(); // after which the next group starts
 251
 252   // called by entries/subgroups when they're created/deleted
 253   void SetLastEntry(wxFileConfigEntry *pEntry);
 254   void SetLastGroup(wxFileConfigGroup *pGroup)
 255     { m_pLastGroup = pGroup; }
 256
 257   DECLARE_NO_COPY_CLASS(wxFileConfigGroup)
 258 };
 259
 260 // ============================================================================
 261 // implementation
 262 // ============================================================================
 263
 264 // ----------------------------------------------------------------------------
 265 // static functions
 266 // ----------------------------------------------------------------------------
 267
 268 // this function modifies in place the given wxFileName object if it doesn't
 269 // already have an extension
 270 //
 271 // note that it's slightly misnamed under Mac as there it doesn't add an
 272 // extension but modifies the file name instead, so you shouldn't suppose that
 273 // fn.HasExt() is true after it returns
 274 static void AddConfFileExtIfNeeded(wxFileName& fn)
 275 {
 276     if ( !fn.HasExt() )
 277     {
 278 #if defined( __WXMAC__ )
 279         fn.SetName(fn.GetName() + wxT(" Preferences"));
 280 #elif defined( __UNIX__ )
 281         fn.SetExt(wxT(".conf"));
 282 #else   // Windows
 283         fn.SetExt(wxT(".ini"));
 284 #endif  // UNIX/Win
 285     }
 286 }
 287
 288 wxString wxFileConfig::GetGlobalDir()
 289 {
 290     return wxStandardPaths::Get().GetConfigDir();
 291 }
 292
 293 wxString wxFileConfig::GetLocalDir(int style)
 294 {
 295     wxUnusedVar(style);
 296
 297     wxStandardPathsBase& stdp = wxStandardPaths::Get();
 298
 299     // it so happens that user data directory is a subdirectory of user config
 300     // directory on all supported platforms, which explains why we use it here
 301     return style & wxCONFIG_USE_SUBDIR ? stdp.GetUserDataDir()
 302                                        : stdp.GetUserConfigDir();
 303 }
 304
 305 wxFileName wxFileConfig::GetGlobalFile(const wxString& szFile)
 306 {
 307     wxFileName fn(GetGlobalDir(), szFile);
 308
 309     AddConfFileExtIfNeeded(fn);
 310
 311     return fn;
 312 }
 313
 314 wxFileName wxFileConfig::GetLocalFile(const wxString& szFile, int style)
 315 {
 316     wxFileName fn(GetLocalDir(style), szFile);
 317
 318 #ifdef __UNIX__
 319     if ( !(style & wxCONFIG_USE_SUBDIR) )
 320     {
 321         // dot-files under Unix start with, well, a dot (but OTOH they usually
 322         // don't have any specific extension)
 323         fn.SetName(wxT('.') + fn.GetName());
 324     }
 325     else // we do append ".conf" extension to config files in subdirectories
 326 #endif // __UNIX__
 327     {
 328         AddConfFileExtIfNeeded(fn);
 329     }
 330
 331     return fn;
 332 }
 333
 334 // ----------------------------------------------------------------------------
 335 // ctor
 336 // ----------------------------------------------------------------------------
 337 IMPLEMENT_ABSTRACT_CLASS(wxFileConfig, wxConfigBase)
 338
 339 void wxFileConfig::Init()
 340 {
 341     m_pCurrentGroup =
 342     m_pRootGroup    = new wxFileConfigGroup(NULL, wxEmptyString, this);
 343
 344     m_linesHead =
 345     m_linesTail = NULL;
 346
 347     // It's not an error if (one of the) file(s) doesn't exist.
 348
 349     // parse the global file
 350     if ( m_fnGlobalFile.IsOk() && m_fnGlobalFile.FileExists() )
 351     {
 352         wxTextFile fileGlobal(m_fnGlobalFile.GetFullPath());
 353
 354         if ( fileGlobal.Open(*m_conv/*ignored in ANSI build*/) )
 355         {
 356             Parse(fileGlobal, false /* global */);
 357             SetRootPath();
 358         }
 359         else
 360         {
 361             wxLogWarning(_("can't open global configuration file '%s'."), m_fnGlobalFile.GetFullPath().c_str());
 362         }
 363     }
 364
 365     // parse the local file
 366     if ( m_fnLocalFile.IsOk() && m_fnLocalFile.FileExists() )
 367     {
 368         wxTextFile fileLocal(m_fnLocalFile.GetFullPath());
 369         if ( fileLocal.Open(*m_conv/*ignored in ANSI build*/) )
 370         {
 371             Parse(fileLocal, true /* local */);
 372             SetRootPath();
 373         }
 374         else
 375         {
 376             const wxString path = m_fnLocalFile.GetFullPath();
 377             wxLogWarning(_("can't open user configuration file '%s'."),
 378                          path.c_str());
 379
 380             if ( m_fnLocalFile.FileExists() )
 381             {
 382                 wxLogWarning(_("Changes won't be saved to avoid overwriting the existing file \"%s\""),
 383                              path.c_str());
 384                 m_fnLocalFile.Clear();
 385             }
 386         }
 387     }
 388
 389     m_isDirty = false;
 390 }
 391
 392 // constructor supports creation of wxFileConfig objects of any type
 393 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
 394                            const wxString& strLocal, const wxString& strGlobal,
 395                            long style,
 396                            const wxMBConv& conv)
 397             : wxConfigBase(::GetAppName(appName), vendorName,
 398                            strLocal, strGlobal,
 399                            style),
 400               m_fnLocalFile(strLocal),
 401               m_fnGlobalFile(strGlobal),
 402               m_conv(conv.Clone())
 403 {
 404     // Make up names for files if empty
 405     if ( !m_fnLocalFile.IsOk() && (style & wxCONFIG_USE_LOCAL_FILE) )
 406         m_fnLocalFile = GetLocalFile(GetAppName(), style);
 407
 408     if ( !m_fnGlobalFile.IsOk() && (style & wxCONFIG_USE_GLOBAL_FILE) )
 409         m_fnGlobalFile = GetGlobalFile(GetAppName());
 410
 411     // Check if styles are not supplied, but filenames are, in which case
 412     // add the correct styles.
 413     if ( m_fnLocalFile.IsOk() )
 414         SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
 415
 416     if ( m_fnGlobalFile.IsOk() )
 417         SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
 418
 419     // if the path is not absolute, prepend the standard directory to it
 420     // unless explicitly asked not to
 421     if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
 422     {
 423         if ( m_fnLocalFile.IsOk() )
 424             m_fnLocalFile.MakeAbsolute(GetLocalDir(style));
 425
 426         if ( m_fnGlobalFile.IsOk() )
 427             m_fnGlobalFile.MakeAbsolute(GetGlobalDir());
 428     }
 429
 430     SetUmask(-1);
 431
 432     Init();
 433 }
 434
 435 #if wxUSE_STREAMS
 436
 437 wxFileConfig::wxFileConfig(wxInputStream &inStream, const wxMBConv& conv)
 438             : m_conv(conv.Clone())
 439 {
 440     // always local_file when this constructor is called (?)
 441     SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
 442
 443     m_pCurrentGroup =
 444     m_pRootGroup    = new wxFileConfigGroup(NULL, wxEmptyString, this);
 445
 446     m_linesHead =
 447     m_linesTail = NULL;
 448
 449     // read the entire stream contents in memory
 450     wxWxCharBuffer cbuf;
 451     static const size_t chunkLen = 1024;
 452
 453     wxMemoryBuffer buf(chunkLen);
 454     do
 455     {
 456         inStream.Read(buf.GetAppendBuf(chunkLen), chunkLen);
 457         buf.UngetAppendBuf(inStream.LastRead());
 458
 459         const wxStreamError err = inStream.GetLastError();
 460
 461         if ( err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF )
 462         {
 463             wxLogError(_("Error reading config options."));
 464             break;
 465         }
 466     }
 467     while ( !inStream.Eof() );
 468
 469 #if wxUSE_UNICODE
 470     size_t len;
 471     cbuf = conv.cMB2WC((char *)buf.GetData(), buf.GetDataLen() + 1, &len);
 472     if ( !len && buf.GetDataLen() )
 473     {
 474         wxLogError(_("Failed to read config options."));
 475     }
 476 #else // !wxUSE_UNICODE
 477     // no need for conversion
 478     cbuf = wxCharBuffer::CreateNonOwned((char *)buf.GetData());
 479 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 480
 481
 482     // now break it into lines
 483     wxMemoryText memText;
 484     for ( const wxChar *s = cbuf; ; ++s )
 485     {
 486         const wxChar *e = s;
 487         while ( *e != '\0' && *e != '\n' && *e != '\r' )
 488             ++e;
 489
 490         // notice that we throw away the original EOL kind here, maybe we
 491         // should preserve it?
 492         if ( e != s )
 493             memText.AddLine(wxString(s, e));
 494
 495         if ( *e == '\0' )
 496             break;
 497
 498         // skip the second EOL byte if it's a DOS one
 499         if ( *e == '\r' && e[1] == '\n' )
 500             ++e;
 501
 502         s = e;
 503     }
 504
 505     // Finally we can parse it all.
 506     Parse(memText, true /* local */);
 507
 508     SetRootPath();
 509     ResetDirty();
 510 }
 511
 512 #endif // wxUSE_STREAMS
 513
 514 void wxFileConfig::CleanUp()
 515 {
 516     delete m_pRootGroup;
 517
 518     wxFileConfigLineList *pCur = m_linesHead;
 519     while ( pCur != NULL ) {
 520         wxFileConfigLineList *pNext = pCur->Next();
 521         delete pCur;
 522         pCur = pNext;
 523     }
 524 }
 525
 526 wxFileConfig::~wxFileConfig()
 527 {
 528     Flush();
 529
 530     CleanUp();
 531
 532     delete m_conv;
 533 }
 534
 535 // ----------------------------------------------------------------------------
 536 // parse a config file
 537 // ----------------------------------------------------------------------------
 538
 539 void wxFileConfig::Parse(const wxTextBuffer& buffer, bool bLocal)
 540 {
 541
 542   size_t nLineCount = buffer.GetLineCount();
 543
 544   for ( size_t n = 0; n < nLineCount; n++ )
 545   {
 546     wxString strLine = buffer[n];
 547     // FIXME-UTF8: rewrite using iterators, without this buffer
 548     wxWxCharBuffer buf(strLine.c_str());
 549     const wxChar *pStart;
 550     const wxChar *pEnd;
 551
 552     // add the line to linked list
 553     if ( bLocal )
 554       LineListAppend(strLine);
 555
 556
 557     // skip leading spaces
 558     for ( pStart = buf; wxIsspace(*pStart); pStart++ )
 559       ;
 560
 561     // skip blank/comment lines
 562     if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
 563       continue;
 564
 565     if ( *pStart == wxT('[') ) {          // a new group
 566       pEnd = pStart;
 567
 568       while ( *++pEnd != wxT(']') ) {
 569         if ( *pEnd == wxT('\\') ) {
 570             // the next char is escaped, so skip it even if it is ']'
 571             pEnd++;
 572         }
 573
 574         if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
 575             // we reached the end of line, break out of the loop
 576             break;
 577         }
 578       }
 579
 580       if ( *pEnd != wxT(']') ) {
 581         wxLogError(_("file '%s': unexpected character %c at line %d."),
 582                    buffer.GetName(), *pEnd, n + 1);
 583         continue; // skip this line
 584       }
 585
 586       // group name here is always considered as abs path
 587       wxString strGroup;
 588       pStart++;
 589       strGroup << wxCONFIG_PATH_SEPARATOR
 590                << FilterInEntryName(wxString(pStart, pEnd - pStart));
 591
 592       // will create it if doesn't yet exist
 593       SetPath(strGroup);
 594
 595       if ( bLocal )
 596       {
 597         if ( m_pCurrentGroup->Parent() )
 598           m_pCurrentGroup->Parent()->SetLastGroup(m_pCurrentGroup);
 599         m_pCurrentGroup->SetLine(m_linesTail);
 600       }
 601
 602       // check that there is nothing except comments left on this line
 603       bool bCont = true;
 604       while ( *++pEnd != wxT('\0') && bCont ) {
 605         switch ( *pEnd ) {
 606           case wxT('#'):
 607           case wxT(';'):
 608             bCont = false;
 609             break;
 610
 611           case wxT(' '):
 612           case wxT('\t'):
 613             // ignore whitespace ('\n' impossible here)
 614             break;
 615
 616           default:
 617             wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
 618                          buffer.GetName(), n + 1, pEnd);
 619             bCont = false;
 620         }
 621       }
 622     }
 623     else {                        // a key
 624       pEnd = pStart;
 625       while ( *pEnd && *pEnd != wxT('=') /* && !wxIsspace(*pEnd)*/ ) {
 626         if ( *pEnd == wxT('\\') ) {
 627           // next character may be space or not - still take it because it's
 628           // quoted (unless there is nothing)
 629           pEnd++;
 630           if ( !*pEnd ) {
 631             // the error message will be given below anyhow
 632             break;
 633           }
 634         }
 635
 636         pEnd++;
 637       }
 638
 639       wxString strKey(FilterInEntryName(wxString(pStart, pEnd).Trim()));
 640
 641       // skip whitespace
 642       while ( wxIsspace(*pEnd) )
 643         pEnd++;
 644
 645       if ( *pEnd++ != wxT('=') ) {
 646         wxLogError(_("file '%s', line %d: '=' expected."),
 647                    buffer.GetName(), n + 1);
 648       }
 649       else {
 650         wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
 651
 652         if ( pEntry == NULL ) {
 653           // new entry
 654           pEntry = m_pCurrentGroup->AddEntry(strKey, n);
 655         }
 656         else {
 657           if ( bLocal && pEntry->IsImmutable() ) {
 658             // immutable keys can't be changed by user
 659             wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
 660                          buffer.GetName(), n + 1, strKey.c_str());
 661             continue;
 662           }
 663           // the condition below catches the cases (a) and (b) but not (c):
 664           //  (a) global key found second time in global file
 665           //  (b) key found second (or more) time in local file
 666           //  (c) key from global file now found in local one
 667           // which is exactly what we want.
 668           else if ( !bLocal || pEntry->IsLocal() ) {
 669             wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
 670                          buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
 671
 672           }
 673         }
 674
 675         if ( bLocal )
 676           pEntry->SetLine(m_linesTail);
 677
 678         // skip whitespace
 679         while ( wxIsspace(*pEnd) )
 680           pEnd++;
 681
 682         wxString value = pEnd;
 683         if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
 684             value = FilterInValue(value);
 685
 686         pEntry->SetValue(value, false);
 687       }
 688     }
 689   }
 690 }
 691
 692 // ----------------------------------------------------------------------------
 693 // set/retrieve path
 694 // ----------------------------------------------------------------------------
 695
 696 void wxFileConfig::SetRootPath()
 697 {
 698     m_strPath.Empty();
 699     m_pCurrentGroup = m_pRootGroup;
 700 }
 701
 702 bool
 703 wxFileConfig::DoSetPath(const wxString& strPath, bool createMissingComponents)
 704 {
 705     wxArrayString aParts;
 706
 707     if ( strPath.empty() ) {
 708         SetRootPath();
 709         return true;
 710     }
 711
 712     if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
 713         // absolute path
 714         wxSplitPath(aParts, strPath);
 715     }
 716     else {
 717         // relative path, combine with current one
 718         wxString strFullPath = m_strPath;
 719         strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
 720         wxSplitPath(aParts, strFullPath);
 721     }
 722
 723     // change current group
 724     size_t n;
 725     m_pCurrentGroup = m_pRootGroup;
 726     for ( n = 0; n < aParts.GetCount(); n++ ) {
 727         wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
 728         if ( pNextGroup == NULL )
 729         {
 730             if ( !createMissingComponents )
 731                 return false;
 732
 733             pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
 734         }
 735
 736         m_pCurrentGroup = pNextGroup;
 737     }
 738
 739     // recombine path parts in one variable
 740     m_strPath.Empty();
 741     for ( n = 0; n < aParts.GetCount(); n++ ) {
 742         m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
 743     }
 744
 745     return true;
 746 }
 747
 748 void wxFileConfig::SetPath(const wxString& strPath)
 749 {
 750     DoSetPath(strPath, true /* create missing path components */);
 751 }
 752
 753 // ----------------------------------------------------------------------------
 754 // enumeration
 755 // ----------------------------------------------------------------------------
 756
 757 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
 758 {
 759     lIndex = 0;
 760     return GetNextGroup(str, lIndex);
 761 }
 762
 763 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
 764 {
 765     if ( size_t(lIndex) < m_pCurrentGroup->Groups().GetCount() ) {
 766         str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
 767         return true;
 768     }
 769     else
 770         return false;
 771 }
 772
 773 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
 774 {
 775     lIndex = 0;
 776     return GetNextEntry(str, lIndex);
 777 }
 778
 779 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
 780 {
 781     if ( size_t(lIndex) < m_pCurrentGroup->Entries().GetCount() ) {
 782         str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
 783         return true;
 784     }
 785     else
 786         return false;
 787 }
 788
 789 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
 790 {
 791     size_t n = m_pCurrentGroup->Entries().GetCount();
 792     if ( bRecursive ) {
 793         wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 794         size_t nSubgroups = m_pCurrentGroup->Groups().GetCount();
 795         for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 796             CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 797             n += GetNumberOfEntries(true);
 798             CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
 799         }
 800     }
 801
 802     return n;
 803 }
 804
 805 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
 806 {
 807     size_t n = m_pCurrentGroup->Groups().GetCount();
 808     if ( bRecursive ) {
 809         wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 810         size_t nSubgroups = m_pCurrentGroup->Groups().GetCount();
 811         for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 812             CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 813             n += GetNumberOfGroups(true);
 814             CONST_CAST 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 = wx_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 = wx_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, _T("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                 _T("  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                     _T("  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                         _T("  Adding Entry %s"),
 974                         strName.c_str() );
 975             pEntry = m_pCurrentGroup->AddEntry(strName);
 976         }
 977
 978         wxLogTrace( FILECONF_TRACE_MASK,
 979                     _T("  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(_T("%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(__WXMAC__)
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                    _T("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                 _T("    ** Adding Line '%s'"),
1195                 str.c_str() );
1196     wxLogTrace( FILECONF_TRACE_MASK,
1197                 _T("        head: %s"),
1198                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1199                                : wxEmptyString) );
1200     wxLogTrace( FILECONF_TRACE_MASK,
1201                 _T("        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                 _T("        head: %s"),
1223                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1224                                : wxEmptyString) );
1225     wxLogTrace( FILECONF_TRACE_MASK,
1226                 _T("        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                 _T("    ** 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                 _T("        head: %s"),
1244                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1245                                : wxEmptyString) );
1246     wxLogTrace( FILECONF_TRACE_MASK,
1247                 _T("        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                 _T("        head: %s"),
1274                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1275                                : wxEmptyString) );
1276     wxLogTrace( FILECONF_TRACE_MASK,
1277                 _T("        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                 _T("    ** Removing Line '%s'"),
1288                 pLine->Text().c_str() );
1289     wxLogTrace( FILECONF_TRACE_MASK,
1290                 _T("        head: %s"),
1291                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1292                                : wxEmptyString) );
1293     wxLogTrace( FILECONF_TRACE_MASK,
1294                 _T("        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     if ( m_pRootGroup->GetGroupLine() == pLine )
1316         m_pRootGroup->SetLine(m_linesHead);
1317
1318     wxLogTrace( FILECONF_TRACE_MASK,
1319                 _T("        head: %s"),
1320                 ((m_linesHead) ? (const wxChar*)m_linesHead->Text().c_str()
1321                                : wxEmptyString) );
1322     wxLogTrace( FILECONF_TRACE_MASK,
1323                 _T("        tail: %s"),
1324                 ((m_linesTail) ? (const wxChar*)m_linesTail->Text().c_str()
1325                                : wxEmptyString) );
1326
1327     delete pLine;
1328 }
1329
1330 bool wxFileConfig::LineListIsEmpty()
1331 {
1332     return m_linesHead == NULL;
1333 }
1334
1335 // ============================================================================
1336 // wxFileConfig::wxFileConfigGroup
1337 // ============================================================================
1338
1339 // ----------------------------------------------------------------------------
1340 // ctor/dtor
1341 // ----------------------------------------------------------------------------
1342
1343 // ctor
1344 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1345                                        const wxString& strName,
1346                                        wxFileConfig *pConfig)
1347                          : m_aEntries(CompareEntries),
1348                            m_aSubgroups(CompareGroups),
1349                            m_strName(strName)
1350 {
1351   m_pConfig = pConfig;
1352   m_pParent = pParent;
1353   m_pLine   = NULL;
1354
1355   m_pLastEntry = NULL;
1356   m_pLastGroup = NULL;
1357 }
1358
1359 // dtor deletes all children
1360 wxFileConfigGroup::~wxFileConfigGroup()
1361 {
1362   // entries
1363   size_t n, nCount = m_aEntries.GetCount();
1364   for ( n = 0; n < nCount; n++ )
1365     delete m_aEntries[n];
1366
1367   // subgroups
1368   nCount = m_aSubgroups.GetCount();
1369   for ( n = 0; n < nCount; n++ )
1370     delete m_aSubgroups[n];
1371 }
1372
1373 // ----------------------------------------------------------------------------
1374 // line
1375 // ----------------------------------------------------------------------------
1376
1377 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1378 {
1379     // for a normal (i.e. not root) group this method shouldn't be called twice
1380     // unless we are resetting the line
1381     wxASSERT_MSG( !m_pParent || !m_pLine || !pLine,
1382                    _T("changing line for a non-root group?") );
1383
1384     m_pLine = pLine;
1385 }
1386
1387 /*
1388   This is a bit complicated, so let me explain it in details. All lines that
1389   were read from the local file (the only one we will ever modify) are stored
1390   in a (doubly) linked list. Our problem is to know at which position in this
1391   list should we insert the new entries/subgroups. To solve it we keep three
1392   variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1393
1394   m_pLine points to the line containing "[group_name]"
1395   m_pLastEntry points to the last entry of this group in the local file.
1396   m_pLastGroup                   subgroup
1397
1398   Initially, they're NULL all three. When the group (an entry/subgroup) is read
1399   from the local file, the corresponding variable is set. However, if the group
1400   was read from the global file and then modified or created by the application
1401   these variables are still NULL and we need to create the corresponding lines.
1402   See the following functions (and comments preceding them) for the details of
1403   how we do it.
1404
1405   Also, when our last entry/group are deleted we need to find the new last
1406   element - the code in DeleteEntry/Subgroup does this by backtracking the list
1407   of lines until it either founds an entry/subgroup (and this is the new last
1408   element) or the m_pLine of the group, in which case there are no more entries
1409   (or subgroups) left and m_pLast<element> becomes NULL.
1410
1411   NB: This last problem could be avoided for entries if we added new entries
1412       immediately after m_pLine, but in this case the entries would appear
1413       backwards in the config file (OTOH, it's not that important) and as we
1414       would still need to do it for the subgroups the code wouldn't have been
1415       significantly less complicated.
1416 */
1417
1418 // Return the line which contains "[our name]". If we're still not in the list,
1419 // add our line to it immediately after the last line of our parent group if we
1420 // have it or in the very beginning if we're the root group.
1421 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1422 {
1423     wxLogTrace( FILECONF_TRACE_MASK,
1424                 _T("  GetGroupLine() for Group '%s'"),
1425                 Name().c_str() );
1426
1427     if ( !m_pLine )
1428     {
1429         wxLogTrace( FILECONF_TRACE_MASK,
1430                     _T("    Getting Line item pointer") );
1431
1432         wxFileConfigGroup   *pParent = Parent();
1433
1434         // this group wasn't present in local config file, add it now
1435         if ( pParent )
1436         {
1437             wxLogTrace( FILECONF_TRACE_MASK,
1438                         _T("    checking parent '%s'"),
1439                         pParent->Name().c_str() );
1440
1441             wxString    strFullName;
1442
1443             // add 1 to the name because we don't want to start with '/'
1444             strFullName << wxT("[")
1445                         << FilterOutEntryName(GetFullName().c_str() + 1)
1446                         << wxT("]");
1447             m_pLine = m_pConfig->LineListInsert(strFullName,
1448                                                 pParent->GetLastGroupLine());
1449             pParent->SetLastGroup(this);  // we're surely after all the others
1450         }
1451         //else: this is the root group and so we return NULL because we don't
1452         //      have any group line
1453     }
1454
1455     return m_pLine;
1456 }
1457
1458 // Return the last line belonging to the subgroups of this group (after which
1459 // we can add a new subgroup), if we don't have any subgroups or entries our
1460 // last line is the group line (m_pLine) itself.
1461 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1462 {
1463     // if we have any subgroups, our last line is the last line of the last
1464     // subgroup
1465     if ( m_pLastGroup )
1466     {
1467         wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1468
1469         wxASSERT_MSG( pLine, _T("last group must have !NULL associated line") );
1470
1471         return pLine;
1472     }
1473
1474     // no subgroups, so the last line is the line of thelast entry (if any)
1475     return GetLastEntryLine();
1476 }
1477
1478 // return the last line belonging to the entries of this group (after which
1479 // we can add a new entry), if we don't have any entries we will add the new
1480 // one immediately after the group line itself.
1481 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1482 {
1483     wxLogTrace( FILECONF_TRACE_MASK,
1484                 _T("  GetLastEntryLine() for Group '%s'"),
1485                 Name().c_str() );
1486
1487     if ( m_pLastEntry )
1488     {
1489         wxFileConfigLineList    *pLine = m_pLastEntry->GetLine();
1490
1491         wxASSERT_MSG( pLine, _T("last entry must have !NULL associated line") );
1492
1493         return pLine;
1494     }
1495
1496     // no entries: insert after the group header, if any
1497     return GetGroupLine();
1498 }
1499
1500 void wxFileConfigGroup::SetLastEntry(wxFileConfigEntry *pEntry)
1501 {
1502     m_pLastEntry = pEntry;
1503
1504     if ( !m_pLine )
1505     {
1506         // the only situation in which a group without its own line can have
1507         // an entry is when the first entry is added to the initially empty
1508         // root pseudo-group
1509         wxASSERT_MSG( !m_pParent, _T("unexpected for non root group") );
1510
1511         // let the group know that it does have a line in the file now
1512         m_pLine = pEntry->GetLine();
1513     }
1514 }
1515
1516 // ----------------------------------------------------------------------------
1517 // group name
1518 // ----------------------------------------------------------------------------
1519
1520 void wxFileConfigGroup::UpdateGroupAndSubgroupsLines()
1521 {
1522     // update the line of this group
1523     wxFileConfigLineList *line = GetGroupLine();
1524     wxCHECK_RET( line, _T("a non root group must have a corresponding line!") );
1525
1526     // +1: skip the leading '/'
1527     line->SetText(wxString::Format(_T("[%s]"), GetFullName().c_str() + 1));
1528
1529
1530     // also update all subgroups as they have this groups name in their lines
1531     const size_t nCount = m_aSubgroups.GetCount();
1532     for ( size_t n = 0; n < nCount; n++ )
1533     {
1534         m_aSubgroups[n]->UpdateGroupAndSubgroupsLines();
1535     }
1536 }
1537
1538 void wxFileConfigGroup::Rename(const wxString& newName)
1539 {
1540     wxCHECK_RET( m_pParent, _T("the root group can't be renamed") );
1541
1542     if ( newName == m_strName )
1543         return;
1544
1545     // we need to remove the group from the parent and it back under the new
1546     // name to keep the parents array of subgroups alphabetically sorted
1547     m_pParent->m_aSubgroups.Remove(this);
1548
1549     m_strName = newName;
1550
1551     m_pParent->m_aSubgroups.Add(this);
1552
1553     // update the group lines recursively
1554     UpdateGroupAndSubgroupsLines();
1555 }
1556
1557 wxString wxFileConfigGroup::GetFullName() const
1558 {
1559     wxString fullname;
1560     if ( Parent() )
1561         fullname = Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1562
1563     return fullname;
1564 }
1565
1566 // ----------------------------------------------------------------------------
1567 // find an item
1568 // ----------------------------------------------------------------------------
1569
1570 // use binary search because the array is sorted
1571 wxFileConfigEntry *
1572 wxFileConfigGroup::FindEntry(const wxString& name) const
1573 {
1574   size_t i,
1575        lo = 0,
1576        hi = m_aEntries.GetCount();
1577   int res;
1578   wxFileConfigEntry *pEntry;
1579
1580   while ( lo < hi ) {
1581     i = (lo + hi)/2;
1582     pEntry = m_aEntries[i];
1583
1584     #if wxCONFIG_CASE_SENSITIVE
1585       res = pEntry->Name().compare(name);
1586     #else
1587       res = pEntry->Name().CmpNoCase(name);
1588     #endif
1589
1590     if ( res > 0 )
1591       hi = i;
1592     else if ( res < 0 )
1593       lo = i + 1;
1594     else
1595       return pEntry;
1596   }
1597
1598   return NULL;
1599 }
1600
1601 wxFileConfigGroup *
1602 wxFileConfigGroup::FindSubgroup(const wxString& name) const
1603 {
1604   size_t i,
1605        lo = 0,
1606        hi = m_aSubgroups.GetCount();
1607   int res;
1608   wxFileConfigGroup *pGroup;
1609
1610   while ( lo < hi ) {
1611     i = (lo + hi)/2;
1612     pGroup = m_aSubgroups[i];
1613
1614     #if wxCONFIG_CASE_SENSITIVE
1615       res = pGroup->Name().compare(name);
1616     #else
1617       res = pGroup->Name().CmpNoCase(name);
1618     #endif
1619
1620     if ( res > 0 )
1621       hi = i;
1622     else if ( res < 0 )
1623       lo = i + 1;
1624     else
1625       return pGroup;
1626   }
1627
1628   return NULL;
1629 }
1630
1631 // ----------------------------------------------------------------------------
1632 // create a new item
1633 // ----------------------------------------------------------------------------
1634
1635 // create a new entry and add it to the current group
1636 wxFileConfigEntry *wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1637 {
1638     wxASSERT( FindEntry(strName) == 0 );
1639
1640     wxFileConfigEntry   *pEntry = new wxFileConfigEntry(this, strName, nLine);
1641
1642     m_aEntries.Add(pEntry);
1643     return pEntry;
1644 }
1645
1646 // create a new group and add it to the current group
1647 wxFileConfigGroup *wxFileConfigGroup::AddSubgroup(const wxString& strName)
1648 {
1649     wxASSERT( FindSubgroup(strName) == 0 );
1650
1651     wxFileConfigGroup   *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1652
1653     m_aSubgroups.Add(pGroup);
1654     return pGroup;
1655 }
1656
1657 // ----------------------------------------------------------------------------
1658 // delete an item
1659 // ----------------------------------------------------------------------------
1660
1661 /*
1662   The delete operations are _very_ slow if we delete the last item of this
1663   group (see comments before GetXXXLineXXX functions for more details),
1664   so it's much better to start with the first entry/group if we want to
1665   delete several of them.
1666  */
1667
1668 bool wxFileConfigGroup::DeleteSubgroupByName(const wxString& name)
1669 {
1670     wxFileConfigGroup * const pGroup = FindSubgroup(name);
1671
1672     return pGroup ? DeleteSubgroup(pGroup) : false;
1673 }
1674
1675 // Delete the subgroup and remove all references to it from
1676 // other data structures.
1677 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1678 {
1679     wxCHECK_MSG( pGroup, false, _T("deleting non existing group?") );
1680
1681     wxLogTrace( FILECONF_TRACE_MASK,
1682                 _T("Deleting group '%s' from '%s'"),
1683                 pGroup->Name().c_str(),
1684                 Name().c_str() );
1685
1686     wxLogTrace( FILECONF_TRACE_MASK,
1687                 _T("  (m_pLine) = prev: %p, this %p, next %p"),
1688                 m_pLine ? wx_static_cast(void*, m_pLine->Prev()) : 0,
1689                 wx_static_cast(void*, m_pLine),
1690                 m_pLine ? wx_static_cast(void*, m_pLine->Next()) : 0 );
1691     wxLogTrace( FILECONF_TRACE_MASK,
1692                 _T("  text: '%s'"),
1693                 m_pLine ? (const wxChar*)m_pLine->Text().c_str()
1694                         : wxEmptyString );
1695
1696     // delete all entries...
1697     size_t nCount = pGroup->m_aEntries.GetCount();
1698
1699     wxLogTrace(FILECONF_TRACE_MASK,
1700                _T("Removing %lu entries"), (unsigned long)nCount );
1701
1702     for ( size_t nEntry = 0; nEntry < nCount; nEntry++ )
1703     {
1704         wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1705
1706         if ( pLine )
1707         {
1708             wxLogTrace( FILECONF_TRACE_MASK,
1709                         _T("    '%s'"),
1710                         pLine->Text().c_str() );
1711             m_pConfig->LineListRemove(pLine);
1712         }
1713     }
1714
1715     // ...and subgroups of this subgroup
1716     nCount = pGroup->m_aSubgroups.GetCount();
1717
1718     wxLogTrace( FILECONF_TRACE_MASK,
1719                 _T("Removing %lu subgroups"), (unsigned long)nCount );
1720
1721     for ( size_t nGroup = 0; nGroup < nCount; nGroup++ )
1722     {
1723         pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1724     }
1725
1726     // and then finally the group itself
1727     wxFileConfigLineList *pLine = pGroup->m_pLine;
1728     if ( pLine )
1729     {
1730         wxLogTrace( FILECONF_TRACE_MASK,
1731                     _T("  Removing line for group '%s' : '%s'"),
1732                     pGroup->Name().c_str(),
1733                     pLine->Text().c_str() );
1734         wxLogTrace( FILECONF_TRACE_MASK,
1735                     _T("  Removing from group '%s' : '%s'"),
1736                     Name().c_str(),
1737                     ((m_pLine) ? (const wxChar*)m_pLine->Text().c_str()
1738                                : wxEmptyString) );
1739
1740         // notice that we may do this test inside the previous "if"
1741         // because the last entry's line is surely !NULL
1742         if ( pGroup == m_pLastGroup )
1743         {
1744             wxLogTrace( FILECONF_TRACE_MASK,
1745                         _T("  Removing last group") );
1746
1747             // our last entry is being deleted, so find the last one which
1748             // stays by going back until we find a subgroup or reach the
1749             // group line
1750             const size_t nSubgroups = m_aSubgroups.GetCount();
1751
1752             m_pLastGroup = NULL;
1753             for ( wxFileConfigLineList *pl = pLine->Prev();
1754                   pl && !m_pLastGroup;
1755                   pl = pl->Prev() )
1756             {
1757                 // does this line belong to our subgroup?
1758                 for ( size_t n = 0; n < nSubgroups; n++ )
1759                 {
1760                     // do _not_ call GetGroupLine! we don't want to add it to
1761                     // the local file if it's not already there
1762                     if ( m_aSubgroups[n]->m_pLine == pl )
1763                     {
1764                         m_pLastGroup = m_aSubgroups[n];
1765                         break;
1766                     }
1767                 }
1768
1769                 if ( pl == m_pLine )
1770                     break;
1771             }
1772         }
1773
1774         m_pConfig->LineListRemove(pLine);
1775     }
1776     else
1777     {
1778         wxLogTrace( FILECONF_TRACE_MASK,
1779                     _T("  No line entry for Group '%s'?"),
1780                     pGroup->Name().c_str() );
1781     }
1782
1783     m_aSubgroups.Remove(pGroup);
1784     delete pGroup;
1785
1786     return true;
1787 }
1788
1789 bool wxFileConfigGroup::DeleteEntry(const wxString& name)
1790 {
1791   wxFileConfigEntry *pEntry = FindEntry(name);
1792   if ( !pEntry )
1793   {
1794       // entry doesn't exist, nothing to do
1795       return false;
1796   }
1797
1798   wxFileConfigLineList *pLine = pEntry->GetLine();
1799   if ( pLine != NULL ) {
1800     // notice that we may do this test inside the previous "if" because the
1801     // last entry's line is surely !NULL
1802     if ( pEntry == m_pLastEntry ) {
1803       // our last entry is being deleted - find the last one which stays
1804       wxASSERT( m_pLine != NULL );  // if we have an entry with !NULL pLine...
1805
1806       // find the previous entry (if any)
1807       wxFileConfigEntry *pNewLast = NULL;
1808       const wxFileConfigLineList * const
1809         pNewLastLine = m_pLastEntry->GetLine()->Prev();
1810       const size_t nEntries = m_aEntries.GetCount();
1811       for ( size_t n = 0; n < nEntries; n++ ) {
1812         if ( m_aEntries[n]->GetLine() == pNewLastLine ) {
1813           pNewLast = m_aEntries[n];
1814           break;
1815         }
1816       }
1817
1818       // pNewLast can be NULL here -- it's ok and can happen if we have no
1819       // entries left
1820       m_pLastEntry = pNewLast;
1821     }
1822
1823     m_pConfig->LineListRemove(pLine);
1824   }
1825
1826   m_aEntries.Remove(pEntry);
1827   delete pEntry;
1828
1829   return true;
1830 }
1831
1832 // ============================================================================
1833 // wxFileConfig::wxFileConfigEntry
1834 // ============================================================================
1835
1836 // ----------------------------------------------------------------------------
1837 // ctor
1838 // ----------------------------------------------------------------------------
1839 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1840                                        const wxString& strName,
1841                                        int nLine)
1842                          : m_strName(strName)
1843 {
1844   wxASSERT( !strName.empty() );
1845
1846   m_pParent = pParent;
1847   m_nLine   = nLine;
1848   m_pLine   = NULL;
1849
1850   m_bHasValue = false;
1851
1852   m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1853   if ( m_bImmutable )
1854     m_strName.erase(0, 1);  // remove first character
1855 }
1856
1857 // ----------------------------------------------------------------------------
1858 // set value
1859 // ----------------------------------------------------------------------------
1860
1861 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1862 {
1863   if ( m_pLine != NULL ) {
1864     wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1865                  Name().c_str(), m_pParent->GetFullName().c_str());
1866   }
1867
1868   m_pLine = pLine;
1869   Group()->SetLastEntry(this);
1870 }
1871
1872 // second parameter is false if we read the value from file and prevents the
1873 // entry from being marked as 'dirty'
1874 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1875 {
1876     if ( bUser && IsImmutable() )
1877     {
1878         wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1879                       Name().c_str());
1880         return;
1881     }
1882
1883     // do nothing if it's the same value: but don't test for it if m_bHasValue
1884     // hadn't been set yet or we'd never write empty values to the file
1885     if ( m_bHasValue && strValue == m_strValue )
1886         return;
1887
1888     m_bHasValue = true;
1889     m_strValue = strValue;
1890
1891     if ( bUser )
1892     {
1893         wxString strValFiltered;
1894
1895         if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS )
1896         {
1897             strValFiltered = strValue;
1898         }
1899         else {
1900             strValFiltered = FilterOutValue(strValue);
1901         }
1902
1903         wxString    strLine;
1904         strLine << FilterOutEntryName(m_strName) << wxT('=') << strValFiltered;
1905
1906         if ( m_pLine )
1907         {
1908             // entry was read from the local config file, just modify the line
1909             m_pLine->SetText(strLine);
1910         }
1911         else // this entry didn't exist in the local file
1912         {
1913             // add a new line to the file: note that line returned by
1914             // GetLastEntryLine() may be NULL if we're in the root group and it
1915             // doesn't have any entries yet, but this is ok as passing NULL
1916             // line to LineListInsert() means to prepend new line to the list
1917             wxFileConfigLineList *line = Group()->GetLastEntryLine();
1918             m_pLine = Group()->Config()->LineListInsert(strLine, line);
1919
1920             Group()->SetLastEntry(this);
1921         }
1922     }
1923 }
1924
1925 // ============================================================================
1926 // global functions
1927 // ============================================================================
1928
1929 // ----------------------------------------------------------------------------
1930 // compare functions for array sorting
1931 // ----------------------------------------------------------------------------
1932
1933 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1934 {
1935 #if wxCONFIG_CASE_SENSITIVE
1936     return p1->Name().compare(p2->Name());
1937 #else
1938     return p1->Name().CmpNoCase(p2->Name());
1939 #endif
1940 }
1941
1942 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1943 {
1944 #if wxCONFIG_CASE_SENSITIVE
1945     return p1->Name().compare(p2->Name());
1946 #else
1947     return p1->Name().CmpNoCase(p2->Name());
1948 #endif
1949 }
1950
1951 // ----------------------------------------------------------------------------
1952 // filter functions
1953 // ----------------------------------------------------------------------------
1954
1955 // undo FilterOutValue
1956 static wxString FilterInValue(const wxString& str)
1957 {
1958     wxString strResult;
1959     if ( str.empty() )
1960         return strResult;
1961
1962     strResult.reserve(str.length());
1963
1964     wxString::const_iterator i = str.begin();
1965     const bool bQuoted = *i == '"';
1966     if ( bQuoted )
1967         ++i;
1968
1969     for ( const wxString::const_iterator end = str.end(); i != end; ++i )
1970     {
1971         if ( *i == wxT('\\') )
1972         {
1973             if ( ++i == end )
1974             {
1975                 wxLogWarning(_("trailing backslash ignored in '%s'"), str.c_str());
1976                 break;
1977             }
1978
1979             switch ( (*i).GetValue() )
1980             {
1981                 case wxT('n'):
1982                     strResult += wxT('\n');
1983                     break;
1984
1985                 case wxT('r'):
1986                     strResult += wxT('\r');
1987                     break;
1988
1989                 case wxT('t'):
1990                     strResult += wxT('\t');
1991                     break;
1992
1993                 case wxT('\\'):
1994                     strResult += wxT('\\');
1995                     break;
1996
1997                 case wxT('"'):
1998                     strResult += wxT('"');
1999                     break;
2000             }
2001         }
2002         else // not a backslash
2003         {
2004             if ( *i != wxT('"') || !bQuoted )
2005             {
2006                 strResult += *i;
2007             }
2008             else if ( i != end - 1 )
2009             {
2010                 wxLogWarning(_("unexpected \" at position %d in '%s'."),
2011                              i - str.begin(), str.c_str());
2012             }
2013             //else: it's the last quote of a quoted string, ok
2014         }
2015     }
2016
2017     return strResult;
2018 }
2019
2020 // quote the string before writing it to file
2021 static wxString FilterOutValue(const wxString& str)
2022 {
2023    if ( !str )
2024       return str;
2025
2026   wxString strResult;
2027   strResult.Alloc(str.Len());
2028
2029   // quoting is necessary to preserve spaces in the beginning of the string
2030   bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
2031
2032   if ( bQuote )
2033     strResult += wxT('"');
2034
2035   wxChar c;
2036   for ( size_t n = 0; n < str.Len(); n++ ) {
2037     switch ( str[n].GetValue() ) {
2038       case wxT('\n'):
2039         c = wxT('n');
2040         break;
2041
2042       case wxT('\r'):
2043         c = wxT('r');
2044         break;
2045
2046       case wxT('\t'):
2047         c = wxT('t');
2048         break;
2049
2050       case wxT('\\'):
2051         c = wxT('\\');
2052         break;
2053
2054       case wxT('"'):
2055         if ( bQuote ) {
2056           c = wxT('"');
2057           break;
2058         }
2059         //else: fall through
2060
2061       default:
2062         strResult += str[n];
2063         continue;   // nothing special to do
2064     }
2065
2066     // we get here only for special characters
2067     strResult << wxT('\\') << c;
2068   }
2069
2070   if ( bQuote )
2071     strResult += wxT('"');
2072
2073   return strResult;
2074 }
2075
2076 // undo FilterOutEntryName
2077 static wxString FilterInEntryName(const wxString& str)
2078 {
2079   wxString strResult;
2080   strResult.Alloc(str.Len());
2081
2082   for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
2083     if ( *pc == wxT('\\') ) {
2084       // we need to test it here or we'd skip past the NUL in the loop line
2085       if ( *++pc == _T('\0') )
2086         break;
2087     }
2088
2089     strResult += *pc;
2090   }
2091
2092   return strResult;
2093 }
2094
2095 // sanitize entry or group name: insert '\\' before any special characters
2096 static wxString FilterOutEntryName(const wxString& str)
2097 {
2098   wxString strResult;
2099   strResult.Alloc(str.Len());
2100
2101   for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
2102     const wxChar c = *pc;
2103
2104     // we explicitly allow some of "safe" chars and 8bit ASCII characters
2105     // which will probably never have special meaning and with which we can't
2106     // use isalnum() anyhow (in ASCII built, in Unicode it's just fine)
2107     //
2108     // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2109     //     should *not* be quoted
2110     if (
2111 #if !wxUSE_UNICODE
2112             ((unsigned char)c < 127) &&
2113 #endif // ANSI
2114          !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) )
2115     {
2116       strResult += wxT('\\');
2117     }
2118
2119     strResult += c;
2120   }
2121
2122   return strResult;
2123 }
2124
2125 // we can't put ?: in the ctor initializer list because it confuses some
2126 // broken compilers (Borland C++)
2127 static wxString GetAppName(const wxString& appName)
2128 {
2129     if ( !appName && wxTheApp )
2130         return wxTheApp->GetAppName();
2131     else
2132         return appName;
2133 }
2134
2135 #endif // wxUSE_CONFIG