nel/src/misc/config_file/config_file.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "../stdmisc.h"
  18 #include "nel/misc/config_file.h"
  19
  20 #include <ctime>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23
  24 #include "nel/misc/file.h"
  25 #include "nel/misc/debug.h"
  26 #include "nel/misc/path.h"
  27 #include "nel/misc/i18n.h"
  28 #include "nel/misc/mem_stream.h"
  29 #include "locale.h"
  30
  31 #ifdef DEBUG_NEW
  32         #define new DEBUG_NEW
  33 #endif
  34
  35 using namespace std;
  36 using namespace NLMISC;
  37
  38 extern void cfrestart (FILE *); // used to reinit the file
  39 extern int cfparse (void *);    // used to parse the file
  40 //extern FILE *cfin;
  41 extern int cf_CurrentLine;
  42 extern char *cf_CurrentFile;
  43 extern bool cf_Ignore;
  44 extern bool cf_OverwriteExistingVariable;
  45 extern CMemStream cf_ifile;
  46
  47 // put true if you want that the config file class check type when you call asFunctions
  48 // (for example, check when you call asInt() that the variable is an int).
  49 // when it's false, the function will convert to the wanted type (if he can)
  50 const bool CheckType = false;
  51 bool LoadRoot = false;
  52
  53 namespace NLMISC
  54 {
  55
  56 const char *CConfigFile::CVar::TypeName[] = { "Integer", "String", "Float", "Boolean" };
  57
  58 int CConfigFile::CVar::asInt (int index) const
  59 {
  60         if (CheckType && Type != T_INT) throw EBadType (Name, Type, T_INT);
  61         switch (Type)
  62         {
  63         case T_STRING:
  64         {
  65                 if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, (int)StrValues.size (), index);
  66                 int ret = 0;
  67                 NLMISC::fromString(StrValues[index], ret);
  68                 return ret;
  69         }
  70         case T_REAL:
  71                 if (index >= (int)RealValues.size () || index < 0) throw EBadSize (Name, (int)RealValues.size (), index);
  72                 return (int)RealValues[index];
  73         default:
  74                 if (index >= (int)IntValues.size () || index < 0) throw EBadSize (Name, (int)IntValues.size (), index);
  75                 return IntValues[index];
  76         }
  77 }
  78
  79 double CConfigFile::CVar::asDouble (int index) const
  80 {
  81         if (CheckType && Type != T_REAL) throw EBadType (Name, Type, T_REAL);
  82         switch (Type)
  83         {
  84         case T_INT:
  85                 if (index >= (int)IntValues.size () || index < 0) throw EBadSize (Name, (int)IntValues.size (), index);
  86                 return (double)IntValues[index];
  87         case T_STRING:
  88         {
  89                 if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, (int)StrValues.size (), index);
  90                 double val;
  91                 NLMISC::fromString(StrValues[index], val);
  92                 return val;
  93         }
  94         default:
  95                 if (index >= (int)RealValues.size () || index < 0) throw EBadSize (Name, (int)RealValues.size (), index);
  96                 return RealValues[index];
  97         }
  98 }
  99
 100 float CConfigFile::CVar::asFloat (int index) const
 101 {
 102         return (float) asDouble (index);
 103 }
 104
 105 std::string CConfigFile::CVar::asString (int index) const
 106 {
 107         if (CheckType && Type != T_STRING) throw EBadType (Name, Type, T_STRING);
 108         switch (Type)
 109         {
 110         case T_INT:
 111                 if (index >= (int)IntValues.size () || index < 0) throw EBadSize (Name, (int)IntValues.size (), index);
 112                 return toString(IntValues[index]);
 113         case T_REAL:
 114                 if (index >= (int)RealValues.size () || index < 0) throw EBadSize (Name, (int)RealValues.size (), index);
 115                 return toString(RealValues[index]);
 116         default:
 117                 if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, (int)StrValues.size (), index);
 118                 return StrValues[index];
 119         }
 120 }
 121
 122 bool CConfigFile::CVar::asBool (int index) const
 123 {
 124         switch (Type)
 125         {
 126         case T_STRING:
 127                 if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, (int)StrValues.size (), index);
 128                 if(StrValues[index] == "true")
 129                 {
 130                         return true;
 131                 }
 132                 else
 133                 {
 134                         return false;
 135                 }
 136         case T_REAL:
 137                 if (index >= (int)RealValues.size () || index < 0) throw EBadSize (Name, (int)RealValues.size (), index);
 138                 if ((int)RealValues[index] == 1)
 139                 {
 140                         return true;
 141                 }
 142                 else
 143                 {
 144                         return false;
 145                 }
 146         default:
 147                 if (index >= (int)IntValues.size () || index < 0) throw EBadSize (Name, (int)IntValues.size (), index);
 148                 if (IntValues[index] == 1)
 149                 {
 150                         return true;
 151                 }
 152                 else
 153                 {
 154                         return false;
 155                 }
 156         }
 157 }
 158
 159 void CConfigFile::CVar::setAsInt (int val, int index)
 160 {
 161         if (Type != T_INT) throw EBadType (Name, Type, T_INT);
 162         else if (index > (int)IntValues.size () || index < 0) throw EBadSize (Name, (int)IntValues.size (), index);
 163         else if (index == (int)IntValues.size ()) IntValues.push_back(val);
 164         else IntValues[index] = val;
 165         Root = false;
 166 }
 167
 168 void CConfigFile::CVar::setAsDouble (double val, int index)
 169 {
 170         if (Type != T_REAL) throw EBadType (Name, Type, T_REAL);
 171         else if (index > (int)RealValues.size () || index < 0) throw EBadSize (Name, (int)RealValues.size (), index);
 172         else if (index == (int)RealValues.size ()) RealValues.push_back(val);
 173         else RealValues[index] = val;
 174         Root = false;
 175 }
 176
 177 void CConfigFile::CVar::setAsFloat (float val, int index)
 178 {
 179         setAsDouble (val, index);
 180 }
 181
 182 void CConfigFile::CVar::setAsString (const std::string &val, int index)
 183 {
 184         if (Type != T_STRING) throw EBadType (Name, Type, T_STRING);
 185         else if (index > (int)StrValues.size () || index < 0) throw EBadSize (Name, (int)StrValues.size (), index);
 186         else if (index == (int)StrValues.size ()) StrValues.push_back(val);
 187         else StrValues[index] = val;
 188         Root = false;
 189 }
 190
 191 void CConfigFile::CVar::forceAsInt      (int val)
 192 {
 193         Type= T_INT;
 194         IntValues.resize(1);
 195         RealValues.clear();
 196         StrValues.clear();
 197         IntValues[0]= val;
 198         Root = false;
 199 }
 200
 201 void CConfigFile::CVar::forceAsDouble   (double val)
 202 {
 203         Type= T_REAL;
 204         IntValues.clear();
 205         RealValues.resize(1);
 206         StrValues.clear();
 207         RealValues[0]= val;
 208         Root = false;
 209 }
 210
 211 void CConfigFile::CVar::forceAsString   (const std::string &val)
 212 {
 213         Type= T_STRING;
 214         IntValues.clear();
 215         RealValues.clear();
 216         StrValues.resize(1);
 217         StrValues[0]= val;
 218         Root = false;
 219 }
 220
 221 void CConfigFile::CVar::setAsInt (const std::vector<int> &vals)
 222 {
 223         if (Type != T_INT) throw EBadType (Name, Type, T_INT);
 224         else IntValues = vals;
 225         Root = false;
 226 }
 227
 228 void CConfigFile::CVar::setAsDouble (const std::vector<double> &vals)
 229 {
 230         if (Type != T_REAL) throw EBadType (Name, Type, T_REAL);
 231         else RealValues = vals;
 232         Root = false;
 233 }
 234
 235 void CConfigFile::CVar::setAsFloat (const std::vector<float> &vals)
 236 {
 237         if (Type != T_REAL) throw EBadType (Name, Type, T_REAL);
 238         else
 239         {
 240                 RealValues.clear ();
 241                 RealValues.resize (vals.size ());
 242                 for (uint i = 0; i < vals.size (); i++)
 243                         RealValues[i] = (double)vals[i];
 244         }
 245         Root = false;
 246 }
 247
 248 void CConfigFile::CVar::setAsString (const std::vector<std::string> &vals)
 249 {
 250         if (Type != T_STRING) throw EBadType (Name, Type, T_STRING);
 251         else StrValues = vals;
 252         Root = false;
 253 }
 254
 255 bool CConfigFile::CVar::operator==      (const CVar& var) const
 256 {
 257         if (Type == var.Type)
 258         {
 259                 switch (Type)
 260                 {
 261                 case T_INT: return IntValues == var.IntValues; break;
 262                 case T_REAL: return RealValues == var.RealValues; break;
 263                 case T_STRING: return StrValues == var.StrValues; break;
 264                 default: break;
 265                 }
 266         }
 267         return false;
 268 }
 269
 270 bool CConfigFile::CVar::operator!=      (const CVar& var) const
 271 {
 272         return !(*this==var);
 273 }
 274
 275 void CConfigFile::CVar::add (const CVar &var)
 276 {
 277         if (Type == var.Type)
 278         {
 279                 switch (Type)
 280                 {
 281                 case T_INT: IntValues.insert (IntValues.end(), var.IntValues.begin(), var.IntValues.end()); break;
 282                 case T_REAL: RealValues.insert (RealValues.end(), var.RealValues.begin(), var.RealValues.end()); break;
 283                 case T_STRING: StrValues.insert (StrValues.end(), var.StrValues.begin(), var.StrValues.end()); break;
 284                 default: break;
 285                 }
 286         }
 287 }
 288
 289 uint CConfigFile::CVar::size () const
 290 {
 291         switch (Type)
 292         {
 293         case T_INT: return (uint)IntValues.size ();
 294         case T_REAL: return (uint)RealValues.size ();
 295         case T_STRING: return (uint)StrValues.size ();
 296         default: return 0;
 297         }
 298 }
 299
 300 CConfigFile::~CConfigFile ()
 301 {
 302         if (_ConfigFiles == NULL || (*_ConfigFiles).empty ()) return;
 303
 304         vector<CConfigFile *>::iterator it = find ((*_ConfigFiles).begin (), (*_ConfigFiles).end (), this);
 305         if (it != (*_ConfigFiles).end ())
 306         {
 307                 (*_ConfigFiles).erase (it);
 308         }
 309
 310         if ((*_ConfigFiles).empty())
 311         {
 312                 delete _ConfigFiles;
 313                 _ConfigFiles = NULL;
 314         }
 315 }
 316
 317 void CConfigFile::load (const string &fileName, bool lookupPaths )
 318 {
 319         char *locale = setlocale(LC_NUMERIC, NULL);
 320
 321         if (!locale || strcmp(locale, "C"))
 322         {
 323                 nlerror("Numeric locale not defined to C, an external library possibly redefined it!");
 324         }
 325
 326         if(fileName.empty())
 327         {
 328                 nlwarning ("CF: Can't load a empty file name configfile");
 329                 return;
 330         }
 331
 332         FileNames.clear ();
 333         FileNames.push_back (fileName);
 334
 335         if (_ConfigFiles == NULL)
 336         {
 337                 _ConfigFiles = new std::vector<CConfigFile *>;
 338         }
 339         (*CConfigFile::_ConfigFiles).push_back (this);
 340         reparse (lookupPaths);
 341
 342 /*      _FileName.clear ();
 343         _FileName.push_back (fileName);
 344
 345         if (_ConfigFiles == NULL)
 346         {
 347                 _ConfigFiles = new std::vector<CConfigFile *>;
 348         }
 349         (*CConfigFile::_ConfigFiles).push_back (this);
 350         reparse ();
 351
 352         // If we find a linked config file, load it but don't overload already existing variable
 353         CVar *var = getVarPtr ("RootConfigFilename");
 354         if (var)
 355         {
 356                 string RootConfigFilename = var->asString();
 357                 nlinfo ("RootConfigFilename variable found in the '%s' config file, parse it (%s)", fileName.c_str(), RootConfigFilename.c_str());
 358
 359                 string path = CFile::getPath(fileName);
 360
 361                 if (!path.empty())
 362                         path +=  "/";
 363
 364                 path += RootConfigFilename;
 365
 366                 reparse (path.c_str());
 367         }
 368 */
 369 //      print ();
 370 }
 371
 372 bool CConfigFile::loaded()
 373 {
 374         return !CConfigFile::FileNames.empty();
 375 }
 376
 377 uint32 CConfigFile::getVarCount()
 378 {
 379         return (uint32)_Vars.size();
 380 }
 381
 382
 383 void CConfigFile::reparse (bool lookupPaths)
 384 {
 385         if (FileNames.empty())
 386         {
 387                 nlwarning ("CF: Can't reparse config file because file name is empty");
 388                 return;
 389         }
 390
 391         string fn = FileNames[0];
 392
 393         FileNames.clear ();
 394         LastModified.clear ();
 395
 396 //      clearVars ();
 397
 398         while (!fn.empty())
 399         {
 400                 if (lookupPaths)
 401                 {
 402                         fn = CPath::lookup(fn, true);
 403                 }
 404                 else
 405                 {
 406                         fn = NLMISC::CPath::getFullPath(fn, false);
 407                 }
 408                 nldebug ("CF: Adding config file '%s' in the config file", fn.c_str());
 409                 FileNames.push_back (fn);
 410                 LastModified.push_back (CFile::getFileModificationDate(fn));
 411
 412                 if (!CPath::lookup(fn, false).empty())
 413                 {
 414                         ucstring content;
 415                         CI18N::readTextFile(fn, content, true, true);
 416                         string utf8 = content.toUtf8();
 417
 418                         CMemStream stream;
 419                         stream.serialBuffer((uint8*)(utf8.data()), (uint)utf8.size());
 420                         cf_ifile = stream;
 421                         if (!cf_ifile.isReading())
 422                         {
 423                                 cf_ifile.invert();
 424                         }
 425
 426                         cfrestart (NULL);
 427                         cf_CurrentLine = 0;
 428                         cf_CurrentFile = NULL;
 429                         cf_Ignore = false;
 430                         cf_OverwriteExistingVariable = (FileNames.size()==1);
 431                         LoadRoot = (FileNames.size()>1);
 432                         bool parsingOK = (cfparse (&(_Vars)) == 0);
 433 //                      cf_ifile.close();
 434                         if (!parsingOK)
 435                         {
 436                                 // write the result of preprocessing in a temp file
 437                                 string debugFileName;
 438                                 debugFileName += "debug_";
 439                                 debugFileName += CFile::getFilename(fn);
 440
 441                                 CI18N::writeTextFile(debugFileName, content, true);
 442                                 nlwarning ("CF: Parsing error in file %s line %d, look in '%s' for a preprocessed version of the config file",
 443                                         cf_CurrentFile,
 444                                         cf_CurrentLine,
 445                                         debugFileName.c_str());
 446                                 throw EParseError (fn, cf_CurrentLine);
 447                         }
 448
 449                         if (cf_CurrentFile != NULL)
 450                                 free(cf_CurrentFile);
 451
 452                         // reset all 'FromLocalFile' flag on created vars before reading next root cfg
 453                         for (uint i=0; i<_Vars.size(); ++i)
 454                         {
 455                                 _Vars[i].FromLocalFile = false;
 456                         }
 457                 }
 458                 else
 459                 {
 460                         nlwarning ("CF: Config file '%s' not found in the path '%s'", fn.c_str(), CPath::getCurrentPath().c_str());
 461                         throw EFileNotFound (fn);
 462                 }
 463 //              cf_ifile.close ();
 464                 cf_ifile.clear();
 465
 466                 // If we find a linked config file, load it but don't overload already existing variable
 467                 CVar *var = getVarPtr ("RootConfigFilename");
 468                 if (var)
 469                 {
 470                         string RootConfigFilename = var->asString();
 471
 472                         if (!NLMISC::CFile::fileExists(RootConfigFilename))
 473                         {
 474                                 // file is not found, try with the path of the master cfg
 475                                 string path = NLMISC::CPath::standardizePath (NLMISC::CFile::getPath(FileNames[0]));
 476                                 RootConfigFilename = path + RootConfigFilename;
 477                         }
 478
 479                         RootConfigFilename = NLMISC::CPath::getFullPath(RootConfigFilename, false);
 480
 481                         if (RootConfigFilename != fn)
 482                         {
 483                                 nlinfo ("CF: RootConfigFilename variable found in the '%s' config file, parse the root config file '%s'", fn.c_str(), RootConfigFilename.c_str());
 484                                 fn = RootConfigFilename;
 485                         }
 486                         else
 487                                 fn.clear ();
 488                 }
 489                 else
 490                         fn.clear ();
 491         }
 492
 493         if (_Callback != NULL)
 494                 _Callback();
 495
 496 /*      if (filename == NULL)
 497         {
 498                 _LastModified = getLastModified ();
 499
 500                 nlassert (!_FileName.empty());
 501
 502                 if (cf_ifile.open (_FileName[0]))
 503                 {
 504                         // if we clear all the array, we'll lost the callback on variable and all information
 505                         //              _Vars.clear();
 506                         cfrestart (NULL);
 507                         cf_CurrentLine = 1;
 508                         cf_Ignore = false;
 509                         cf_OverwriteExistingVariable = true;
 510                         LoadRoot = false;
 511                         bool parsingOK = (cfparse (&(_Vars)) == 0);
 512                         cf_ifile.close();
 513                         if (!parsingOK)
 514                         {
 515                                 nlwarning ("Parsing error in file %s line %d", _FileName.c_str(), cf_CurrentLine);
 516                                 throw EParseError (_FileName, cf_CurrentLine);
 517                         }
 518                 }
 519                 else
 520                 {
 521                         nlwarning ("ConfigFile '%s' not found in the path '%s'", _FileName.c_str(), CPath::getCurrentPath().c_str());
 522                         throw EFileNotFound (_FileName);
 523                 }
 524         }
 525         else
 526         {
 527                 nlassert (strlen(filename)>0);
 528
 529                 // load external config filename, don't overwrite existing variable
 530                 if (cf_ifile.open (filename))
 531                 {
 532                         cfrestart (NULL);
 533                         cf_CurrentLine = 1;
 534                         cf_Ignore = false;
 535                         cf_OverwriteExistingVariable = false;
 536                         LoadRoot = true;
 537                         bool parsingOK = (cfparse (&(_Vars)) == 0);
 538                         cf_ifile.close ();
 539                         if (!parsingOK)
 540                         {
 541                                 nlwarning ("Parsing error in file %s line %d", filename, cf_CurrentLine);
 542                                 throw EParseError (filename, cf_CurrentLine);
 543                         }
 544                 }
 545                 else
 546                 {
 547                         nlwarning ("RootConfigFilename '%s' not found", _FileName.c_str());
 548                 }
 549         }
 550
 551         if (callingCallback)
 552         {
 553                 if (_Callback != NULL)
 554                         _Callback();
 555         }
 556 */
 557
 558 }
 559
 560
 561
 562 CConfigFile::CVar &CConfigFile::getVar (const std::string &varName)
 563 {
 564         CVar *var =  getVarPtr (varName);
 565         if (var == 0)
 566                 throw EUnknownVar (getFilename(), varName);
 567         else
 568                 return *var;
 569 }
 570
 571
 572 CConfigFile::CVar *CConfigFile::getVarPtr (const std::string &varName)
 573 {
 574         uint i;
 575         for (i = 0; i < _Vars.size(); i++)
 576         {
 577                 // the type could be T_UNKNOWN if we add a callback on this name but this var is not in the config file
 578                 if (_Vars[i].Name == varName && (_Vars[i].Type != CVar::T_UNKNOWN || _Vars[i].Comp))
 579                         return &(_Vars[i]);
 580         }
 581
 582         // if not found, add it in the array if necessary
 583         for (i = 0; i < UnknownVariables.size(); i++)
 584                 if(UnknownVariables[i] == varName)
 585                         break;
 586         if (i == UnknownVariables.size())
 587                 UnknownVariables.push_back(varName);
 588
 589         return NULL;
 590 }
 591
 592 bool CConfigFile::exists (const std::string &varName)
 593 {
 594         for (uint i = 0; i < _Vars.size(); i++)
 595         {
 596                 // the type could be T_UNKNOWN if we add a callback on this name but this var is not in the config file
 597                 if (_Vars[i].Name == varName && (_Vars[i].Type != CVar::T_UNKNOWN || _Vars[i].Comp))
 598                 {
 599                         return true;
 600                 }
 601         }
 602         return false;
 603 }
 604
 605 void CConfigFile::save () const
 606 {
 607         char *locale = setlocale(LC_NUMERIC, NULL);
 608
 609         if (!locale || strcmp(locale, "C"))
 610         {
 611                 nlerror("Numeric locale not defined to C, an external library possibly redefined it!");
 612         }
 613
 614         FILE *fp = nlfopen (getFilename(), "w");
 615         if (fp == NULL)
 616         {
 617                 nlwarning ("CF: Couldn't create %s file", getFilename().c_str ());
 618                 return;
 619         }
 620
 621         // write the UTF-8 bom in order to be able to re-read a config file with
 622         // unicode content.
 623         /* ace: we need to test this before commit it
 624         static char utf8Header[] = {char(0xef), char(0xbb), char(0xbf), 0};
 625         fprintf(fp, utf8Header);
 626         */
 627
 628         for(int i = 0; i < (int)_Vars.size(); i++)
 629         {
 630                 // Not a root value
 631                 if (!_Vars[i].Root)
 632                 {
 633                         if (_Vars[i].Comp)
 634                         {
 635                                 fprintf(fp, "%-20s = {", _Vars[i].Name.c_str());
 636                                 switch (_Vars[i].Type)
 637                                 {
 638                                 case CConfigFile::CVar::T_INT:
 639                                 {
 640                                         for (int it=0; it < (int)_Vars[i].IntValues.size(); it++)
 641                                         {
 642                                                 if (it%_Vars[i].SaveWrap == 0)
 643                                                 {
 644                                                         fprintf(fp, "\n\t");
 645                                                 }
 646                                                 fprintf(fp, "%d%s", _Vars[i].IntValues[it], it<(int)_Vars[i].IntValues.size()-1?", ":" ");
 647                                         }
 648                                         break;
 649                                 }
 650                                 case CConfigFile::CVar::T_STRING:
 651                                 {
 652                                         for (int st=0; st < (int)_Vars[i].StrValues.size(); st++)
 653                                         {
 654                                                 if (st%_Vars[i].SaveWrap == 0)
 655                                                 {
 656                                                         fprintf(fp, "\n\t");
 657                                                 }
 658                                                 fprintf(fp, "\"%s\"%s", _Vars[i].StrValues[st].c_str(), st<(int)_Vars[i].StrValues.size()-1?", ":" ");
 659                                         }
 660                                         break;
 661                                 }
 662                                 case CConfigFile::CVar::T_REAL:
 663                                 {
 664                                         for (int rt=0; rt < (int)_Vars[i].RealValues.size(); rt++)
 665                                         {
 666                                                 if (rt%_Vars[i].SaveWrap == 0)
 667                                                 {
 668                                                         fprintf(fp, "\n\t");
 669                                                 }
 670                                                 fprintf(fp, "%.10f%s", _Vars[i].RealValues[rt], rt<(int)_Vars[i].RealValues.size()-1?", ":" ");
 671                                         }
 672                                         break;
 673                                 }
 674                                 default: break;
 675                                 }
 676                                 fprintf(fp, "\n};\n");
 677                         }
 678                         else
 679                         {
 680                                 switch (_Vars[i].Type)
 681                                 {
 682                                 case CConfigFile::CVar::T_INT:
 683                                         fprintf(fp, "%-20s = %d;\n", _Vars[i].Name.c_str(), _Vars[i].IntValues[0]);
 684                                         break;
 685                                 case CConfigFile::CVar::T_STRING:
 686                                         fprintf(fp, "%-20s = \"%s\";\n", _Vars[i].Name.c_str(), _Vars[i].StrValues[0].c_str());
 687                                         break;
 688                                 case CConfigFile::CVar::T_REAL:
 689                                         fprintf(fp, "%-20s = %.10f;\n", _Vars[i].Name.c_str(), _Vars[i].RealValues[0]);
 690                                         break;
 691                                 default: break;
 692                                 }
 693                         }
 694                 }
 695         }
 696         fclose (fp);
 697 }
 698
 699 void CConfigFile::display () const
 700 {
 701         display (InfoLog);
 702 }
 703
 704 void CConfigFile::display (CLog *log) const
 705 {
 706         createDebug ();
 707
 708         log->displayRawNL ("Config file %s have %d variables and %d root config file:", getFilename().c_str(), _Vars.size(), FileNames.size()-1);
 709         log->displayRaw ("Root config files: ");
 710         for(int i = 1; i < (int)FileNames.size(); i++)
 711         {
 712                 log->displayRaw (FileNames[i].c_str());
 713         }
 714         log->displayRawNL ("");
 715         log->displayRawNL ("------------------------------------------------------");
 716         for(int i = 0; i < (int)_Vars.size(); i++)
 717         {
 718                 log->displayRaw ((_Vars[i].Callback==NULL)?"   ":"CB ");
 719                 log->displayRaw ((_Vars[i].Root)?"Root ":"     ");
 720                 if (_Vars[i].Comp)
 721                 {
 722                         switch (_Vars[i].Type)
 723                         {
 724                         case CConfigFile::CVar::T_INT:
 725                         {
 726                                 log->displayRaw ("%-20s { ", _Vars[i].Name.c_str());
 727                                 for (int it=0; it < (int)_Vars[i].IntValues.size(); it++)
 728                                 {
 729                                         log->displayRaw ("'%d' ", _Vars[i].IntValues[it]);
 730                                 }
 731                                 log->displayRawNL ("}");
 732                                 break;
 733                         }
 734                         case CConfigFile::CVar::T_STRING:
 735                         {
 736                                 log->displayRaw ("%-20s { ", _Vars[i].Name.c_str());
 737                                 for (int st=0; st < (int)_Vars[i].StrValues.size(); st++)
 738                                 {
 739                                         log->displayRaw ("\"%s\" ", _Vars[i].StrValues[st].c_str());
 740                                 }
 741                                 log->displayRawNL ("}");
 742                                 break;
 743                         }
 744                         case CConfigFile::CVar::T_REAL:
 745                         {
 746                                 log->displayRaw ("%-20s { " , _Vars[i].Name.c_str());
 747                                 for (int rt=0; rt < (int)_Vars[i].RealValues.size(); rt++)
 748                                 {
 749                                         log->displayRaw ("`%f` ", _Vars[i].RealValues[rt]);
 750                                 }
 751                                 log->displayRawNL ("}");
 752                                 break;
 753                         }
 754                         case CConfigFile::CVar::T_UNKNOWN:
 755                         {
 756                                  log->displayRawNL ("%-20s { }" , _Vars[i].Name.c_str());
 757                                 break;
 758                         }
 759                         default:
 760                         {
 761                                 log->displayRawNL ("%-20s <default case comp> (%d)" , _Vars[i].Name.c_str(), _Vars[i].Type);
 762                                 break;
 763                         }
 764                         }
 765                 }
 766                 else
 767                 {
 768                         switch (_Vars[i].Type)
 769                         {
 770                         case CConfigFile::CVar::T_INT:
 771                                 log->displayRawNL ("%-20s '%d'", _Vars[i].Name.c_str(), _Vars[i].IntValues[0]);
 772                                 break;
 773                         case CConfigFile::CVar::T_STRING:
 774                                 log->displayRawNL ("%-20s \"%s\"", _Vars[i].Name.c_str(), _Vars[i].StrValues[0].c_str());
 775                                 break;
 776                         case CConfigFile::CVar::T_REAL:
 777                                 log->displayRawNL ("%-20s `%f`", _Vars[i].Name.c_str(), _Vars[i].RealValues[0]);
 778                                 break;
 779                         case CConfigFile::CVar::T_UNKNOWN:
 780                                 log->displayRawNL ("%-20s <Unknown>", _Vars[i].Name.c_str());
 781                                 break;
 782                         default:
 783                         {
 784                                 log->displayRawNL ("%-20s <default case> (%d)" , _Vars[i].Name.c_str(), _Vars[i].Type);
 785                                 break;
 786                         }
 787                         }
 788                 }
 789         }
 790 }
 791
 792 void CConfigFile::setCallback (void (*cb)())
 793 {
 794         _Callback = cb;
 795         if( !FileNames.empty() )
 796                 nlinfo ("CF: Setting callback to reload the file '%s' when modified externally", getFilename().c_str());
 797 }
 798
 799 void CConfigFile::setCallback (const string &VarName, void (*cb)(CConfigFile::CVar &var))
 800 {
 801         for (vector<CVar>::iterator it = _Vars.begin (); it != _Vars.end (); it++)
 802         {
 803                 if (VarName == (*it).Name)
 804                 {
 805                         (*it).Callback = cb;
 806                         //nldebug("CF: Setting callback to reload the variable '%s' in the file '%s' when modified externally", VarName.c_str(), getFilename().c_str());
 807                         return;
 808                 }
 809         }
 810         // VarName doesn't exist, add it now for the future
 811         CVar Var;
 812         Var.Name = VarName;
 813         Var.Callback = cb;
 814         Var.Type = CVar::T_UNKNOWN;
 815         Var.Comp = false;
 816         _Vars.push_back (Var);
 817         //nldebug("CF: Setting callback to reload the variable '%s' in the file '%s' when modified externally (currently unknown)", VarName.c_str(), getFilename().c_str());
 818 }
 819
 820 // ***************************************************************************
 821
 822
 823 vector<CConfigFile *> *CConfigFile::_ConfigFiles = NULL;
 824
 825 uint32  CConfigFile::_Timeout = 1000;
 826
 827 void CConfigFile::checkConfigFiles ()
 828 {
 829         if (_ConfigFiles == NULL) return;
 830
 831         static time_t LastCheckTime = time (NULL);
 832         if (_Timeout > 0 && (float)(time (NULL) - LastCheckTime)*1000.0f < (float)_Timeout) return;
 833
 834         LastCheckTime = time (NULL);
 835
 836         bool needReparse;
 837         for (vector<CConfigFile *>::iterator it = (*_ConfigFiles).begin (); it != (*_ConfigFiles).end (); it++)
 838         {
 839                 needReparse = false;
 840                 nlassert ((*it)->FileNames.size() == (*it)->LastModified.size());
 841                 for (uint i = 0; i < (*it)->FileNames.size(); i++)
 842                 {
 843                         if ((*it)->LastModified[i] != CFile::getFileModificationDate((*it)->FileNames[i]))
 844                         {
 845                                 needReparse = true;
 846                                 (*it)->LastModified[i] = CFile::getFileModificationDate((*it)->FileNames[i]);
 847                         }
 848                 }
 849                 if (needReparse)
 850                 {
 851                         try
 852                         {
 853                                 (*it)->reparse ();
 854                         }
 855                         catch (const EConfigFile &e)
 856                         {
 857                                 nlwarning ("CF: Exception will re-read modified config file '%s': %s", (*it)->getFilename().c_str(), e.what ());
 858                         }
 859                 }
 860         }
 861 }
 862
 863 void CConfigFile::setTimeout (uint32 timeout)
 864 {
 865         _Timeout = timeout;
 866 }
 867
 868 void CConfigFile::clear()
 869 {
 870         _Vars.clear ();
 871 }
 872
 873 void CConfigFile::clearVars ()
 874 {
 875         for (vector<CVar>::iterator it = _Vars.begin (); it != _Vars.end (); it++)
 876         {
 877                 (*it).Type = CVar::T_UNKNOWN;
 878         }
 879 }
 880
 881 uint CConfigFile::getNumVar () const
 882 {
 883         return (uint)_Vars.size ();
 884 }
 885
 886 CConfigFile::CVar *CConfigFile::getVar (uint varId)
 887 {
 888         return &(_Vars[varId]);
 889 }
 890
 891 CConfigFile::CVar *CConfigFile::insertVar (const std::string &varName, const CVar &varToCopy)
 892 {
 893         // Get the var
 894         CVar *var = getVarPtr (varName);
 895         if (!var)
 896         {
 897                 _Vars.push_back (varToCopy);
 898                 var = &(_Vars.back ());
 899                 var->Root = false;
 900                 var->Name = varName;
 901         }
 902         return var;
 903 }
 904
 905 } // NLMISC