]> git.saurik.com Git - wxWidgets.git/blob - src/common/intl.cpp
Removed wxProp source files
[wxWidgets.git] / 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 size_t32 MSGCATALOG_MAGIC = 0x950412de;
50 const size_t32 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 size_t32 nLen; // length of the string
108 size_t32 ofsString; // pointer to the string
109 };
110
111 // header of a .mo file
112 struct wxMsgCatalogHeader
113 {
114 size_t32 magic, // offset +00: magic id
115 revision, // +04: revision
116 numStrings; // +08: number of strings in the file
117 size_t32 ofsOrigTable, // +0C: start of original string table
118 ofsTransTable; // +10: start of translated string table
119 size_t32 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 size_t8 *m_pData;
125
126 // data description
127 size_t32 m_numStrings, // number of strings in this domain
128 m_nHashSize; // number of entries in hash table
129 size_t32 *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, size_t32 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 size_t32 GetHash(const char *sz);
139 // big<->little endian
140 inline size_t32 Swap(size_t32 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 size_t32 wxMsgCatalog::GetHash(const char *sz)
162 {
163 #define HASHWORDBITS 32 // the length of size_t32
164
165 size_t32 hval = 0;
166 size_t32 g;
167 while ( *sz != '\0' ) {
168 hval <<= 4;
169 hval += (size_t32)*sz++;
170 g = hval & ((size_t32)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 size_t32 wxMsgCatalog::Swap(size_t32 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 size_t8[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 = (wxMsgCatalogHeader *)m_pData;
279 if ( bValid ) {
280 // we'll have to swap all the integers if it's true
281 m_bSwapped = pHeader->magic == MSGCATALOG_MAGIC_SW;
282
283 // check the magic number
284 bValid = m_bSwapped || pHeader->magic == MSGCATALOG_MAGIC;
285 }
286
287 if ( !bValid ) {
288 // it's either too short or has incorrect magic number
289 wxLogWarning(_("'%s' is not a valid message catalog."), strFullName.c_str());
290
291 wxDELETEA(m_pData);
292 return FALSE;
293 }
294
295 // initialize
296 m_numStrings = Swap(pHeader->numStrings);
297 m_pOrigTable = (wxMsgTableEntry *)(m_pData +
298 Swap(pHeader->ofsOrigTable));
299 m_pTransTable = (wxMsgTableEntry *)(m_pData +
300 Swap(pHeader->ofsTransTable));
301
302 m_nHashSize = Swap(pHeader->nHashSize);
303 m_pHashTable = (size_t32 *)(m_pData + Swap(pHeader->ofsHashTable));
304
305 m_pszName = new char[strlen(szName) + 1];
306 strcpy(m_pszName, szName);
307
308 // everything is fine
309 return TRUE;
310 }
311
312 // search for a string
313 const char *wxMsgCatalog::GetString(const char *szOrig) const
314 {
315 if ( szOrig == NULL )
316 return NULL;
317
318 if ( HasHashTable() ) { // use hash table for lookup if possible
319 size_t32 nHashVal = GetHash(szOrig);
320 size_t32 nIndex = nHashVal % m_nHashSize;
321
322 size_t32 nIncr = 1 + (nHashVal % (m_nHashSize - 2));
323
324 while ( TRUE ) {
325 size_t32 nStr = Swap(m_pHashTable[nIndex]);
326 if ( nStr == 0 )
327 return NULL;
328
329 if ( strcmp(szOrig, StringAtOfs(m_pOrigTable, nStr - 1)) == 0 )
330 return StringAtOfs(m_pTransTable, nStr - 1);
331
332 if ( nIndex >= m_nHashSize - nIncr)
333 nIndex -= m_nHashSize - nIncr;
334 else
335 nIndex += nIncr;
336 }
337 }
338 else { // no hash table: use default binary search
339 size_t32 bottom = 0,
340 top = m_numStrings,
341 current;
342 while ( bottom < top ) {
343 current = (bottom + top) / 2;
344 int res = strcmp(szOrig, StringAtOfs(m_pOrigTable, current));
345 if ( res < 0 )
346 top = current;
347 else if ( res > 0 )
348 bottom = current + 1;
349 else // found!
350 return StringAtOfs(m_pTransTable, current);
351 }
352 }
353
354 // not found
355 return NULL;
356 }
357
358 // ----------------------------------------------------------------------------
359 // wxLocale
360 // ----------------------------------------------------------------------------
361
362 wxLocale::wxLocale()
363 {
364 m_pszOldLocale = NULL;
365 m_pMsgCat = NULL;
366 }
367
368 // NB: this function has (desired) side effect of changing current locale
369 bool wxLocale::Init(const char *szName,
370 const char *szShort,
371 const char *szLocale,
372 bool bLoadDefault)
373 {
374 m_strLocale = szName;
375 m_strShort = szShort;
376
377 // change current locale (default: same as long name)
378 if ( szLocale == NULL )
379 szLocale = szName;
380 m_pszOldLocale = setlocale(LC_ALL, szLocale);
381 if ( m_pszOldLocale == NULL )
382 wxLogError(_("locale '%s' can not be set."), szLocale);
383
384 // the short name will be used to look for catalog files as well,
385 // so we need something here
386 if ( m_strShort.IsEmpty() ) {
387 // #### I don't know how these 2 letter abbreviations are formed,
388 // this wild guess is almost surely wrong
389 m_strShort = wxToLower(szLocale[0]) + wxToLower(szLocale[1]);
390 }
391
392 // save the old locale to be able to restore it later
393 m_pOldLocale = wxSetLocale(this);
394
395 // load the default catalog with wxWindows standard messages
396 m_pMsgCat = NULL;
397 bool bOk = TRUE;
398 if ( bLoadDefault )
399 bOk = AddCatalog("wxstd");
400
401 return bOk;
402 }
403
404 // clean up
405 wxLocale::~wxLocale()
406 {
407 // free memory
408 wxMsgCatalog *pTmpCat;
409 while ( m_pMsgCat != NULL ) {
410 pTmpCat = m_pMsgCat;
411 m_pMsgCat = m_pMsgCat->m_pNext;
412 delete pTmpCat;
413 }
414
415 // restore old locale
416 wxSetLocale(m_pOldLocale);
417 setlocale(LC_ALL, m_pszOldLocale);
418 }
419
420 // get the translation of given string in current locale
421 const char *wxLocale::GetString(const char *szOrigString,
422 const char *szDomain) const
423 {
424 wxASSERT( szOrigString != NULL ); // would be pretty silly
425
426 const char *pszTrans = NULL;
427
428 wxMsgCatalog *pMsgCat;
429 if ( szDomain != NULL ) {
430 pMsgCat = FindCatalog(szDomain);
431
432 // does the catalog exist?
433 if ( pMsgCat != NULL )
434 pszTrans = pMsgCat->GetString(szOrigString);
435 }
436 else {
437 // search in all domains
438 for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) {
439 pszTrans = pMsgCat->GetString(szOrigString);
440 if ( pszTrans != NULL ) // take the first found
441 break;
442 }
443 }
444
445 if ( pszTrans == NULL ) {
446 if ( wxIsLoggingTransErrors() ) {
447 // suppress further error messages
448 // (do it before LogWarning to prevent infinite recursion!)
449 wxSuppressTransErrors();
450
451 if ( szDomain != NULL )
452 wxLogWarning(_("string '%s' not found in domain '%s' for locale '%s'."),
453 szOrigString, szDomain, m_strLocale.c_str());
454 else
455 wxLogWarning(_("string '%s' not found in locale '%s'."),
456 szOrigString, m_strLocale.c_str());
457 }
458
459 return szOrigString;
460 }
461 else
462 return pszTrans;
463 }
464
465 // find catalog by name in a linked list, return NULL if !found
466 wxMsgCatalog *wxLocale::FindCatalog(const char *szDomain) const
467 {
468 // linear search in the linked list
469 wxMsgCatalog *pMsgCat;
470 for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) {
471 if ( Stricmp(pMsgCat->GetName(), szDomain) == 0 )
472 return pMsgCat;
473 }
474
475 return NULL;
476 }
477
478 // check if the given catalog is loaded
479 bool wxLocale::IsLoaded(const char *szDomain) const
480 {
481 return FindCatalog(szDomain) != NULL;
482 }
483
484 // add a catalog to our linked list
485 bool wxLocale::AddCatalog(const char *szDomain)
486 {
487 wxMsgCatalog *pMsgCat = new wxMsgCatalog;
488
489 if ( pMsgCat->Load(m_strShort, szDomain) ) {
490 // add it to the head of the list so that in GetString it will
491 // be searched before the catalogs added earlier
492 pMsgCat->m_pNext = m_pMsgCat;
493 m_pMsgCat = pMsgCat;
494
495 return TRUE;
496 }
497 else {
498 // don't add it because it couldn't be loaded anyway
499 delete pMsgCat;
500
501 return FALSE;
502 }
503 }
504
505 // ----------------------------------------------------------------------------
506 // global functions and variables
507 // ----------------------------------------------------------------------------
508
509 // translation errors logging
510 // --------------------------
511
512 static bool gs_bGiveTransErrors = TRUE;
513
514 void wxSuppressTransErrors()
515 {
516 gs_bGiveTransErrors = FALSE;
517 }
518
519 void wxRestoreTransErrors()
520 {
521 gs_bGiveTransErrors = TRUE;
522 }
523
524 bool wxIsLoggingTransErrors()
525 {
526 return gs_bGiveTransErrors;
527 }
528
529 // retrieve/change current locale
530 // ------------------------------
531
532 // the current locale object
533 wxLocale *g_pLocale = NULL;
534
535 wxLocale *wxGetLocale()
536 {
537 return g_pLocale;
538 }
539
540 wxLocale *wxSetLocale(wxLocale *pLocale)
541 {
542 wxLocale *pOld = g_pLocale;
543 g_pLocale = pLocale;
544 return pOld;
545 }