Source/kwsys/Registry.cxx

   1 /*=========================================================================
   2
   3   Program:   KWSys - Kitware System Library
   4   Module:    $RCSfile: Registry.cxx,v $
   5
   6   Copyright (c) Kitware, Inc., Insight Consortium.  All rights reserved.
   7   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
   8
   9      This software is distributed WITHOUT ANY WARRANTY; without even
  10      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11      PURPOSE.  See the above copyright notices for more information.
  12
  13 =========================================================================*/
  14 #include "kwsysPrivate.h"
  15 #include KWSYS_HEADER(Registry.hxx)
  16
  17 #include KWSYS_HEADER(Configure.hxx)
  18 #include KWSYS_HEADER(ios/iostream)
  19 #include KWSYS_HEADER(stl/string)
  20 #include KWSYS_HEADER(stl/map)
  21 #include KWSYS_HEADER(ios/iostream)
  22 #include KWSYS_HEADER(ios/fstream)
  23 #include KWSYS_HEADER(ios/sstream)
  24 // Work-around CMake dependency scanning limitation.  This must
  25 // duplicate the above list of headers.
  26 #if 0
  27 # include "Registry.hxx.in"
  28 # include "Configure.hxx.in"
  29 # include "kwsys_stl.hxx.in"
  30 # include "kwsys_stl_string.hxx.in"
  31 # include "kwsys_stl_map.hxx.in"
  32 # include "kwsys_ios_iostream.h.in"
  33 # include "kwsys_ios_fstream.h.in"
  34 # include "kwsys_ios_sstream.h.in"
  35 #endif
  36
  37 #include <ctype.h> // for isspace
  38 #include <stdio.h>
  39 #include <string.h> /* strlen, strncpy */
  40 #include <stdlib.h> /* getenv */
  41
  42 #ifdef _WIN32
  43 # include <windows.h>
  44 #endif
  45
  46
  47 namespace KWSYS_NAMESPACE
  48 {
  49 class RegistryHelper {
  50 public:
  51   RegistryHelper(Registry::RegistryType registryType);
  52   virtual ~RegistryHelper();
  53
  54   // Read a value from the registry.
  55   virtual bool ReadValue(const char *key, const char **value);
  56
  57   // Delete a key from the registry.
  58   virtual bool DeleteKey(const char *key);
  59
  60   // Delete a value from a given key.
  61   virtual bool DeleteValue(const char *key);
  62
  63   // Set value in a given key.
  64   virtual bool SetValue(const char *key, const char *value);
  65
  66   // Open the registry at toplevel/subkey.
  67   virtual bool Open(const char *toplevel, const char *subkey,
  68     int readonly);
  69
  70   // Close the registry.
  71   virtual bool Close();
  72
  73   // Set the value of changed
  74   void SetChanged(bool b) { m_Changed = b; }
  75   void SetTopLevel(const char* tl);
  76   const char* GetTopLevel() { return m_TopLevel.c_str(); }
  77
  78   //! Read from local or global scope. On Windows this mean from local machine
  79   // or local user. On unix this will read from $HOME/.Projectrc or
  80   // /etc/Project
  81   void SetGlobalScope(bool b);
  82   bool GetGlobalScope();
  83
  84   kwsys_stl::string EncodeKey(const char* str);
  85   kwsys_stl::string EncodeValue(const char* str);
  86   kwsys_stl::string DecodeValue(const char* str);
  87
  88 protected:
  89   bool m_Changed;
  90   kwsys_stl::string m_TopLevel;
  91   bool m_GlobalScope;
  92
  93 #ifdef _WIN32
  94   HKEY HKey;
  95 #endif
  96   // Strip trailing and ending spaces.
  97   char *Strip(char *str);
  98   void SetSubKey(const char* sk);
  99   kwsys_stl::string CreateKey(const char *key);
 100
 101   typedef kwsys_stl::map<kwsys_stl::string, kwsys_stl::string> StringToStringMap;
 102   StringToStringMap EntriesMap;
 103   kwsys_stl::string m_SubKey;
 104   bool m_Empty;
 105   bool m_SubKeySpecified;
 106   kwsys_stl::string m_HomeDirectory;
 107
 108   Registry::RegistryType m_RegistryType;
 109 };
 110
 111 //----------------------------------------------------------------------------
 112 #define Registry_BUFFER_SIZE 8192
 113
 114 //----------------------------------------------------------------------------
 115 Registry::Registry(Registry::RegistryType registryType)
 116 {
 117   m_Opened      = false;
 118   m_Locked      = false;
 119   this->Helper = 0;
 120   this->Helper = new RegistryHelper(registryType);
 121 }
 122
 123 //----------------------------------------------------------------------------
 124 Registry::~Registry()
 125 {
 126   if ( m_Opened )
 127     {
 128     kwsys_ios::cerr << "Registry::Close should be "
 129                   "called here. The registry is not closed."
 130                   << kwsys_ios::endl;
 131     }
 132   delete this->Helper;
 133 }
 134
 135 //----------------------------------------------------------------------------
 136 void Registry::SetGlobalScope(bool b)
 137 {
 138   this->Helper->SetGlobalScope(b);
 139 }
 140
 141 //----------------------------------------------------------------------------
 142 bool Registry::GetGlobalScope()
 143 {
 144   return this->Helper->GetGlobalScope();
 145 }
 146
 147 //----------------------------------------------------------------------------
 148 bool Registry::Open(const char *toplevel,
 149   const char *subkey, int readonly)
 150 {
 151   bool res = false;
 152   if ( m_Locked )
 153     {
 154     return res;
 155     }
 156   if ( m_Opened )
 157     {
 158     if ( !this->Close() )
 159       {
 160       return res;
 161       }
 162     }
 163   if ( !toplevel || !*toplevel )
 164     {
 165     kwsys_ios::cerr << "Registry::Opened() Toplevel not defined"
 166       << kwsys_ios::endl;
 167     return res;
 168     }
 169
 170   if ( isspace(toplevel[0]) ||
 171        isspace(toplevel[strlen(toplevel)-1]) )
 172     {
 173     kwsys_ios::cerr << "Toplevel has to start with letter or number and end"
 174       " with one" << kwsys_ios::endl;
 175     return res;
 176     }
 177
 178   res = this->Helper->Open(toplevel, subkey, readonly);
 179   if ( readonly != Registry::READONLY )
 180     {
 181     m_Locked = true;
 182     }
 183
 184   if ( res )
 185     {
 186     m_Opened = true;
 187     this->Helper->SetTopLevel(toplevel);
 188     }
 189   return res;
 190 }
 191
 192 //----------------------------------------------------------------------------
 193 bool Registry::Close()
 194 {
 195   bool res = false;
 196   if ( m_Opened )
 197     {
 198     res = this->Helper->Close();
 199     }
 200
 201   if ( res )
 202     {
 203     m_Opened = false;
 204     m_Locked = false;
 205     this->Helper->SetChanged(false);
 206     }
 207   return res;
 208 }
 209
 210 //----------------------------------------------------------------------------
 211 bool Registry::ReadValue(const char *subkey,
 212   const char *key,
 213   const char **value)
 214 {
 215   bool res = false;
 216   bool open = false;
 217   if ( ! value )
 218     {
 219     return res;
 220     }
 221   *value = 0;
 222   if ( !m_Opened )
 223     {
 224     if ( !this->Open(this->GetTopLevel(), subkey,
 225         Registry::READONLY) )
 226       {
 227       return res;
 228       }
 229     open = true;
 230     }
 231   res = this->Helper->ReadValue(key, value);
 232
 233   if ( open )
 234     {
 235     if ( !this->Close() )
 236       {
 237       res = false;
 238       }
 239     }
 240   return res;
 241 }
 242
 243 //----------------------------------------------------------------------------
 244 bool Registry::DeleteKey(const char *subkey, const char *key)
 245 {
 246   bool res = false;
 247   bool open = false;
 248   if ( !m_Opened )
 249     {
 250     if ( !this->Open(this->GetTopLevel(), subkey,
 251         Registry::READWRITE) )
 252       {
 253       return res;
 254       }
 255     open = true;
 256     }
 257
 258   res = this->Helper->DeleteKey(key);
 259   if ( res )
 260     {
 261     this->Helper->SetChanged(true);
 262     }
 263
 264   if ( open )
 265     {
 266     if ( !this->Close() )
 267       {
 268       res = false;
 269       }
 270     }
 271   return res;
 272 }
 273
 274 //----------------------------------------------------------------------------
 275 bool Registry::DeleteValue(const char *subkey, const char *key)
 276 {
 277   bool res = false;
 278   bool open = false;
 279   if ( !m_Opened )
 280     {
 281     if ( !this->Open(this->GetTopLevel(), subkey,
 282         Registry::READWRITE) )
 283       {
 284       return res;
 285       }
 286     open = true;
 287     }
 288
 289   res = this->Helper->DeleteValue(key);
 290   if ( res )
 291     {
 292     this->Helper->SetChanged(true);
 293     }
 294
 295   if ( open )
 296     {
 297     if ( !this->Close() )
 298       {
 299       res = false;
 300       }
 301     }
 302   return res;
 303 }
 304
 305 //----------------------------------------------------------------------------
 306 bool Registry::SetValue(const char *subkey, const char *key,
 307   const char *value)
 308 {
 309   bool res = false;
 310   bool open = false;
 311   if ( !m_Opened )
 312     {
 313     if ( !this->Open(this->GetTopLevel(), subkey,
 314         Registry::READWRITE) )
 315       {
 316       return res;
 317       }
 318     open = true;
 319     }
 320
 321   res = this->Helper->SetValue( key, value );
 322   if ( res )
 323     {
 324     this->Helper->SetChanged(true);
 325     }
 326
 327   if ( open )
 328     {
 329     if ( !this->Close() )
 330       {
 331       res = false;
 332       }
 333     }
 334   return res;
 335 }
 336
 337 //----------------------------------------------------------------------------
 338 const char* Registry::GetTopLevel()
 339 {
 340   return this->Helper->GetTopLevel();
 341 }
 342
 343 //----------------------------------------------------------------------------
 344 void Registry::SetTopLevel(const char* tl)
 345 {
 346   this->Helper->SetTopLevel(tl);
 347 }
 348
 349 //----------------------------------------------------------------------------
 350 void RegistryHelper::SetTopLevel(const char* tl)
 351 {
 352   if ( tl )
 353     {
 354     m_TopLevel = tl;
 355     }
 356   else
 357     {
 358     m_TopLevel = "";
 359     }
 360 }
 361
 362 //----------------------------------------------------------------------------
 363 RegistryHelper::RegistryHelper(Registry::RegistryType registryType)
 364 {
 365   m_Changed = false;
 366   m_TopLevel    = "";
 367   m_SubKey  = "";
 368   m_SubKeySpecified = false;
 369   m_Empty       = true;
 370   m_GlobalScope = false;
 371   m_RegistryType = registryType;
 372 }
 373
 374 //----------------------------------------------------------------------------
 375 RegistryHelper::~RegistryHelper()
 376 {
 377 }
 378
 379
 380 //----------------------------------------------------------------------------
 381 bool RegistryHelper::Open(const char *toplevel, const char *subkey,
 382   int readonly)
 383 {
 384   this->EntriesMap.clear();
 385   m_Empty = 1;
 386
 387 #ifdef _WIN32
 388   if ( m_RegistryType == Registry::WIN32_REGISTRY)
 389     {
 390     HKEY scope = HKEY_CURRENT_USER;
 391     if ( this->GetGlobalScope() )
 392       {
 393       scope = HKEY_LOCAL_MACHINE;
 394       }
 395     int res = 0;
 396     kwsys_ios::ostringstream str;
 397     DWORD dwDummy;
 398     str << "Software\\Kitware\\" << toplevel << "\\" << subkey;
 399     if ( readonly == Registry::READONLY )
 400       {
 401       res = ( RegOpenKeyEx(scope, str.str().c_str(),
 402           0, KEY_READ, &this->HKey) == ERROR_SUCCESS );
 403       }
 404     else
 405       {
 406       res = ( RegCreateKeyEx(scope, str.str().c_str(),
 407           0, "", REG_OPTION_NON_VOLATILE, KEY_READ|KEY_WRITE,
 408           NULL, &this->HKey, &dwDummy) == ERROR_SUCCESS );
 409       }
 410     if ( res != 0 )
 411       {
 412       this->SetSubKey( subkey );
 413       }
 414     return (res != 0);
 415     }
 416 #endif
 417   if ( m_RegistryType == Registry::FILE_REGISTRY )
 418     {
 419     bool res = false;
 420     int cc;
 421     kwsys_ios::ostringstream str;
 422     const char* homeDirectory;
 423     if ( (homeDirectory = getenv("HOME")) == 0 )
 424       {
 425       if ( (homeDirectory = getenv("USERPROFILE")) == 0 )
 426         {
 427         return false;
 428         }
 429       }
 430     m_HomeDirectory = homeDirectory;
 431     str << m_HomeDirectory.c_str() << "/." << toplevel << "rc";
 432     if ( readonly == Registry::READWRITE )
 433       {
 434       kwsys_ios::ofstream ofs( str.str().c_str(), kwsys_ios::ios::out|kwsys_ios::ios::app );
 435       if ( ofs.fail() )
 436         {
 437         return false;
 438         }
 439       ofs.close();
 440       }
 441
 442     kwsys_ios::ifstream *ifs = new kwsys_ios::ifstream(str.str().c_str(), kwsys_ios::ios::in
 443 #ifndef KWSYS_IOS_USE_ANSI
 444       | kwsys_ios::ios::nocreate
 445 #endif
 446       );
 447     if ( !ifs )
 448       {
 449       return false;
 450       }
 451     if ( ifs->fail())
 452       {
 453       delete ifs;
 454       return false;
 455       }
 456
 457     res = true;
 458     char buffer[Registry_BUFFER_SIZE];
 459     while( !ifs->fail() )
 460       {
 461       ifs->getline(buffer, Registry_BUFFER_SIZE);
 462       if ( ifs->fail() || ifs->eof() )
 463         {
 464         break;
 465         }
 466       char *line = this->Strip(buffer);
 467       if ( *line == '#'  || *line == 0 )
 468         {
 469         // Comment
 470         continue;
 471         }
 472       int linelen = static_cast<int>(strlen(line));
 473       for ( cc = 0; cc < linelen; cc++ )
 474         {
 475         if ( line[cc] == '=' )
 476           {
 477           char *key = new char[ cc+1 ];
 478           strncpy( key, line, cc );
 479           key[cc] = 0;
 480           char *value = line + cc + 1;
 481           char *nkey = this->Strip(key);
 482           char *nvalue = this->Strip(value);
 483           this->EntriesMap[nkey] = this->DecodeValue(nvalue);
 484           m_Empty = 0;
 485           delete [] key;
 486           break;
 487           }
 488         }
 489       }
 490     ifs->close();
 491     this->SetSubKey( subkey );
 492     delete ifs;
 493     return res;
 494     }
 495   return false;
 496 }
 497
 498 //----------------------------------------------------------------------------
 499 bool RegistryHelper::Close()
 500 {
 501 #ifdef _WIN32
 502   if ( m_RegistryType == Registry::WIN32_REGISTRY)
 503     {
 504     int res;
 505     res = ( RegCloseKey(this->HKey) == ERROR_SUCCESS );
 506     return (res != 0);
 507     }
 508 #endif
 509   if ( m_RegistryType == Registry::FILE_REGISTRY )
 510     {
 511     if ( !m_Changed )
 512       {
 513       this->SetSubKey(0);
 514       return true;
 515       }
 516
 517     kwsys_ios::ostringstream str;
 518     str << m_HomeDirectory.c_str() << "/." << this->GetTopLevel() << "rc";
 519     kwsys_ios::ofstream *ofs = new kwsys_ios::ofstream(str.str().c_str(), kwsys_ios::ios::out);
 520     if ( !ofs )
 521       {
 522       return false;
 523       }
 524     if ( ofs->fail())
 525       {
 526       delete ofs;
 527       return false;
 528       }
 529     *ofs << "# This file is automatically generated by the application" << kwsys_ios::endl
 530       << "# If you change any lines or add new lines, note that all" << kwsys_ios::endl
 531       << "# comments and empty lines will be deleted. Every line has" << kwsys_ios::endl
 532       << "# to be in format: " << kwsys_ios::endl
 533       << "# key = value" << kwsys_ios::endl
 534       << "#" << kwsys_ios::endl;
 535
 536     if ( !this->EntriesMap.empty() )
 537       {
 538       RegistryHelper::StringToStringMap::iterator it;
 539       for ( it = this->EntriesMap.begin();
 540         it != this->EntriesMap.end();
 541         ++ it )
 542         {
 543         *ofs << it->first.c_str() << " = " << this->EncodeValue(it->second.c_str()).c_str() << kwsys_ios::endl;
 544         }
 545       }
 546     this->EntriesMap.clear();
 547     ofs->close();
 548     delete ofs;
 549     this->SetSubKey(0);
 550     m_Empty = 1;
 551     return true;
 552     }
 553   return false;
 554 }
 555
 556 //----------------------------------------------------------------------------
 557 bool RegistryHelper::ReadValue(const char *skey, const char **value)
 558
 559 {
 560 #ifdef _WIN32
 561   if ( m_RegistryType == Registry::WIN32_REGISTRY)
 562     {
 563     kwsys_stl::string key = this->CreateKey( skey );
 564     if ( key.empty() )
 565       {
 566       return false;
 567       }
 568     DWORD dwType, dwSize;
 569     dwType = REG_SZ;
 570     char buffer[1024]; // Replace with RegQueryInfoKey
 571     dwSize = sizeof(buffer);
 572     int res = ( RegQueryValueEx(this->HKey, skey, NULL, &dwType,
 573         (BYTE *)buffer, &dwSize) == ERROR_SUCCESS );
 574     if ( !res )
 575       {
 576       return false;
 577       }
 578     this->EntriesMap[key] = buffer;
 579     RegistryHelper::StringToStringMap::iterator it
 580       = this->EntriesMap.find(key);
 581     *value = it->second.c_str();
 582     return true;
 583     }
 584 #endif
 585   if ( m_RegistryType == Registry::FILE_REGISTRY )
 586     {
 587     bool res = false;
 588     kwsys_stl::string key = this->CreateKey( skey );
 589     if ( key.empty() )
 590       {
 591       return false;
 592       }
 593
 594     RegistryHelper::StringToStringMap::iterator it
 595       = this->EntriesMap.find(key);
 596     if ( it != this->EntriesMap.end() )
 597       {
 598       *value = it->second.c_str();
 599       res = true;
 600       }
 601     return res;
 602     }
 603   return false;
 604 }
 605
 606 //----------------------------------------------------------------------------
 607 bool RegistryHelper::DeleteKey(const char* skey)
 608 {
 609 #ifdef _WIN32
 610   if ( m_RegistryType == Registry::WIN32_REGISTRY)
 611     {
 612     int res = ( RegDeleteKey( this->HKey, skey ) == ERROR_SUCCESS );
 613     return (res != 0);
 614     }
 615 #endif
 616   if ( m_RegistryType == Registry::FILE_REGISTRY )
 617     {
 618     kwsys_stl::string key = this->CreateKey( skey );
 619     if ( key.empty() )
 620       {
 621       return false;
 622       }
 623     this->EntriesMap.erase(key);
 624     return true;
 625     }
 626   return false;
 627 }
 628
 629 //----------------------------------------------------------------------------
 630 bool RegistryHelper::DeleteValue(const char *skey)
 631 {
 632 #ifdef _WIN32
 633   if ( m_RegistryType == Registry::WIN32_REGISTRY)
 634     {
 635     int res = ( RegDeleteValue( this->HKey, skey ) == ERROR_SUCCESS );
 636     return (res != 0);
 637     }
 638 #endif
 639   if ( m_RegistryType == Registry::FILE_REGISTRY )
 640     {
 641     kwsys_stl::string key = this->CreateKey( skey );
 642     if ( key.empty() )
 643       {
 644       return false;
 645       }
 646     this->EntriesMap.erase(key);
 647     return true;
 648     }
 649   return false;
 650 }
 651
 652 //----------------------------------------------------------------------------
 653 bool RegistryHelper::SetValue(const char *skey, const char *value)
 654 {
 655 #ifdef _WIN32
 656   if ( m_RegistryType == Registry::WIN32_REGISTRY)
 657     {
 658     DWORD len = (DWORD)(value ? strlen(value) : 0);
 659     int res = ( RegSetValueEx(this->HKey, skey, 0, REG_SZ,
 660         (CONST BYTE *)(const char *)value,
 661         len+1) == ERROR_SUCCESS );
 662     return (res != 0);
 663     }
 664 #endif
 665   if ( m_RegistryType == Registry::FILE_REGISTRY )
 666     {
 667     kwsys_stl::string key = this->CreateKey( skey );
 668     if ( key.empty() )
 669       {
 670       return 0;
 671       }
 672     this->EntriesMap[key] = value;
 673     return 1;
 674     }
 675   return false;
 676 }
 677
 678 //----------------------------------------------------------------------------
 679 kwsys_stl::string RegistryHelper::CreateKey( const char *key )
 680 {
 681   if ( !m_SubKeySpecified || m_SubKey.empty() || !key )
 682     {
 683     return "";
 684     }
 685   kwsys_ios::ostringstream ostr;
 686   ostr << this->EncodeKey(this->m_SubKey.c_str()).c_str()
 687        << "\\" << this->EncodeKey(key).c_str();
 688   return ostr.str();
 689 }
 690
 691 //----------------------------------------------------------------------------
 692 void RegistryHelper::SetSubKey(const char* sk)
 693 {
 694   if ( !sk )
 695     {
 696     m_SubKey = "";
 697     m_SubKeySpecified = false;
 698     }
 699   else
 700     {
 701     m_SubKey = sk;
 702     m_SubKeySpecified = true;
 703     }
 704 }
 705
 706 //----------------------------------------------------------------------------
 707 char *RegistryHelper::Strip(char *str)
 708 {
 709   int cc;
 710   size_t len;
 711   char *nstr;
 712   if ( !str )
 713     {
 714     return NULL;
 715     }
 716   len = strlen(str);
 717   nstr = str;
 718   for( cc=0; cc < static_cast<int>(len); cc++ )
 719     {
 720     if ( !isspace( *nstr ) )
 721       {
 722       break;
 723       }
 724     nstr ++;
 725     }
 726   for( cc= static_cast<int>(strlen(nstr))-1; cc>=0; cc-- )
 727     {
 728     if ( !isspace( nstr[cc] ) )
 729       {
 730       nstr[cc+1] = 0;
 731       break;
 732       }
 733     }
 734   return nstr;
 735 }
 736
 737 //----------------------------------------------------------------------------
 738 void RegistryHelper::SetGlobalScope(bool b)
 739 {
 740   m_GlobalScope = b;
 741 }
 742
 743 //----------------------------------------------------------------------------
 744 bool RegistryHelper::GetGlobalScope()
 745 {
 746   return m_GlobalScope;
 747 }
 748
 749 //----------------------------------------------------------------------------
 750 kwsys_stl::string RegistryHelper::EncodeKey(const char* str)
 751 {
 752   kwsys_ios::ostringstream ostr;
 753   while ( *str )
 754     {
 755     switch ( *str )
 756       {
 757     case '%': case '=': case '\n': case '\r': case '\t':
 758       char buffer[4];
 759       sprintf(buffer, "%%%02X", *str);
 760       ostr << buffer;
 761       break;
 762     default:
 763       ostr << *str;
 764       }
 765     str ++;
 766     }
 767   return ostr.str();
 768 }
 769
 770 //----------------------------------------------------------------------------
 771 kwsys_stl::string RegistryHelper::EncodeValue(const char* str)
 772 {
 773   kwsys_ios::ostringstream ostr;
 774   while ( *str )
 775     {
 776     switch ( *str )
 777       {
 778     case '%': case '=': case '\n': case '\r': case '\t':
 779       char buffer[4];
 780       sprintf(buffer, "%%%02X", *str);
 781       ostr << buffer;
 782       break;
 783     default:
 784       ostr << *str;
 785       }
 786     str ++;
 787     }
 788   return ostr.str();
 789 }
 790
 791 //----------------------------------------------------------------------------
 792 kwsys_stl::string RegistryHelper::DecodeValue(const char* str)
 793 {
 794   kwsys_ios::ostringstream ostr;
 795   while ( *str )
 796     {
 797     unsigned int val;
 798     switch ( *str )
 799       {
 800     case '%':
 801       if ( *(str+1) && *(str+2) && sscanf(str+1, "%x", &val) == 1 )
 802         {
 803         ostr << static_cast<char>(val);
 804         str += 2;
 805         }
 806       else
 807         {
 808         ostr << *str;
 809         }
 810       break;
 811     default:
 812       ostr << *str;
 813       }
 814     str ++;
 815     }
 816   return ostr.str();
 817 }
 818
 819 } // namespace KWSYS_NAMESPACE