src/common/fileconf.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 license
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "fileconf.h"
  15 #endif
  16
  17 // ============================================================================
  18 // declarations
  19 // ============================================================================
  20
  21 // ----------------------------------------------------------------------------
  22 // headers
  23 // ----------------------------------------------------------------------------
  24 #include  "wx/wxprec.h"
  25
  26 #ifdef    __BORLANDC__
  27   #pragma hdrstop
  28 #endif  //__BORLANDC__
  29
  30 #ifndef   WX_PRECOMP
  31   #include  "wx/string.h"
  32   #include  "wx/intl.h"
  33 #endif  //WX_PRECOMP
  34
  35 #include  "wx/app.h"
  36 #include  "wx/dynarray.h"
  37 #include  "wx/file.h"
  38 #include  "wx/log.h"
  39 #include  "wx/textfile.h"
  40 #include  "wx/config.h"
  41 #include  "wx/fileconf.h"
  42
  43 #include  "wx/utils.h"    // for wxGetHomeDir
  44
  45 // _WINDOWS_ is defined when windows.h is included,
  46 // __WXMSW__ is defined for MS Windows compilation
  47 #if       defined(__WXMSW__) && !defined(_WINDOWS_)
  48   #include  <windows.h>
  49 #endif  //windows.h
  50
  51 #include  <stdlib.h>
  52 #include  <ctype.h>
  53
  54 // ----------------------------------------------------------------------------
  55 // macros
  56 // ----------------------------------------------------------------------------
  57 #define CONST_CAST ((wxFileConfig *)this)->
  58
  59 // ----------------------------------------------------------------------------
  60 // constants
  61 // ----------------------------------------------------------------------------
  62 #ifndef MAX_PATH
  63   #define MAX_PATH 512
  64 #endif
  65
  66 // ----------------------------------------------------------------------------
  67 // global functions declarations
  68 // ----------------------------------------------------------------------------
  69
  70 // is 'c' a valid character in group name?
  71 // NB: wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR must be valid chars,
  72 //     but _not_ ']' (group name delimiter)
  73 inline bool IsValid(char c) { return isalnum(c) || strchr("@_/-!.*%", c); }
  74
  75 // compare functions for sorting the arrays
  76 static int CompareEntries(ConfigEntry *p1,
  77                           ConfigEntry *p2);
  78 static int CompareGroups(ConfigGroup *p1,
  79                          ConfigGroup *p2);
  80
  81 // filter strings
  82 static wxString FilterIn(const wxString& str);
  83 static wxString FilterOut(const wxString& str);
  84
  85 // ============================================================================
  86 // implementation
  87 // ============================================================================
  88
  89 // ----------------------------------------------------------------------------
  90 // static functions
  91 // ----------------------------------------------------------------------------
  92 wxString wxFileConfig::GetGlobalDir()
  93 {
  94   wxString strDir;
  95
  96   #ifdef __UNIX__
  97     strDir = "/etc/";
  98   #elif defined(__WXSTUBS__)
  99     wxASSERT_MSG( FALSE, "TODO" ) ;
 100   #else // Windows
 101     char szWinDir[MAX_PATH];
 102     ::GetWindowsDirectory(szWinDir, MAX_PATH);
 103
 104     strDir = szWinDir;
 105     strDir << '\\';
 106   #endif // Unix/Windows
 107
 108   return strDir;
 109 }
 110
 111 wxString wxFileConfig::GetLocalDir()
 112 {
 113   wxString strDir;
 114
 115   wxGetHomeDir(&strDir);
 116
 117 #ifdef  __UNIX__
 118   if (strDir.Last() != '/') strDir << '/';
 119 #else
 120   if (strDir.Last() != '\\') strDir << '\\';
 121 #endif
 122
 123   return strDir;
 124 }
 125
 126 wxString wxFileConfig::GetGlobalFileName(const char *szFile)
 127 {
 128   wxString str = GetGlobalDir();
 129   str << szFile;
 130
 131   if ( strchr(szFile, '.') == NULL )
 132   #ifdef  __UNIX__
 133     str << ".conf";
 134   #else   // Windows
 135     str << ".ini";
 136   #endif  // UNIX/Win
 137
 138   return str;
 139 }
 140
 141 wxString wxFileConfig::GetLocalFileName(const char *szFile)
 142 {
 143   wxString str = GetLocalDir();
 144
 145   #ifdef  __UNIX__
 146     str << '.';
 147   #endif
 148
 149   str << szFile;
 150
 151   #ifdef __WXMSW__
 152     if ( strchr(szFile, '.') == NULL )
 153       str << ".ini";
 154   #endif
 155
 156   return str;
 157 }
 158
 159 // ----------------------------------------------------------------------------
 160 // ctor
 161 // ----------------------------------------------------------------------------
 162
 163 void wxFileConfig::Init()
 164 {
 165   m_pCurrentGroup =
 166   m_pRootGroup    = new ConfigGroup(NULL, "", this);
 167
 168   m_linesHead =
 169   m_linesTail = NULL;
 170
 171   // it's not an error if (one of the) file(s) doesn't exist
 172
 173   // parse the global file
 174   if ( !m_strGlobalFile.IsEmpty() && wxFile::Exists(m_strGlobalFile) ) {
 175     wxTextFile fileGlobal(m_strGlobalFile);
 176
 177     if ( fileGlobal.Open() ) {
 178       Parse(fileGlobal, FALSE /* global */);
 179       SetRootPath();
 180     }
 181     else
 182       wxLogWarning(_("can't open global configuration file '%s'."),
 183                    m_strGlobalFile.c_str());
 184   }
 185
 186   // parse the local file
 187   if ( !m_strLocalFile.IsEmpty() && wxFile::Exists(m_strLocalFile) ) {
 188     wxTextFile fileLocal(m_strLocalFile);
 189     if ( fileLocal.Open() ) {
 190       Parse(fileLocal, TRUE /* local */);
 191       SetRootPath();
 192     }
 193     else
 194       wxLogWarning(_("can't open user configuration file '%s'."),
 195                    m_strLocalFile.c_str());
 196   }
 197 }
 198
 199 // constructor supports creation of wxFileConfig objects of any type
 200 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
 201                            const wxString& strLocal, const wxString& strGlobal,
 202                            long style)
 203             : wxConfigBase(appName, vendorName, strLocal, strGlobal, style),
 204               m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
 205 {
 206   // Make up an application name if not supplied
 207   if (appName.IsEmpty() && wxTheApp)
 208   {
 209     SetAppName(wxTheApp->GetAppName());
 210   }
 211
 212   // Make up names for files if empty
 213   if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
 214   {
 215     m_strLocalFile = GetLocalFileName(GetAppName());
 216   }
 217
 218   if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
 219   {
 220     m_strGlobalFile = GetGlobalFileName(GetAppName());
 221   }
 222
 223   // Check if styles are not supplied, but filenames are, in which case
 224   // add the correct styles.
 225   if ( !m_strLocalFile.IsEmpty() )
 226     SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
 227
 228   if ( !m_strGlobalFile.IsEmpty() )
 229     SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
 230
 231   // if the path is not absolute, prepend the standard directory to it
 232   if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
 233   {
 234     wxString strLocal = m_strLocalFile;
 235     m_strLocalFile = GetLocalDir();
 236     m_strLocalFile << strLocal;
 237   }
 238
 239   if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
 240   {
 241     wxString strGlobal = m_strGlobalFile;
 242     m_strGlobalFile = GetGlobalDir();
 243     m_strGlobalFile << strGlobal;
 244   }
 245
 246   Init();
 247 }
 248
 249 void wxFileConfig::CleanUp()
 250 {
 251   delete m_pRootGroup;
 252
 253   LineList *pCur = m_linesHead;
 254   while ( pCur != NULL ) {
 255     LineList *pNext = pCur->Next();
 256     delete pCur;
 257     pCur = pNext;
 258   }
 259 }
 260
 261 wxFileConfig::~wxFileConfig()
 262 {
 263   Flush();
 264
 265   CleanUp();
 266 }
 267
 268 // ----------------------------------------------------------------------------
 269 // parse a config file
 270 // ----------------------------------------------------------------------------
 271
 272 void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
 273 {
 274   const char *pStart;
 275   const char *pEnd;
 276   wxString strLine;
 277
 278   size_t nLineCount = file.GetLineCount();
 279   for ( size_t n = 0; n < nLineCount; n++ ) {
 280     strLine = file[n];
 281
 282     // add the line to linked list
 283     if ( bLocal )
 284       LineListAppend(strLine);
 285
 286     // skip leading spaces
 287     for ( pStart = strLine; isspace(*pStart); pStart++ )
 288       ;
 289
 290     // skip blank/comment lines
 291     if ( *pStart == '\0'|| *pStart == ';' || *pStart == '#' )
 292       continue;
 293
 294     if ( *pStart == '[' ) {          // a new group
 295       pEnd = pStart;
 296
 297       while ( *++pEnd != ']' ) {
 298         if ( !IsValid(*pEnd) && *pEnd != ' ' )  // allow spaces in group names
 299           break;
 300       }
 301
 302       if ( *pEnd != ']' ) {
 303         wxLogError(_("file '%s': unexpected character %c at line %d."),
 304                    file.GetName(), *pEnd, n + 1);
 305         continue; // skip this line
 306       }
 307
 308       // group name here is always considered as abs path
 309       wxString strGroup;
 310       pStart++;
 311       strGroup << wxCONFIG_PATH_SEPARATOR << wxString(pStart, pEnd - pStart);
 312
 313       // will create it if doesn't yet exist
 314       SetPath(strGroup);
 315
 316       if ( bLocal )
 317         m_pCurrentGroup->SetLine(m_linesTail);
 318
 319       // check that there is nothing except comments left on this line
 320       bool bCont = TRUE;
 321       while ( *++pEnd != '\0' && bCont ) {
 322         switch ( *pEnd ) {
 323           case '#':
 324           case ';':
 325             bCont = FALSE;
 326             break;
 327
 328           case ' ':
 329           case '\t':
 330             // ignore whitespace ('\n' impossible here)
 331             break;
 332
 333           default:
 334             wxLogWarning(_("file '%s', line %d: '%s' "
 335                            "ignored after group header."),
 336                          file.GetName(), n + 1, pEnd);
 337             bCont = FALSE;
 338         }
 339       }
 340     }
 341     else {                        // a key
 342       const char *pEnd = pStart;
 343       while ( IsValid(*pEnd) )
 344         pEnd++;
 345
 346       wxString strKey(pStart, pEnd);
 347
 348       // skip whitespace
 349       while ( isspace(*pEnd) )
 350         pEnd++;
 351
 352       if ( *pEnd++ != '=' ) {
 353         wxLogError(_("file '%s', line %d: '=' expected."),
 354                    file.GetName(), n + 1);
 355       }
 356       else {
 357         ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
 358
 359         if ( pEntry == NULL ) {
 360           // new entry
 361           pEntry = m_pCurrentGroup->AddEntry(strKey, n);
 362
 363           if ( bLocal )
 364             pEntry->SetLine(m_linesTail);
 365         }
 366         else {
 367           if ( bLocal && pEntry->IsImmutable() ) {
 368             // immutable keys can't be changed by user
 369             wxLogWarning(_("file '%s', line %d: value for "
 370                            "immutable key '%s' ignored."),
 371                          file.GetName(), n + 1, strKey.c_str());
 372             continue;
 373           }
 374           // the condition below catches the cases (a) and (b) but not (c):
 375           //  (a) global key found second time in global file
 376           //  (b) key found second (or more) time in local file
 377           //  (c) key from global file now found in local one
 378           // which is exactly what we want.
 379           else if ( !bLocal || pEntry->IsLocal() ) {
 380             wxLogWarning(_("file '%s', line %d: key '%s' was first "
 381                            "found at line %d."),
 382                          file.GetName(), n + 1, strKey.c_str(), pEntry->Line());
 383
 384             if ( bLocal )
 385               pEntry->SetLine(m_linesTail);
 386           }
 387         }
 388
 389         // skip whitespace
 390         while ( isspace(*pEnd) )
 391           pEnd++;
 392
 393         pEntry->SetValue(FilterIn(pEnd), FALSE /* read from file */);
 394       }
 395     }
 396   }
 397 }
 398
 399 // ----------------------------------------------------------------------------
 400 // set/retrieve path
 401 // ----------------------------------------------------------------------------
 402
 403 void wxFileConfig::SetRootPath()
 404 {
 405   m_strPath.Empty();
 406   m_pCurrentGroup = m_pRootGroup;
 407 }
 408
 409 void wxFileConfig::SetPath(const wxString& strPath)
 410 {
 411   wxArrayString aParts;
 412
 413   if ( strPath.IsEmpty() ) {
 414     SetRootPath();
 415     return;
 416   }
 417
 418   if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
 419     // absolute path
 420     wxSplitPath(aParts, strPath);
 421   }
 422   else {
 423     // relative path, combine with current one
 424     wxString strFullPath = m_strPath;
 425     strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
 426     wxSplitPath(aParts, strFullPath);
 427   }
 428
 429   // change current group
 430   size_t n;
 431   m_pCurrentGroup = m_pRootGroup;
 432   for ( n = 0; n < aParts.Count(); n++ ) {
 433     ConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
 434     if ( pNextGroup == NULL )
 435       pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
 436     m_pCurrentGroup = pNextGroup;
 437   }
 438
 439   // recombine path parts in one variable
 440   m_strPath.Empty();
 441   for ( n = 0; n < aParts.Count(); n++ ) {
 442     m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
 443   }
 444 }
 445
 446 // ----------------------------------------------------------------------------
 447 // enumeration
 448 // ----------------------------------------------------------------------------
 449
 450 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
 451 {
 452   lIndex = 0;
 453   return GetNextGroup(str, lIndex);
 454 }
 455
 456 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
 457 {
 458   if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
 459     str = m_pCurrentGroup->Groups()[lIndex++]->Name();
 460     return TRUE;
 461   }
 462   else
 463     return FALSE;
 464 }
 465
 466 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
 467 {
 468   lIndex = 0;
 469   return GetNextEntry(str, lIndex);
 470 }
 471
 472 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
 473 {
 474   if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
 475     str = m_pCurrentGroup->Entries()[lIndex++]->Name();
 476     return TRUE;
 477   }
 478   else
 479     return FALSE;
 480 }
 481
 482 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
 483 {
 484   size_t n = m_pCurrentGroup->Entries().Count();
 485   if ( bRecursive ) {
 486     ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 487     size_t nSubgroups = m_pCurrentGroup->Groups().Count();
 488     for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 489       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 490       n += GetNumberOfEntries(TRUE);
 491       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
 492     }
 493   }
 494
 495   return n;
 496 }
 497
 498 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
 499 {
 500   size_t n = m_pCurrentGroup->Groups().Count();
 501   if ( bRecursive ) {
 502     ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 503     size_t nSubgroups = m_pCurrentGroup->Groups().Count();
 504     for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 505       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 506       n += GetNumberOfGroups(TRUE);
 507       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
 508     }
 509   }
 510
 511   return n;
 512 }
 513
 514 // ----------------------------------------------------------------------------
 515 // tests for existence
 516 // ----------------------------------------------------------------------------
 517
 518 bool wxFileConfig::HasGroup(const wxString& strName) const
 519 {
 520   wxConfigPathChanger path(this, strName);
 521
 522   ConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
 523   return pGroup != NULL;
 524 }
 525
 526 bool wxFileConfig::HasEntry(const wxString& strName) const
 527 {
 528   wxConfigPathChanger path(this, strName);
 529
 530   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
 531   return pEntry != NULL;
 532 }
 533
 534 // ----------------------------------------------------------------------------
 535 // read/write values
 536 // ----------------------------------------------------------------------------
 537
 538 bool wxFileConfig::Read(const wxString& key,
 539                         wxString* pStr) const
 540 {
 541   wxConfigPathChanger path(this, key);
 542
 543   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
 544   if (pEntry == NULL) {
 545     return FALSE;
 546   }
 547   else {
 548     *pStr = ExpandEnvVars(pEntry->Value());
 549     return TRUE;
 550   }
 551 }
 552
 553 bool wxFileConfig::Read(const wxString& key,
 554                         wxString* pStr, const wxString& defVal) const
 555 {
 556   wxConfigPathChanger path(this, key);
 557
 558   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
 559   if (pEntry == NULL) {
 560     if( IsRecordingDefaults() )
 561       ((wxFileConfig *)this)->Write(key,defVal);
 562     *pStr = ExpandEnvVars(defVal);
 563     return FALSE;
 564   }
 565   else {
 566     *pStr = ExpandEnvVars(pEntry->Value());
 567     return TRUE;
 568   }
 569 }
 570
 571 bool wxFileConfig::Read(const wxString& key, long *pl) const
 572 {
 573   wxString str;
 574   if ( Read(key, & str) ) {
 575     *pl = atol(str);
 576     return TRUE;
 577   }
 578   else {
 579     return FALSE;
 580   }
 581 }
 582
 583 bool wxFileConfig::Write(const wxString& key, const wxString& szValue)
 584 {
 585   wxConfigPathChanger path(this, key);
 586
 587   wxString strName = path.Name();
 588   if ( strName.IsEmpty() ) {
 589     // setting the value of a group is an error
 590     wxASSERT_MSG( IsEmpty(szValue), _("can't set value of a group!") );
 591
 592     // ... except if it's empty in which case it's a way to force it's creation
 593     m_pCurrentGroup->SetDirty();
 594
 595     // this will add a line for this group if it didn't have it before
 596     (void)m_pCurrentGroup->GetGroupLine();
 597   }
 598   else {
 599     // writing an entry
 600
 601     // check that the name is reasonable
 602     if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) {
 603       wxLogError(_("Entry name can't start with '%c'."),
 604                  wxCONFIG_IMMUTABLE_PREFIX);
 605       return FALSE;
 606     }
 607
 608     for ( const char *pc = strName; *pc != '\0'; pc++ ) {
 609       if ( !IsValid(*pc) ) {
 610         wxLogError(_("Character '%c' is invalid in a config entry name."),
 611                    *pc);
 612         return FALSE;
 613       }
 614     }
 615
 616     ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
 617     if ( pEntry == NULL )
 618       pEntry = m_pCurrentGroup->AddEntry(strName);
 619
 620     pEntry->SetValue(szValue);
 621   }
 622
 623   return TRUE;
 624 }
 625
 626 bool wxFileConfig::Write(const wxString& key, long lValue)
 627 {
 628   // ltoa() is not ANSI :-(
 629   wxString buf;
 630   buf.Printf("%ld", lValue);
 631   return Write(key, buf);
 632 }
 633
 634 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
 635 {
 636   if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() )
 637     return TRUE;
 638
 639   wxTempFile file(m_strLocalFile);
 640
 641   if ( !file.IsOpened() ) {
 642     wxLogError(_("can't open user configuration file."));
 643     return FALSE;
 644   }
 645
 646   // write all strings to file
 647   for ( LineList *p = m_linesHead; p != NULL; p = p->Next() ) {
 648     if ( !file.Write(p->Text() + wxTextFile::GetEOL()) ) {
 649       wxLogError(_("can't write user configuration file."));
 650       return FALSE;
 651     }
 652   }
 653
 654   return file.Commit();
 655 }
 656
 657 // ----------------------------------------------------------------------------
 658 // delete groups/entries
 659 // ----------------------------------------------------------------------------
 660
 661 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
 662 {
 663   wxConfigPathChanger path(this, key);
 664
 665   if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
 666     return FALSE;
 667
 668   if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
 669     if ( m_pCurrentGroup != m_pRootGroup ) {
 670       ConfigGroup *pGroup = m_pCurrentGroup;
 671       SetPath("..");  // changes m_pCurrentGroup!
 672       m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
 673     }
 674     //else: never delete the root group
 675   }
 676
 677   return TRUE;
 678 }
 679
 680 bool wxFileConfig::DeleteGroup(const wxString& key)
 681 {
 682   wxConfigPathChanger path(this, key);
 683
 684   return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
 685 }
 686
 687 bool wxFileConfig::DeleteAll()
 688 {
 689   CleanUp();
 690
 691   const char *szFile = m_strLocalFile;
 692
 693   if ( remove(szFile) == -1 )
 694     wxLogSysError(_("can't delete user configuration file '%s'"), szFile);
 695
 696   m_strLocalFile = m_strGlobalFile = "";
 697   Init();
 698
 699   return TRUE;
 700 }
 701
 702 // ----------------------------------------------------------------------------
 703 // linked list functions
 704 // ----------------------------------------------------------------------------
 705
 706 // append a new line to the end of the list
 707 LineList *wxFileConfig::LineListAppend(const wxString& str)
 708 {
 709   LineList *pLine = new LineList(str);
 710
 711   if ( m_linesTail == NULL ) {
 712     // list is empty
 713     m_linesHead = pLine;
 714   }
 715   else {
 716     // adjust pointers
 717     m_linesTail->SetNext(pLine);
 718     pLine->SetPrev(m_linesTail);
 719   }
 720
 721   m_linesTail = pLine;
 722   return m_linesTail;
 723 }
 724
 725 // insert a new line after the given one or in the very beginning if !pLine
 726 LineList *wxFileConfig::LineListInsert(const wxString& str,
 727                                                      LineList *pLine)
 728 {
 729   if ( pLine == m_linesTail )
 730     return LineListAppend(str);
 731
 732   LineList *pNewLine = new LineList(str);
 733   if ( pLine == NULL ) {
 734     // prepend to the list
 735     pNewLine->SetNext(m_linesHead);
 736     m_linesHead->SetPrev(pNewLine);
 737     m_linesHead = pNewLine;
 738   }
 739   else {
 740     // insert before pLine
 741     LineList *pNext = pLine->Next();
 742     pNewLine->SetNext(pNext);
 743     pNewLine->SetPrev(pLine);
 744     pNext->SetPrev(pNewLine);
 745     pLine->SetNext(pNewLine);
 746   }
 747
 748   return pNewLine;
 749 }
 750
 751 void wxFileConfig::LineListRemove(LineList *pLine)
 752 {
 753   LineList *pPrev = pLine->Prev(),
 754            *pNext = pLine->Next();
 755
 756   // first entry?
 757   if ( pPrev == NULL )
 758     m_linesHead = pNext;
 759   else
 760     pPrev->SetNext(pNext);
 761
 762   // last entry?
 763   if ( pNext == NULL )
 764     m_linesTail = pPrev;
 765   else
 766     pNext->SetPrev(pPrev);
 767
 768   delete pLine;
 769 }
 770
 771 bool wxFileConfig::LineListIsEmpty()
 772 {
 773   return m_linesHead == NULL;
 774 }
 775
 776 // ============================================================================
 777 // wxFileConfig::ConfigGroup
 778 // ============================================================================
 779
 780 // ----------------------------------------------------------------------------
 781 // ctor/dtor
 782 // ----------------------------------------------------------------------------
 783
 784 // ctor
 785 ConfigGroup::ConfigGroup(ConfigGroup *pParent,
 786                                        const wxString& strName,
 787                                        wxFileConfig *pConfig)
 788                          : m_aEntries(CompareEntries),
 789                            m_aSubgroups(CompareGroups),
 790                            m_strName(strName)
 791 {
 792   m_pConfig = pConfig;
 793   m_pParent = pParent;
 794   m_bDirty  = FALSE;
 795   m_pLine   = NULL;
 796
 797   m_pLastEntry = NULL;
 798   m_pLastGroup = NULL;
 799 }
 800
 801 // dtor deletes all children
 802 ConfigGroup::~ConfigGroup()
 803 {
 804   // entries
 805   size_t n, nCount = m_aEntries.Count();
 806   for ( n = 0; n < nCount; n++ )
 807     delete m_aEntries[n];
 808
 809   // subgroups
 810   nCount = m_aSubgroups.Count();
 811   for ( n = 0; n < nCount; n++ )
 812     delete m_aSubgroups[n];
 813 }
 814
 815 // ----------------------------------------------------------------------------
 816 // line
 817 // ----------------------------------------------------------------------------
 818
 819 void ConfigGroup::SetLine(LineList *pLine)
 820 {
 821   wxASSERT( m_pLine == NULL ); // shouldn't be called twice
 822
 823   m_pLine = pLine;
 824 }
 825
 826 /*
 827   This is a bit complicated, so let me explain it in details. All lines that
 828   were read from the local file (the only one we will ever modify) are stored
 829   in a (doubly) linked list. Our problem is to know at which position in this
 830   list should we insert the new entries/subgroups. To solve it we keep three
 831   variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
 832
 833   m_pLine points to the line containing "[group_name]"
 834   m_pLastEntry points to the last entry of this group in the local file.
 835   m_pLastGroup                   subgroup
 836
 837   Initially, they're NULL all three. When the group (an entry/subgroup) is read
 838   from the local file, the corresponding variable is set. However, if the group
 839   was read from the global file and then modified or created by the application
 840   these variables are still NULL and we need to create the corresponding lines.
 841   See the following functions (and comments preceding them) for the details of
 842   how we do it.
 843
 844   Also, when our last entry/group are deleted we need to find the new last
 845   element - the code in DeleteEntry/Subgroup does this by backtracking the list
 846   of lines until it either founds an entry/subgroup (and this is the new last
 847   element) or the m_pLine of the group, in which case there are no more entries
 848   (or subgroups) left and m_pLast<element> becomes NULL.
 849
 850   NB: This last problem could be avoided for entries if we added new entries
 851       immediately after m_pLine, but in this case the entries would appear
 852       backwards in the config file (OTOH, it's not that important) and as we
 853       would still need to do it for the subgroups the code wouldn't have been
 854       significantly less complicated.
 855  */
 856
 857 // Return the line which contains "[our name]". If we're still not in the list,
 858 // add our line to it immediately after the last line of our parent group if we
 859 // have it or in the very beginning if we're the root group.
 860 LineList *ConfigGroup::GetGroupLine()
 861 {
 862   if ( m_pLine == NULL ) {
 863     ConfigGroup *pParent = Parent();
 864
 865     // this group wasn't present in local config file, add it now
 866     if ( pParent != NULL ) {
 867       wxString strFullName;
 868       strFullName << "[" << (GetFullName().c_str() + 1) << "]"; // +1: no '/'
 869       m_pLine = m_pConfig->LineListInsert(strFullName,
 870                                           pParent->GetLastGroupLine());
 871       pParent->SetLastGroup(this);  // we're surely after all the others
 872     }
 873     else {
 874       // we return NULL, so that LineListInsert() will insert us in the
 875       // very beginning
 876     }
 877   }
 878
 879   return m_pLine;
 880 }
 881
 882 // Return the last line belonging to the subgroups of this group (after which
 883 // we can add a new subgroup), if we don't have any subgroups or entries our
 884 // last line is the group line (m_pLine) itself.
 885 LineList *ConfigGroup::GetLastGroupLine()
 886 {
 887   // if we have any subgroups, our last line is the last line of the last
 888   // subgroup
 889   if ( m_pLastGroup != NULL ) {
 890     LineList *pLine = m_pLastGroup->GetLastGroupLine();
 891
 892     wxASSERT( pLine != NULL );  // last group must have !NULL associated line
 893     return pLine;
 894   }
 895
 896   // no subgroups, so the last line is the line of thelast entry (if any)
 897   return GetLastEntryLine();
 898 }
 899
 900 // return the last line belonging to the entries of this group (after which
 901 // we can add a new entry), if we don't have any entries we will add the new
 902 // one immediately after the group line itself.
 903 LineList *ConfigGroup::GetLastEntryLine()
 904 {
 905   if ( m_pLastEntry != NULL ) {
 906     LineList *pLine = m_pLastEntry->GetLine();
 907
 908     wxASSERT( pLine != NULL );  // last entry must have !NULL associated line
 909     return pLine;
 910   }
 911
 912   // no entries: insert after the group header
 913   return GetGroupLine();
 914 }
 915
 916 // ----------------------------------------------------------------------------
 917 // group name
 918 // ----------------------------------------------------------------------------
 919
 920 wxString ConfigGroup::GetFullName() const
 921 {
 922   if ( Parent() )
 923     return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
 924   else
 925     return "";
 926 }
 927
 928 // ----------------------------------------------------------------------------
 929 // find an item
 930 // ----------------------------------------------------------------------------
 931
 932 // use binary search because the array is sorted
 933 ConfigEntry *
 934 ConfigGroup::FindEntry(const char *szName) const
 935 {
 936   size_t i,
 937        lo = 0,
 938        hi = m_aEntries.Count();
 939   int res;
 940   ConfigEntry *pEntry;
 941
 942   while ( lo < hi ) {
 943     i = (lo + hi)/2;
 944     pEntry = m_aEntries[i];
 945
 946     #if wxCONFIG_CASE_SENSITIVE
 947       res = strcmp(pEntry->Name(), szName);
 948     #else
 949       res = Stricmp(pEntry->Name(), szName);
 950     #endif
 951
 952     if ( res > 0 )
 953       hi = i;
 954     else if ( res < 0 )
 955       lo = i + 1;
 956     else
 957       return pEntry;
 958   }
 959
 960   return NULL;
 961 }
 962
 963 ConfigGroup *
 964 ConfigGroup::FindSubgroup(const char *szName) const
 965 {
 966   size_t i,
 967        lo = 0,
 968        hi = m_aSubgroups.Count();
 969   int res;
 970   ConfigGroup *pGroup;
 971
 972   while ( lo < hi ) {
 973     i = (lo + hi)/2;
 974     pGroup = m_aSubgroups[i];
 975
 976     #if wxCONFIG_CASE_SENSITIVE
 977       res = strcmp(pGroup->Name(), szName);
 978     #else
 979       res = Stricmp(pGroup->Name(), szName);
 980     #endif
 981
 982     if ( res > 0 )
 983       hi = i;
 984     else if ( res < 0 )
 985       lo = i + 1;
 986     else
 987       return pGroup;
 988   }
 989
 990   return NULL;
 991 }
 992
 993 // ----------------------------------------------------------------------------
 994 // create a new item
 995 // ----------------------------------------------------------------------------
 996
 997 // create a new entry and add it to the current group
 998 ConfigEntry *
 999 ConfigGroup::AddEntry(const wxString& strName, int nLine)
1000 {
1001   wxASSERT( FindEntry(strName) == NULL );
1002
1003   ConfigEntry *pEntry = new ConfigEntry(this, strName, nLine);
1004   m_aEntries.Add(pEntry);
1005
1006   return pEntry;
1007 }
1008
1009 // create a new group and add it to the current group
1010 ConfigGroup *
1011 ConfigGroup::AddSubgroup(const wxString& strName)
1012 {
1013   wxASSERT( FindSubgroup(strName) == NULL );
1014
1015   ConfigGroup *pGroup = new ConfigGroup(this, strName, m_pConfig);
1016   m_aSubgroups.Add(pGroup);
1017
1018   return pGroup;
1019 }
1020
1021 // ----------------------------------------------------------------------------
1022 // delete an item
1023 // ----------------------------------------------------------------------------
1024
1025 /*
1026   The delete operations are _very_ slow if we delete the last item of this
1027   group (see comments before GetXXXLineXXX functions for more details),
1028   so it's much better to start with the first entry/group if we want to
1029   delete several of them.
1030  */
1031
1032 bool ConfigGroup::DeleteSubgroupByName(const char *szName)
1033 {
1034   return DeleteSubgroup(FindSubgroup(szName));
1035 }
1036
1037 // doesn't delete the subgroup itself, but does remove references to it from
1038 // all other data structures (and normally the returned pointer should be
1039 // deleted a.s.a.p. because there is nothing much to be done with it anyhow)
1040 bool ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
1041 {
1042   wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
1043
1044   // delete all entries
1045   size_t nCount = pGroup->m_aEntries.Count();
1046   for ( size_t nEntry = 0; nEntry < nCount; nEntry++ ) {
1047     LineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1048     if ( pLine != NULL )
1049       m_pConfig->LineListRemove(pLine);
1050   }
1051
1052   // and subgroups of this sungroup
1053   nCount = pGroup->m_aSubgroups.Count();
1054   for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) {
1055     pGroup->DeleteSubgroup(pGroup->m_aSubgroups[nGroup]);
1056   }
1057
1058   LineList *pLine = pGroup->m_pLine;
1059   if ( pLine != NULL ) {
1060     // notice that we may do this test inside the previous "if" because the
1061     // last entry's line is surely !NULL
1062     if ( pGroup == m_pLastGroup ) {
1063       // our last entry is being deleted - find the last one which stays
1064       wxASSERT( m_pLine != NULL );  // we have a subgroup with !NULL pLine...
1065
1066       // go back until we find a subgroup or reach the group's line
1067       ConfigGroup *pNewLast = NULL;
1068       size_t n, nSubgroups = m_aSubgroups.Count();
1069       LineList *pl;
1070       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1071         // is it our subgroup?
1072         for ( n = 0; (pNewLast == NULL) && (n < nSubgroups); n++ ) {
1073           // do _not_ call GetGroupLine! we don't want to add it to the local
1074           // file if it's not already there
1075           if ( m_aSubgroups[n]->m_pLine == m_pLine )
1076             pNewLast = m_aSubgroups[n];
1077         }
1078
1079         if ( pNewLast != NULL ) // found?
1080           break;
1081       }
1082
1083       if ( pl == m_pLine ) {
1084         wxASSERT( !pNewLast );  // how comes it has the same line as we?
1085
1086         // we've reached the group line without finding any subgroups
1087         m_pLastGroup = NULL;
1088       }
1089       else
1090         m_pLastGroup = pNewLast;
1091     }
1092
1093     m_pConfig->LineListRemove(pLine);
1094   }
1095
1096   SetDirty();
1097
1098   m_aSubgroups.Remove(pGroup);
1099   delete pGroup;
1100
1101   return TRUE;
1102 }
1103
1104 bool ConfigGroup::DeleteEntry(const char *szName)
1105 {
1106   ConfigEntry *pEntry = FindEntry(szName);
1107   wxCHECK( pEntry != NULL, FALSE );  // deleting non existing item?
1108
1109   LineList *pLine = pEntry->GetLine();
1110   if ( pLine != NULL ) {
1111     // notice that we may do this test inside the previous "if" because the
1112     // last entry's line is surely !NULL
1113     if ( pEntry == m_pLastEntry ) {
1114       // our last entry is being deleted - find the last one which stays
1115       wxASSERT( m_pLine != NULL );  // if we have an entry with !NULL pLine...
1116
1117       // go back until we find another entry or reach the group's line
1118       ConfigEntry *pNewLast = NULL;
1119       size_t n, nEntries = m_aEntries.Count();
1120       LineList *pl;
1121       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1122         // is it our subgroup?
1123         for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1124           if ( m_aEntries[n]->GetLine() == m_pLine )
1125             pNewLast = m_aEntries[n];
1126         }
1127
1128         if ( pNewLast != NULL ) // found?
1129           break;
1130       }
1131
1132       if ( pl == m_pLine ) {
1133         wxASSERT( !pNewLast );  // how comes it has the same line as we?
1134
1135         // we've reached the group line without finding any subgroups
1136         m_pLastEntry = NULL;
1137       }
1138       else
1139         m_pLastEntry = pNewLast;
1140     }
1141
1142     m_pConfig->LineListRemove(pLine);
1143   }
1144
1145   // we must be written back for the changes to be saved
1146   SetDirty();
1147
1148   m_aEntries.Remove(pEntry);
1149   delete pEntry;
1150
1151   return TRUE;
1152 }
1153
1154 // ----------------------------------------------------------------------------
1155 //
1156 // ----------------------------------------------------------------------------
1157 void ConfigGroup::SetDirty()
1158 {
1159   m_bDirty = TRUE;
1160   if ( Parent() != NULL )             // propagate upwards
1161     Parent()->SetDirty();
1162 }
1163
1164 // ============================================================================
1165 // wxFileConfig::ConfigEntry
1166 // ============================================================================
1167
1168 // ----------------------------------------------------------------------------
1169 // ctor
1170 // ----------------------------------------------------------------------------
1171 ConfigEntry::ConfigEntry(ConfigGroup *pParent,
1172                                        const wxString& strName,
1173                                        int nLine)
1174                          : m_strName(strName)
1175 {
1176   wxASSERT( !strName.IsEmpty() );
1177
1178   m_pParent = pParent;
1179   m_nLine   = nLine;
1180   m_pLine   = NULL;
1181
1182   m_bDirty  = FALSE;
1183
1184   m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1185   if ( m_bImmutable )
1186     m_strName.erase(0, 1);  // remove first character
1187 }
1188
1189 // ----------------------------------------------------------------------------
1190 // set value
1191 // ----------------------------------------------------------------------------
1192
1193 void ConfigEntry::SetLine(LineList *pLine)
1194 {
1195   if ( m_pLine != NULL ) {
1196     wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1197                  Name().c_str(), m_pParent->GetFullName().c_str());
1198   }
1199
1200   m_pLine = pLine;
1201   Group()->SetLastEntry(this);
1202 }
1203
1204 // second parameter is FALSE if we read the value from file and prevents the
1205 // entry from being marked as 'dirty'
1206 void ConfigEntry::SetValue(const wxString& strValue, bool bUser)
1207 {
1208   if ( bUser && IsImmutable() ) {
1209     wxLogWarning(_("attempt to change immutable key '%s' ignored."),
1210                  Name().c_str());
1211     return;
1212   }
1213
1214   // do nothing if it's the same value
1215   if ( strValue == m_strValue )
1216     return;
1217
1218   m_strValue = strValue;
1219
1220   if ( bUser ) {
1221     wxString strVal = FilterOut(strValue);
1222     wxString strLine;
1223     strLine << m_strName << " = " << strVal;
1224
1225     if ( m_pLine != NULL ) {
1226       // entry was read from the local config file, just modify the line
1227       m_pLine->SetText(strLine);
1228     }
1229     else {
1230       // add a new line to the file
1231       wxASSERT( m_nLine == wxNOT_FOUND );   // consistency check
1232
1233       m_pLine = Group()->Config()->LineListInsert(strLine,
1234                                                   Group()->GetLastEntryLine());
1235       Group()->SetLastEntry(this);
1236     }
1237
1238     SetDirty();
1239   }
1240 }
1241
1242 void ConfigEntry::SetDirty()
1243 {
1244   m_bDirty = TRUE;
1245   Group()->SetDirty();
1246 }
1247
1248 // ============================================================================
1249 // global functions
1250 // ============================================================================
1251
1252 // ----------------------------------------------------------------------------
1253 // compare functions for array sorting
1254 // ----------------------------------------------------------------------------
1255
1256 int CompareEntries(ConfigEntry *p1,
1257                    ConfigEntry *p2)
1258 {
1259   #if wxCONFIG_CASE_SENSITIVE
1260     return strcmp(p1->Name(), p2->Name());
1261   #else
1262     return Stricmp(p1->Name(), p2->Name());
1263   #endif
1264 }
1265
1266 int CompareGroups(ConfigGroup *p1,
1267                   ConfigGroup *p2)
1268 {
1269   #if wxCONFIG_CASE_SENSITIVE
1270     return strcmp(p1->Name(), p2->Name());
1271   #else
1272     return Stricmp(p1->Name(), p2->Name());
1273   #endif
1274 }
1275
1276 // ----------------------------------------------------------------------------
1277 // filter functions
1278 // ----------------------------------------------------------------------------
1279
1280 // undo FilterOut
1281 wxString FilterIn(const wxString& str)
1282 {
1283   wxString strResult;
1284   strResult.Alloc(str.Len());
1285
1286   bool bQuoted = !str.IsEmpty() && str[0] == '"';
1287
1288   for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1289     if ( str[n] == '\\' ) {
1290       switch ( str[++n] ) {
1291         case 'n':
1292           strResult += '\n';
1293           break;
1294
1295         case 'r':
1296           strResult += '\r';
1297           break;
1298
1299         case 't':
1300           strResult += '\t';
1301           break;
1302
1303         case '\\':
1304           strResult += '\\';
1305           break;
1306
1307         case '"':
1308           strResult += '"';
1309           break;
1310       }
1311     }
1312     else {
1313       if ( str[n] != '"' || !bQuoted )
1314         strResult += str[n];
1315       else if ( n != str.Len() - 1 ) {
1316         wxLogWarning(_("unexpected \" at position %d in '%s'."),
1317                      n, str.c_str());
1318       }
1319       //else: it's the last quote of a quoted string, ok
1320     }
1321   }
1322
1323   return strResult;
1324 }
1325
1326 // quote the string before writing it to file
1327 wxString FilterOut(const wxString& str)
1328 {
1329    if(str.IsEmpty())
1330       return str;
1331
1332   wxString strResult;
1333   strResult.Alloc(str.Len());
1334
1335   // quoting is necessary to preserve spaces in the beginning of the string
1336   bool bQuote = isspace(str[0]) || str[0] == '"';
1337
1338   if ( bQuote )
1339     strResult += '"';
1340
1341   char c;
1342   for ( size_t n = 0; n < str.Len(); n++ ) {
1343     switch ( str[n] ) {
1344       case '\n':
1345         c = 'n';
1346         break;
1347
1348       case '\r':
1349         c = 'r';
1350         break;
1351
1352       case '\t':
1353         c = 't';
1354         break;
1355
1356       case '\\':
1357         c = '\\';
1358         break;
1359
1360       case '"':
1361         if ( bQuote ) {
1362           c = '"';
1363           break;
1364         }
1365         //else: fall through
1366
1367       default:
1368         strResult += str[n];
1369         continue;   // nothing special to do
1370     }
1371
1372     // we get here only for special characters
1373     strResult << '\\' << c;
1374   }
1375
1376   if ( bQuote )
1377     strResult += '"';
1378
1379   return strResult;
1380 }
1381
1382
1383
1384
1385
1386
1387