src/common/intl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        intl.cpp
   3 // Purpose:     Internationalization and localisation for wxWindows
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declaration
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21 #pragma implementation "intl.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28 #pragma hdrstop
  29 #endif
  30
  31 // standard headers
  32 #include  <locale.h>
  33
  34 // wxWindows
  35 #include "wx/defs.h"
  36 #include "wx/string.h"
  37 #include "wx/intl.h"
  38 #include "wx/file.h"
  39 #include "wx/log.h"
  40 #include "wx/utils.h"
  41
  42 #include <stdlib.h>
  43
  44 // ----------------------------------------------------------------------------
  45 // constants
  46 // ----------------------------------------------------------------------------
  47
  48 // magic number identifying the .mo format file
  49 const uint32 MSGCATALOG_MAGIC    = 0x950412de;
  50 const uint32 MSGCATALOG_MAGIC_SW = 0xde120495;
  51
  52 // extension of ".mo" files
  53 #define MSGCATALOG_EXTENSION  ".mo"
  54
  55 // ----------------------------------------------------------------------------
  56 // global functions
  57 // ----------------------------------------------------------------------------
  58
  59 // suppress further error messages about missing translations
  60 // (if you don't have one catalog file, you wouldn't like to see the
  61 //  error message for each string in it, so normally it's given only
  62 //  once)
  63 void wxSuppressTransErrors();
  64
  65 // restore the logging
  66 void wxRestoreTransErrors();
  67
  68 // get the current state
  69 bool wxIsLoggingTransErrors();
  70
  71 // get the current locale object (## may be NULL!)
  72 extern wxLocale *wxSetLocale(wxLocale *pLocale);
  73
  74 // ----------------------------------------------------------------------------
  75 // wxMsgCatalog corresponds to one disk-file message catalog.
  76 //
  77 // This is a "low-level" class and is used only by wxLocale (that's why
  78 // it's designed to be stored in a linked list)
  79 // ----------------------------------------------------------------------------
  80
  81 class wxMsgCatalog
  82 {
  83 public:
  84   // ctor & dtor
  85   wxMsgCatalog();
  86  ~wxMsgCatalog();
  87
  88   // load the catalog from disk (szDirPrefix corresponds to language)
  89   bool Load(const char *szDirPrefix, const char *szName);
  90   bool IsLoaded() const { return m_pData != NULL; }
  91
  92   // get name of the catalog
  93   const char *GetName() const { return m_pszName; }
  94
  95   // get the translated string: returns NULL if not found
  96   const char *GetString(const char *sz) const;
  97
  98   // public variable pointing to the next element in a linked list (or NULL)
  99   wxMsgCatalog *m_pNext;
 100
 101 private:
 102   // this implementation is binary compatible with GNU gettext() version 0.10
 103
 104   // an entry in the string table
 105   struct wxMsgTableEntry
 106   {
 107     uint32   nLen;           // length of the string
 108     uint32   ofsString;      // pointer to the string
 109   };
 110
 111   // header of a .mo file
 112   struct wxMsgCatalogHeader
 113   {
 114     uint32  magic,          // offset +00:  magic id
 115             revision,       //        +04:  revision
 116             numStrings;     //        +08:  number of strings in the file
 117     uint32  ofsOrigTable,   //        +0C:  start of original string table
 118             ofsTransTable;  //        +10:  start of translated string table
 119     uint32  nHashSize,      //        +14:  hash table size
 120             ofsHashTable;   //        +18:  offset of hash table start
 121   };
 122
 123   // all data is stored here, NULL if no data loaded
 124   uint8 *m_pData;
 125
 126   // data description
 127   uint32            m_numStrings,   // number of strings in this domain
 128                     m_nHashSize;    // number of entries in hash table
 129   uint32           *m_pHashTable;   // pointer to hash table
 130   wxMsgTableEntry  *m_pOrigTable,   // pointer to original   strings
 131                    *m_pTransTable;  //            translated
 132
 133   const char *StringAtOfs(wxMsgTableEntry *pTable, uint32 index) const
 134     { return (const char *)(m_pData + Swap(pTable[index].ofsString)); }
 135
 136   // utility functions
 137     // calculate the hash value of given string
 138   static inline uint32 GetHash(const char *sz);
 139     // big<->little endian
 140   inline uint32 Swap(uint32 ui) const;
 141
 142   // internal state
 143   bool HasHashTable() const // true if hash table is present
 144     { return m_nHashSize > 2 && m_pHashTable != NULL; }
 145
 146   bool          m_bSwapped;   // wrong endianness?
 147
 148   char         *m_pszName;    // name of the domain
 149 };
 150
 151 // ============================================================================
 152 // implementation
 153 // ============================================================================
 154
 155 // ----------------------------------------------------------------------------
 156 // wxMsgCatalog class
 157 // ----------------------------------------------------------------------------
 158
 159 // calculate hash value using the so called hashpjw function by P.J. Weinberger
 160 // [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools]
 161 uint32 wxMsgCatalog::GetHash(const char *sz)
 162 {
 163   #define HASHWORDBITS 32     // the length of uint32
 164
 165   uint32 hval = 0;
 166   uint32 g;
 167   while ( *sz != '\0' ) {
 168     hval <<= 4;
 169     hval += (uint32)*sz++;
 170     g = hval & ((uint32)0xf << (HASHWORDBITS - 4));
 171     if ( g != 0 ) {
 172       hval ^= g >> (HASHWORDBITS - 8);
 173       hval ^= g;
 174     }
 175   }
 176
 177   return hval;
 178 }
 179
 180 // swap the 2 halves of 32 bit integer if needed
 181 uint32 wxMsgCatalog::Swap(uint32 ui) const
 182 {
 183   return m_bSwapped ? (ui << 24) | ((ui & 0xff00) << 8) |
 184                       ((ui >> 8) & 0xff00) | (ui >> 24)
 185                     : ui;
 186 }
 187
 188 wxMsgCatalog::wxMsgCatalog()
 189 {
 190   m_pData   = NULL;
 191   m_pszName = NULL;
 192 }
 193
 194 wxMsgCatalog::~wxMsgCatalog()
 195 {
 196   wxDELETEA(m_pData);
 197   wxDELETEA(m_pszName);
 198 }
 199
 200 class NoTransErr
 201 {
 202   public:
 203     NoTransErr() { wxSuppressTransErrors(); }
 204    ~NoTransErr() { wxRestoreTransErrors();  }
 205 };
 206
 207 // open disk file and read in it's contents
 208 bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
 209 {
 210   // search order (assume language 'foo') is
 211   // 1) $LC_PATH/foo/LC_MESSAGES          (if LC_PATH set)
 212   // 2) ./foo/LC_MESSAGES
 213   // 3) ./foo
 214   // 4) . (Added by JACS)
 215   //
 216   // under UNIX we search also in:
 217   // 5) /usr/share/locale/foo/LC_MESSAGES (Linux)
 218   // 6) /usr/lib/locale/foo/LC_MESSAGES   (Solaris)
 219   #define MSG_PATH FILE_SEP_PATH + "LC_MESSAGES" PATH_SEP
 220
 221   wxString strPath("");
 222   const char *pszLcPath = getenv("LC_PATH");
 223   if ( pszLcPath != NULL )
 224       strPath += pszLcPath + wxString(szDirPrefix) + MSG_PATH;        // (1)
 225
 226   // NB: '<<' is unneeded between too literal strings:
 227   //     they are concatenated at compile time
 228   strPath += "./" + wxString(szDirPrefix) + MSG_PATH                  // (2)
 229           + "./" + szDirPrefix + FILE_SEP_PATH + PATH_SEP // (3)
 230                   + "." + PATH_SEP
 231   #ifdef  __UNIX__
 232              "/usr/share/locale/" + szDirPrefix + MSG_PATH  // (5)
 233              "/usr/lib/locale/"  + szDirPrefix + MSG_PATH  // (6)
 234   #endif  //UNIX
 235           ;
 236
 237   wxString strFile = szName;
 238   strFile += MSGCATALOG_EXTENSION;
 239
 240   // don't give translation errors here because the wxstd catalog might
 241   // not yet be loaded (and it's normal)
 242   //
 243   // (we're using an object because we have several return paths)
 244   NoTransErr noTransErr;
 245
 246   wxLogVerbose("looking for catalog '%s' in path '%s'.",
 247              szName, strPath.c_str());
 248
 249   wxString strFullName;
 250   if ( !wxFindFileInPath(&strFullName, strPath, strFile) ) {
 251     wxLogWarning("catalog file for domain '%s' not found.", szName);
 252     return FALSE;
 253   }
 254
 255   // open file
 256   wxLogVerbose("using catalog '%s' from '%s'.",
 257              szName, strFullName.c_str());
 258
 259   wxFile fileMsg(strFullName);
 260   if ( !fileMsg.IsOpened() )
 261     return FALSE;
 262
 263   // get the file size
 264   off_t nSize = fileMsg.Length();
 265   if ( nSize == wxInvalidOffset )
 266     return FALSE;
 267
 268   // read the whole file in memory
 269   m_pData = new uint8[nSize];
 270   if ( fileMsg.Read(m_pData, nSize) != nSize ) {
 271     wxDELETEA(m_pData);
 272     return FALSE;
 273   }
 274
 275   // examine header
 276   bool bValid = (size_t)nSize > sizeof(wxMsgCatalogHeader);
 277
 278   wxMsgCatalogHeader *pHeader;
 279   if ( bValid ) {
 280     pHeader = (wxMsgCatalogHeader *)m_pData;
 281
 282     // we'll have to swap all the integers if it's true
 283     m_bSwapped = pHeader->magic == MSGCATALOG_MAGIC_SW;
 284
 285     // check the magic number
 286     bValid = m_bSwapped || pHeader->magic == MSGCATALOG_MAGIC;
 287   }
 288
 289   if ( !bValid ) {
 290     // it's either too short or has incorrect magic number
 291     wxLogWarning("'%s' is not a valid message catalog.", strFullName.c_str());
 292
 293     wxDELETEA(m_pData);
 294     return FALSE;
 295   }
 296
 297   // initialize
 298   m_numStrings  = Swap(pHeader->numStrings);
 299   m_pOrigTable  = (wxMsgTableEntry *)(m_pData +
 300                    Swap(pHeader->ofsOrigTable));
 301   m_pTransTable = (wxMsgTableEntry *)(m_pData +
 302                    Swap(pHeader->ofsTransTable));
 303
 304   m_nHashSize   = Swap(pHeader->nHashSize);
 305   m_pHashTable  = (uint32 *)(m_pData + Swap(pHeader->ofsHashTable));
 306
 307   m_pszName = new char[strlen(szName) + 1];
 308   strcpy(m_pszName, szName);
 309
 310   // everything is fine
 311   return TRUE;
 312 }
 313
 314 // search for a string
 315 const char *wxMsgCatalog::GetString(const char *szOrig) const
 316 {
 317   if ( szOrig == NULL )
 318     return NULL;
 319
 320   if ( HasHashTable() ) {   // use hash table for lookup if possible
 321     uint32 nHashVal = GetHash(szOrig);
 322     uint32 nIndex   = nHashVal % m_nHashSize;
 323
 324     uint32 nIncr = 1 + (nHashVal % (m_nHashSize - 2));
 325
 326     while ( TRUE ) {
 327       uint32 nStr = Swap(m_pHashTable[nIndex]);
 328       if ( nStr == 0 )
 329         return NULL;
 330
 331       if ( strcmp(szOrig, StringAtOfs(m_pOrigTable, nStr - 1)) == 0 )
 332         return StringAtOfs(m_pTransTable, nStr - 1);
 333
 334       if ( nIndex >= m_nHashSize - nIncr)
 335         nIndex -= m_nHashSize - nIncr;
 336       else
 337         nIndex += nIncr;
 338     }
 339   }
 340   else {                    // no hash table: use default binary search
 341     uint32 bottom = 0,
 342            top    = m_numStrings,
 343            current;
 344     while ( bottom < top ) {
 345       current = (bottom + top) / 2;
 346       int res = strcmp(szOrig, StringAtOfs(m_pOrigTable, current));
 347       if ( res < 0 )
 348         top = current;
 349       else if ( res > 0 )
 350         bottom = current + 1;
 351       else    // found!
 352         return StringAtOfs(m_pTransTable, current);
 353     }
 354   }
 355
 356   // not found
 357   return NULL;
 358 }
 359
 360 // ----------------------------------------------------------------------------
 361 // wxLocale
 362 // ----------------------------------------------------------------------------
 363
 364 wxLocale::wxLocale()
 365 {
 366   m_pszOldLocale = NULL;
 367   m_pMsgCat = NULL;
 368 }
 369
 370 // NB: this function has (desired) side effect of changing current locale
 371 bool wxLocale::Init(const char *szName,
 372                     const char *szShort,
 373                     const char *szLocale,
 374                     bool        bLoadDefault)
 375 {
 376   m_strLocale = szName;
 377   m_strShort = szShort;
 378
 379   // change current locale (default: same as long name)
 380   if ( szLocale == NULL )
 381     szLocale = szName;
 382   m_pszOldLocale = setlocale(LC_ALL, szLocale);
 383   if ( m_pszOldLocale == NULL )
 384     wxLogError("locale '%s' can not be set.", szLocale);
 385
 386   // the short name will be used to look for catalog files as well,
 387   // so we need something here
 388   if ( m_strShort.IsEmpty() ) {
 389     // #### I don't know how these 2 letter abbreviations are formed,
 390     //      this wild guess is almost surely wrong
 391     m_strShort = wxToLower(szLocale[0]) + wxToLower(szLocale[1]);
 392   }
 393
 394   // save the old locale to be able to restore it later
 395         m_pOldLocale = wxSetLocale(this);
 396
 397   // load the default catalog with wxWindows standard messages
 398   m_pMsgCat = NULL;
 399   bool bOk = TRUE;
 400   if ( bLoadDefault )
 401     bOk = AddCatalog("wxstd");
 402
 403   return bOk;
 404 }
 405
 406 // clean up
 407 wxLocale::~wxLocale()
 408 {
 409   // free memory
 410   wxMsgCatalog *pTmpCat;
 411   while ( m_pMsgCat != NULL ) {
 412     pTmpCat = m_pMsgCat;
 413     m_pMsgCat = m_pMsgCat->m_pNext;
 414     delete pTmpCat;
 415   }
 416
 417   // restore old locale
 418         wxSetLocale(m_pOldLocale);
 419   setlocale(LC_ALL, m_pszOldLocale);
 420 }
 421
 422 // get the translation of given string in current locale
 423 const char *wxLocale::GetString(const char *szOrigString,
 424                                 const char *szDomain) const
 425 {
 426   wxASSERT( szOrigString != NULL ); // would be pretty silly
 427
 428   const char *pszTrans = NULL;
 429
 430   wxMsgCatalog *pMsgCat;
 431   if ( szDomain != NULL ) {
 432     pMsgCat = FindCatalog(szDomain);
 433
 434     // does the catalog exist?
 435     if ( pMsgCat != NULL )
 436       pszTrans = pMsgCat->GetString(szOrigString);
 437   }
 438   else {
 439     // search in all domains
 440     for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) {
 441       pszTrans = pMsgCat->GetString(szOrigString);
 442       if ( pszTrans != NULL )   // take the first found
 443         break;
 444     }
 445   }
 446
 447   if ( pszTrans == NULL ) {
 448     if ( wxIsLoggingTransErrors() ) {
 449       // suppress further error messages
 450       // (do it before LogWarning to prevent infinite recursion!)
 451       wxSuppressTransErrors();
 452
 453       if ( szDomain != NULL )
 454         wxLogWarning("string '%s' not found in domain '%s' for locale '%s'.",
 455                     szOrigString, szDomain, m_strLocale.c_str());
 456       else
 457         wxLogWarning("string '%s' not found in locale '%s'.",
 458                    szOrigString, m_strLocale.c_str());
 459     }
 460
 461     return szOrigString;
 462   }
 463   else
 464     return pszTrans;
 465 }
 466
 467 // find catalog by name in a linked list, return NULL if !found
 468 wxMsgCatalog *wxLocale::FindCatalog(const char *szDomain) const
 469 {
 470 // linear search in the linked list
 471   wxMsgCatalog *pMsgCat;
 472   for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) {
 473     if ( Stricmp(pMsgCat->GetName(), szDomain) == 0 )
 474       return pMsgCat;
 475   }
 476
 477   return NULL;
 478 }
 479
 480 // check if the given catalog is loaded
 481 bool wxLocale::IsLoaded(const char *szDomain) const
 482 {
 483   return FindCatalog(szDomain) != NULL;
 484 }
 485
 486 // add a catalog to our linked list
 487 bool wxLocale::AddCatalog(const char *szDomain)
 488 {
 489   wxMsgCatalog *pMsgCat = new wxMsgCatalog;
 490
 491   if ( pMsgCat->Load(m_strShort, szDomain) ) {
 492     // add it to the head of the list so that in GetString it will
 493     // be searched before the catalogs added earlier
 494     pMsgCat->m_pNext = m_pMsgCat;
 495     m_pMsgCat = pMsgCat;
 496
 497     return TRUE;
 498   }
 499   else {
 500     // don't add it because it couldn't be loaded anyway
 501     delete pMsgCat;
 502
 503     return FALSE;
 504   }
 505 }
 506
 507 // ----------------------------------------------------------------------------
 508 // global functions and variables
 509 // ----------------------------------------------------------------------------
 510
 511 // translation errors logging
 512 // --------------------------
 513
 514 static bool gs_bGiveTransErrors = TRUE;
 515
 516 void wxSuppressTransErrors()
 517 {
 518   gs_bGiveTransErrors = FALSE;
 519 }
 520
 521 void wxRestoreTransErrors()
 522 {
 523   gs_bGiveTransErrors = TRUE;
 524 }
 525
 526 bool wxIsLoggingTransErrors()
 527 {
 528   return gs_bGiveTransErrors;
 529 }
 530
 531 // retrieve/change current locale
 532 // ------------------------------
 533
 534 // the current locale object
 535 wxLocale *g_pLocale = NULL;
 536
 537 wxLocale *wxGetLocale()
 538 {
 539         return g_pLocale;
 540 }
 541
 542 wxLocale *wxSetLocale(wxLocale *pLocale)
 543 {
 544         wxLocale *pOld = g_pLocale;
 545         g_pLocale = pLocale;
 546         return pOld;
 547 }