]> git.saurik.com Git - wxWidgets.git/blob - src/common/translation.cpp
projects / wxWidgets.git / blob
? search:


69c9361e996c2fee9862dfd1e482dd07bd9eb26b
[wxWidgets.git] / src / common / translation.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/translation.cpp
3 // Purpose: Internationalization and localisation for wxWidgets
4 // Author: Vadim Zeitlin, Vaclav Slavik,
5 // Michael N. Filippov <michael@idisys.iae.nsk.su>
6 // (2003/09/30 - PluralForms support)
7 // Created: 2010-04-23
8 // RCS-ID: $Id$
9 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ============================================================================
14 // declaration
15 // ============================================================================
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 // For compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
23
24 #ifdef __BORLANDC__
25 #pragma hdrstop
26 #endif
27
28 #if wxUSE_INTL
29
30 #ifndef WX_PRECOMP
31 #include "wx/dynarray.h"
32 #include "wx/string.h"
33 #include "wx/intl.h"
34 #include "wx/log.h"
35 #include "wx/utils.h"
36 #include "wx/hashmap.h"
37 #include "wx/module.h"
38 #endif // WX_PRECOMP
39
40 // standard headers
41 #include <ctype.h>
42 #include <stdlib.h>
43
44 #include "wx/arrstr.h"
45 #include "wx/dir.h"
46 #include "wx/file.h"
47 #include "wx/filename.h"
48 #include "wx/tokenzr.h"
49 #include "wx/fontmap.h"
50 #include "wx/stdpaths.h"
51 #include "wx/hashset.h"
52
53 #ifdef __WINDOWS__
54 #include "wx/dynlib.h"
55 #include "wx/scopedarray.h"
56 #include "wx/msw/wrapwin.h"
57 #include "wx/msw/missing.h"
58 #endif
59 #ifdef __WXOSX__
60 #include "wx/osx/core/cfstring.h"
61 #include <CoreFoundation/CFBundle.h>
62 #include <CoreFoundation/CFLocale.h>
63 #endif
64
65 // ----------------------------------------------------------------------------
66 // simple types
67 // ----------------------------------------------------------------------------
68
69 typedef wxUint32 size_t32;
70
71 // ----------------------------------------------------------------------------
72 // constants
73 // ----------------------------------------------------------------------------
74
75 // magic number identifying the .mo format file
76 const size_t32 MSGCATALOG_MAGIC = 0x950412de;
77 const size_t32 MSGCATALOG_MAGIC_SW = 0xde120495;
78
79 #define TRACE_I18N wxS("i18n")
80
81 // ============================================================================
82 // implementation
83 // ============================================================================
84
85 namespace
86 {
87
88 #if !wxUSE_UNICODE
89 // We need to keep track of (char*) msgids in non-Unicode legacy builds. Instead
90 // of making the public wxMsgCatalog and wxTranslationsLoader APIs ugly, we
91 // store them in this global map.
92 wxStringToStringHashMap gs_msgIdCharset;
93 #endif
94
95 // ----------------------------------------------------------------------------
96 // Platform specific helpers
97 // ----------------------------------------------------------------------------
98
99 void LogTraceArray(const char *prefix, const wxArrayString& arr)
100 {
101 wxLogTrace(TRACE_I18N, "%s: [%s]", prefix, wxJoin(arr, ','));
102 }
103
104 void LogTraceLargeArray(const char *prefix, const wxArrayString& arr)
105 {
106 wxLogTrace(TRACE_I18N, "%s:", prefix);
107 for ( wxArrayString::const_iterator i = arr.begin(); i != arr.end(); ++i )
108 wxLogTrace(TRACE_I18N, " %s", *i);
109 }
110
111 // Use locale-based detection as a fallback
112 wxString GetPreferredUILanguageFallback(const wxArrayString& WXUNUSED(available))
113 {
114 const wxString lang = wxLocale::GetLanguageCanonicalName(wxLocale::GetSystemLanguage());
115 wxLogTrace(TRACE_I18N, " - obtained best language from locale: %s", lang);
116 return lang;
117 }
118
119 #ifdef __WINDOWS__
120
121 wxString GetPreferredUILanguage(const wxArrayString& available)
122 {
123 typedef BOOL (WINAPI *GetUserPreferredUILanguages_t)(DWORD, PULONG, PWSTR, PULONG);
124 static GetUserPreferredUILanguages_t s_pfnGetUserPreferredUILanguages = NULL;
125 static bool s_initDone = false;
126 if ( !s_initDone )
127 {
128 wxLoadedDLL dllKernel32("kernel32.dll");
129 wxDL_INIT_FUNC(s_pfn, GetUserPreferredUILanguages, dllKernel32);
130 s_initDone = true;
131 }
132
133 if ( s_pfnGetUserPreferredUILanguages )
134 {
135 ULONG numLangs;
136 ULONG bufferSize = 0;
137 if ( (*s_pfnGetUserPreferredUILanguages)(MUI_LANGUAGE_NAME,
138 &numLangs,
139 NULL,
140 &bufferSize) )
141 {
142 wxScopedArray<WCHAR> langs(new WCHAR[bufferSize]);
143 if ( (*s_pfnGetUserPreferredUILanguages)(MUI_LANGUAGE_NAME,
144 &numLangs,
145 langs.get(),
146 &bufferSize) )
147 {
148 wxArrayString preferred;
149
150 WCHAR *buf = langs.get();
151 for ( unsigned i = 0; i < numLangs; i++ )
152 {
153 const wxString lang(buf);
154 preferred.push_back(lang);
155 buf += lang.length() + 1;
156 }
157 LogTraceArray(" - system preferred languages", preferred);
158
159 for ( wxArrayString::const_iterator j = preferred.begin();
160 j != preferred.end();
161 ++j )
162 {
163 wxString lang(*j);
164 lang.Replace("-", "_");
165 if ( available.Index(lang, /*bCase=*/false) != wxNOT_FOUND )
166 return lang;
167 size_t pos = lang.find('_');
168 if ( pos != wxString::npos )
169 {
170 lang = lang.substr(0, pos);
171 if ( available.Index(lang, /*bCase=*/false) != wxNOT_FOUND )
172 return lang;
173 }
174 }
175 }
176 }
177 }
178
179 return GetPreferredUILanguageFallback(available);
180 }
181
182 #elif defined(__WXOSX__)
183
184 void LogTraceArray(const char *prefix, CFArrayRef arr)
185 {
186 wxString s;
187 const unsigned count = CFArrayGetCount(arr);
188 if ( count )
189 {
190 s += wxCFStringRef::AsString((CFStringRef)CFArrayGetValueAtIndex(arr, 0));
191 for ( unsigned i = 1 ; i < count; i++ )
192 s += "," + wxCFStringRef::AsString((CFStringRef)CFArrayGetValueAtIndex(arr, i));
193 }
194 wxLogTrace(TRACE_I18N, "%s: [%s]", prefix, s);
195 }
196
197 wxString GetPreferredUILanguage(const wxArrayString& available)
198 {
199 wxStringToStringHashMap availableNormalized;
200 wxCFRef<CFMutableArrayRef> availableArr(
201 CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks));
202
203 for ( wxArrayString::const_iterator i = available.begin();
204 i != available.end();
205 ++i )
206 {
207 wxString lang(*i);
208 wxCFStringRef code_wx(*i);
209 wxCFStringRef code_norm(
210 CFLocaleCreateCanonicalLanguageIdentifierFromString(kCFAllocatorDefault, code_wx));
211 CFArrayAppendValue(availableArr, code_norm);
212 availableNormalized[code_norm.AsString()] = *i;
213 }
214 LogTraceArray(" - normalized available list", availableArr);
215
216 wxCFRef<CFArrayRef> prefArr(
217 CFBundleCopyLocalizationsForPreferences(availableArr, NULL));
218 LogTraceArray(" - system preferred languages", prefArr);
219
220 unsigned prefArrLength = CFArrayGetCount(prefArr);
221 if ( prefArrLength > 0 )
222 {
223 // Lookup the name in 'available' by index -- we need to get the
224 // original value corresponding to the normalized one chosen.
225 wxString lang(wxCFStringRef::AsString((CFStringRef)CFArrayGetValueAtIndex(prefArr, 0)));
226 wxStringToStringHashMap::const_iterator i = availableNormalized.find(lang);
227 if ( i == availableNormalized.end() )
228 return lang;
229 else
230 return i->second;
231 }
232
233 return GetPreferredUILanguageFallback(available);
234 }
235
236 #else
237
238 // On Unix, there's just one language=locale setting, so we should always
239 // use that.
240 #define GetPreferredUILanguage GetPreferredUILanguageFallback
241
242 #endif
243
244 } // anonymous namespace
245
246 // ----------------------------------------------------------------------------
247 // Plural forms parser
248 // ----------------------------------------------------------------------------
249
250 /*
251 Simplified Grammar
252
253 Expression:
254 LogicalOrExpression '?' Expression ':' Expression
255 LogicalOrExpression
256
257 LogicalOrExpression:
258 LogicalAndExpression "||" LogicalOrExpression // to (a || b) || c
259 LogicalAndExpression
260
261 LogicalAndExpression:
262 EqualityExpression "&&" LogicalAndExpression // to (a && b) && c
263 EqualityExpression
264
265 EqualityExpression:
266 RelationalExpression "==" RelationalExperession
267 RelationalExpression "!=" RelationalExperession
268 RelationalExpression
269
270 RelationalExpression:
271 MultiplicativeExpression '>' MultiplicativeExpression
272 MultiplicativeExpression '<' MultiplicativeExpression
273 MultiplicativeExpression ">=" MultiplicativeExpression
274 MultiplicativeExpression "<=" MultiplicativeExpression
275 MultiplicativeExpression
276
277 MultiplicativeExpression:
278 PmExpression '%' PmExpression
279 PmExpression
280
281 PmExpression:
282 N
283 Number
284 '(' Expression ')'
285 */
286
287 class wxPluralFormsToken
288 {
289 public:
290 enum Type
291 {
292 T_ERROR, T_EOF, T_NUMBER, T_N, T_PLURAL, T_NPLURALS, T_EQUAL, T_ASSIGN,
293 T_GREATER, T_GREATER_OR_EQUAL, T_LESS, T_LESS_OR_EQUAL,
294 T_REMINDER, T_NOT_EQUAL,
295 T_LOGICAL_AND, T_LOGICAL_OR, T_QUESTION, T_COLON, T_SEMICOLON,
296 T_LEFT_BRACKET, T_RIGHT_BRACKET
297 };
298 Type type() const { return m_type; }
299 void setType(Type t) { m_type = t; }
300 // for T_NUMBER only
301 typedef int Number;
302 Number number() const { return m_number; }
303 void setNumber(Number num) { m_number = num; }
304 private:
305 Type m_type;
306 Number m_number;
307 };
308
309
310 class wxPluralFormsScanner
311 {
312 public:
313 wxPluralFormsScanner(const char* s);
314 const wxPluralFormsToken& token() const { return m_token; }
315 bool nextToken(); // returns false if error
316 private:
317 const char* m_s;
318 wxPluralFormsToken m_token;
319 };
320
321 wxPluralFormsScanner::wxPluralFormsScanner(const char* s) : m_s(s)
322 {
323 nextToken();
324 }
325
326 bool wxPluralFormsScanner::nextToken()
327 {
328 wxPluralFormsToken::Type type = wxPluralFormsToken::T_ERROR;
329 while (isspace((unsigned char) *m_s))
330 {
331 ++m_s;
332 }
333 if (*m_s == 0)
334 {
335 type = wxPluralFormsToken::T_EOF;
336 }
337 else if (isdigit((unsigned char) *m_s))
338 {
339 wxPluralFormsToken::Number number = *m_s++ - '0';
340 while (isdigit((unsigned char) *m_s))
341 {
342 number = number * 10 + (*m_s++ - '0');
343 }
344 m_token.setNumber(number);
345 type = wxPluralFormsToken::T_NUMBER;
346 }
347 else if (isalpha((unsigned char) *m_s))
348 {
349 const char* begin = m_s++;
350 while (isalnum((unsigned char) *m_s))
351 {
352 ++m_s;
353 }
354 size_t size = m_s - begin;
355 if (size == 1 && memcmp(begin, "n", size) == 0)
356 {
357 type = wxPluralFormsToken::T_N;
358 }
359 else if (size == 6 && memcmp(begin, "plural", size) == 0)
360 {
361 type = wxPluralFormsToken::T_PLURAL;
362 }
363 else if (size == 8 && memcmp(begin, "nplurals", size) == 0)
364 {
365 type = wxPluralFormsToken::T_NPLURALS;
366 }
367 }
368 else if (*m_s == '=')
369 {
370 ++m_s;
371 if (*m_s == '=')
372 {
373 ++m_s;
374 type = wxPluralFormsToken::T_EQUAL;
375 }
376 else
377 {
378 type = wxPluralFormsToken::T_ASSIGN;
379 }
380 }
381 else if (*m_s == '>')
382 {
383 ++m_s;
384 if (*m_s == '=')
385 {
386 ++m_s;
387 type = wxPluralFormsToken::T_GREATER_OR_EQUAL;
388 }
389 else
390 {
391 type = wxPluralFormsToken::T_GREATER;
392 }
393 }
394 else if (*m_s == '<')
395 {
396 ++m_s;
397 if (*m_s == '=')
398 {
399 ++m_s;
400 type = wxPluralFormsToken::T_LESS_OR_EQUAL;
401 }
402 else
403 {
404 type = wxPluralFormsToken::T_LESS;
405 }
406 }
407 else if (*m_s == '%')
408 {
409 ++m_s;
410 type = wxPluralFormsToken::T_REMINDER;
411 }
412 else if (*m_s == '!' && m_s[1] == '=')
413 {
414 m_s += 2;
415 type = wxPluralFormsToken::T_NOT_EQUAL;
416 }
417 else if (*m_s == '&' && m_s[1] == '&')
418 {
419 m_s += 2;
420 type = wxPluralFormsToken::T_LOGICAL_AND;
421 }
422 else if (*m_s == '|' && m_s[1] == '|')
423 {
424 m_s += 2;
425 type = wxPluralFormsToken::T_LOGICAL_OR;
426 }
427 else if (*m_s == '?')
428 {
429 ++m_s;
430 type = wxPluralFormsToken::T_QUESTION;
431 }
432 else if (*m_s == ':')
433 {
434 ++m_s;
435 type = wxPluralFormsToken::T_COLON;
436 } else if (*m_s == ';') {
437 ++m_s;
438 type = wxPluralFormsToken::T_SEMICOLON;
439 }
440 else if (*m_s == '(')
441 {
442 ++m_s;
443 type = wxPluralFormsToken::T_LEFT_BRACKET;
444 }
445 else if (*m_s == ')')
446 {
447 ++m_s;
448 type = wxPluralFormsToken::T_RIGHT_BRACKET;
449 }
450 m_token.setType(type);
451 return type != wxPluralFormsToken::T_ERROR;
452 }
453
454 class wxPluralFormsNode;
455
456 // NB: Can't use wxDEFINE_SCOPED_PTR_TYPE because wxPluralFormsNode is not
457 // fully defined yet:
458 class wxPluralFormsNodePtr
459 {
460 public:
461 wxPluralFormsNodePtr(wxPluralFormsNode *p = NULL) : m_p(p) {}
462 ~wxPluralFormsNodePtr();
463 wxPluralFormsNode& operator*() const { return *m_p; }
464 wxPluralFormsNode* operator->() const { return m_p; }
465 wxPluralFormsNode* get() const { return m_p; }
466 wxPluralFormsNode* release();
467 void reset(wxPluralFormsNode *p);
468
469 private:
470 wxPluralFormsNode *m_p;
471 };
472
473 class wxPluralFormsNode
474 {
475 public:
476 wxPluralFormsNode(const wxPluralFormsToken& t) : m_token(t) {}
477 const wxPluralFormsToken& token() const { return m_token; }
478 const wxPluralFormsNode* node(unsigned i) const
479 { return m_nodes[i].get(); }
480 void setNode(unsigned i, wxPluralFormsNode* n);
481 wxPluralFormsNode* releaseNode(unsigned i);
482 wxPluralFormsToken::Number evaluate(wxPluralFormsToken::Number n) const;
483
484 private:
485 wxPluralFormsToken m_token;
486 wxPluralFormsNodePtr m_nodes[3];
487 };
488
489 wxPluralFormsNodePtr::~wxPluralFormsNodePtr()
490 {
491 delete m_p;
492 }
493 wxPluralFormsNode* wxPluralFormsNodePtr::release()
494 {
495 wxPluralFormsNode *p = m_p;
496 m_p = NULL;
497 return p;
498 }
499 void wxPluralFormsNodePtr::reset(wxPluralFormsNode *p)
500 {
501 if (p != m_p)
502 {
503 delete m_p;
504 m_p = p;
505 }
506 }
507
508
509 void wxPluralFormsNode::setNode(unsigned i, wxPluralFormsNode* n)
510 {
511 m_nodes[i].reset(n);
512 }
513
514 wxPluralFormsNode* wxPluralFormsNode::releaseNode(unsigned i)
515 {
516 return m_nodes[i].release();
517 }
518
519 wxPluralFormsToken::Number
520 wxPluralFormsNode::evaluate(wxPluralFormsToken::Number n) const
521 {
522 switch (token().type())
523 {
524 // leaf
525 case wxPluralFormsToken::T_NUMBER:
526 return token().number();
527 case wxPluralFormsToken::T_N:
528 return n;
529 // 2 args
530 case wxPluralFormsToken::T_EQUAL:
531 return node(0)->evaluate(n) == node(1)->evaluate(n);
532 case wxPluralFormsToken::T_NOT_EQUAL:
533 return node(0)->evaluate(n) != node(1)->evaluate(n);
534 case wxPluralFormsToken::T_GREATER:
535 return node(0)->evaluate(n) > node(1)->evaluate(n);
536 case wxPluralFormsToken::T_GREATER_OR_EQUAL:
537 return node(0)->evaluate(n) >= node(1)->evaluate(n);
538 case wxPluralFormsToken::T_LESS:
539 return node(0)->evaluate(n) < node(1)->evaluate(n);
540 case wxPluralFormsToken::T_LESS_OR_EQUAL:
541 return node(0)->evaluate(n) <= node(1)->evaluate(n);
542 case wxPluralFormsToken::T_REMINDER:
543 {
544 wxPluralFormsToken::Number number = node(1)->evaluate(n);
545 if (number != 0)
546 {
547 return node(0)->evaluate(n) % number;
548 }
549 else
550 {
551 return 0;
552 }
553 }
554 case wxPluralFormsToken::T_LOGICAL_AND:
555 return node(0)->evaluate(n) && node(1)->evaluate(n);
556 case wxPluralFormsToken::T_LOGICAL_OR:
557 return node(0)->evaluate(n) || node(1)->evaluate(n);
558 // 3 args
559 case wxPluralFormsToken::T_QUESTION:
560 return node(0)->evaluate(n)
561 ? node(1)->evaluate(n)
562 : node(2)->evaluate(n);
563 default:
564 return 0;
565 }
566 }
567
568
569 class wxPluralFormsCalculator
570 {
571 public:
572 wxPluralFormsCalculator() : m_nplurals(0), m_plural(0) {}
573
574 // input: number, returns msgstr index
575 int evaluate(int n) const;
576
577 // input: text after "Plural-Forms:" (e.g. "nplurals=2; plural=(n != 1);"),
578 // if s == 0, creates default handler
579 // returns 0 if error
580 static wxPluralFormsCalculator* make(const char* s = 0);
581
582 ~wxPluralFormsCalculator() {}
583
584 void init(wxPluralFormsToken::Number nplurals, wxPluralFormsNode* plural);
585
586 private:
587 wxPluralFormsToken::Number m_nplurals;
588 wxPluralFormsNodePtr m_plural;
589 };
590
591 wxDEFINE_SCOPED_PTR(wxPluralFormsCalculator, wxPluralFormsCalculatorPtr)
592
593 void wxPluralFormsCalculator::init(wxPluralFormsToken::Number nplurals,
594 wxPluralFormsNode* plural)
595 {
596 m_nplurals = nplurals;
597 m_plural.reset(plural);
598 }
599
600 int wxPluralFormsCalculator::evaluate(int n) const
601 {
602 if (m_plural.get() == 0)
603 {
604 return 0;
605 }
606 wxPluralFormsToken::Number number = m_plural->evaluate(n);
607 if (number < 0 || number > m_nplurals)
608 {
609 return 0;
610 }
611 return number;
612 }
613
614
615 class wxPluralFormsParser
616 {
617 public:
618 wxPluralFormsParser(wxPluralFormsScanner& scanner) : m_scanner(scanner) {}
619 bool parse(wxPluralFormsCalculator& rCalculator);
620
621 private:
622 wxPluralFormsNode* parsePlural();
623 // stops at T_SEMICOLON, returns 0 if error
624 wxPluralFormsScanner& m_scanner;
625 const wxPluralFormsToken& token() const;
626 bool nextToken();
627
628 wxPluralFormsNode* expression();
629 wxPluralFormsNode* logicalOrExpression();
630 wxPluralFormsNode* logicalAndExpression();
631 wxPluralFormsNode* equalityExpression();
632 wxPluralFormsNode* multiplicativeExpression();
633 wxPluralFormsNode* relationalExpression();
634 wxPluralFormsNode* pmExpression();
635 };
636
637 bool wxPluralFormsParser::parse(wxPluralFormsCalculator& rCalculator)
638 {
639 if (token().type() != wxPluralFormsToken::T_NPLURALS)
640 return false;
641 if (!nextToken())
642 return false;
643 if (token().type() != wxPluralFormsToken::T_ASSIGN)
644 return false;
645 if (!nextToken())
646 return false;
647 if (token().type() != wxPluralFormsToken::T_NUMBER)
648 return false;
649 wxPluralFormsToken::Number nplurals = token().number();
650 if (!nextToken())
651 return false;
652 if (token().type() != wxPluralFormsToken::T_SEMICOLON)
653 return false;
654 if (!nextToken())
655 return false;
656 if (token().type() != wxPluralFormsToken::T_PLURAL)
657 return false;
658 if (!nextToken())
659 return false;
660 if (token().type() != wxPluralFormsToken::T_ASSIGN)
661 return false;
662 if (!nextToken())
663 return false;
664 wxPluralFormsNode* plural = parsePlural();
665 if (plural == 0)
666 return false;
667 if (token().type() != wxPluralFormsToken::T_SEMICOLON)
668 return false;
669 if (!nextToken())
670 return false;
671 if (token().type() != wxPluralFormsToken::T_EOF)
672 return false;
673 rCalculator.init(nplurals, plural);
674 return true;
675 }
676
677 wxPluralFormsNode* wxPluralFormsParser::parsePlural()
678 {
679 wxPluralFormsNode* p = expression();
680 if (p == NULL)
681 {
682 return NULL;
683 }
684 wxPluralFormsNodePtr n(p);
685 if (token().type() != wxPluralFormsToken::T_SEMICOLON)
686 {
687 return NULL;
688 }
689 return n.release();
690 }
691
692 const wxPluralFormsToken& wxPluralFormsParser::token() const
693 {
694 return m_scanner.token();
695 }
696
697 bool wxPluralFormsParser::nextToken()
698 {
699 if (!m_scanner.nextToken())
700 return false;
701 return true;
702 }
703
704 wxPluralFormsNode* wxPluralFormsParser::expression()
705 {
706 wxPluralFormsNode* p = logicalOrExpression();
707 if (p == NULL)
708 return NULL;
709 wxPluralFormsNodePtr n(p);
710 if (token().type() == wxPluralFormsToken::T_QUESTION)
711 {
712 wxPluralFormsNodePtr qn(new wxPluralFormsNode(token()));
713 if (!nextToken())
714 {
715 return 0;
716 }
717 p = expression();
718 if (p == 0)
719 {
720 return 0;
721 }
722 qn->setNode(1, p);
723 if (token().type() != wxPluralFormsToken::T_COLON)
724 {
725 return 0;
726 }
727 if (!nextToken())
728 {
729 return 0;
730 }
731 p = expression();
732 if (p == 0)
733 {
734 return 0;
735 }
736 qn->setNode(2, p);
737 qn->setNode(0, n.release());
738 return qn.release();
739 }
740 return n.release();
741 }
742
743 wxPluralFormsNode*wxPluralFormsParser::logicalOrExpression()
744 {
745 wxPluralFormsNode* p = logicalAndExpression();
746 if (p == NULL)
747 return NULL;
748 wxPluralFormsNodePtr ln(p);
749 if (token().type() == wxPluralFormsToken::T_LOGICAL_OR)
750 {
751 wxPluralFormsNodePtr un(new wxPluralFormsNode(token()));
752 if (!nextToken())
753 {
754 return 0;
755 }
756 p = logicalOrExpression();
757 if (p == 0)
758 {
759 return 0;
760 }
761 wxPluralFormsNodePtr rn(p); // right
762 if (rn->token().type() == wxPluralFormsToken::T_LOGICAL_OR)
763 {
764 // see logicalAndExpression comment
765 un->setNode(0, ln.release());
766 un->setNode(1, rn->releaseNode(0));
767 rn->setNode(0, un.release());
768 return rn.release();
769 }
770
771
772 un->setNode(0, ln.release());
773 un->setNode(1, rn.release());
774 return un.release();
775 }
776 return ln.release();
777 }
778
779 wxPluralFormsNode* wxPluralFormsParser::logicalAndExpression()
780 {
781 wxPluralFormsNode* p = equalityExpression();
782 if (p == NULL)
783 return NULL;
784 wxPluralFormsNodePtr ln(p); // left
785 if (token().type() == wxPluralFormsToken::T_LOGICAL_AND)
786 {
787 wxPluralFormsNodePtr un(new wxPluralFormsNode(token())); // up
788 if (!nextToken())
789 {
790 return NULL;
791 }
792 p = logicalAndExpression();
793 if (p == 0)
794 {
795 return NULL;
796 }
797 wxPluralFormsNodePtr rn(p); // right
798 if (rn->token().type() == wxPluralFormsToken::T_LOGICAL_AND)
799 {
800 // transform 1 && (2 && 3) -> (1 && 2) && 3
801 // u r
802 // l r -> u 3
803 // 2 3 l 2
804 un->setNode(0, ln.release());
805 un->setNode(1, rn->releaseNode(0));
806 rn->setNode(0, un.release());
807 return rn.release();
808 }
809
810 un->setNode(0, ln.release());
811 un->setNode(1, rn.release());
812 return un.release();
813 }
814 return ln.release();
815 }
816
817 wxPluralFormsNode* wxPluralFormsParser::equalityExpression()
818 {
819 wxPluralFormsNode* p = relationalExpression();
820 if (p == NULL)
821 return NULL;
822 wxPluralFormsNodePtr n(p);
823 if (token().type() == wxPluralFormsToken::T_EQUAL
824 || token().type() == wxPluralFormsToken::T_NOT_EQUAL)
825 {
826 wxPluralFormsNodePtr qn(new wxPluralFormsNode(token()));
827 if (!nextToken())
828 {
829 return NULL;
830 }
831 p = relationalExpression();
832 if (p == NULL)
833 {
834 return NULL;
835 }
836 qn->setNode(1, p);
837 qn->setNode(0, n.release());
838 return qn.release();
839 }
840 return n.release();
841 }
842
843 wxPluralFormsNode* wxPluralFormsParser::relationalExpression()
844 {
845 wxPluralFormsNode* p = multiplicativeExpression();
846 if (p == NULL)
847 return NULL;
848 wxPluralFormsNodePtr n(p);
849 if (token().type() == wxPluralFormsToken::T_GREATER
850 || token().type() == wxPluralFormsToken::T_LESS
851 || token().type() == wxPluralFormsToken::T_GREATER_OR_EQUAL
852 || token().type() == wxPluralFormsToken::T_LESS_OR_EQUAL)
853 {
854 wxPluralFormsNodePtr qn(new wxPluralFormsNode(token()));
855 if (!nextToken())
856 {
857 return NULL;
858 }
859 p = multiplicativeExpression();
860 if (p == NULL)
861 {
862 return NULL;
863 }
864 qn->setNode(1, p);
865 qn->setNode(0, n.release());
866 return qn.release();
867 }
868 return n.release();
869 }
870
871 wxPluralFormsNode* wxPluralFormsParser::multiplicativeExpression()
872 {
873 wxPluralFormsNode* p = pmExpression();
874 if (p == NULL)
875 return NULL;
876 wxPluralFormsNodePtr n(p);
877 if (token().type() == wxPluralFormsToken::T_REMINDER)
878 {
879 wxPluralFormsNodePtr qn(new wxPluralFormsNode(token()));
880 if (!nextToken())
881 {
882 return NULL;
883 }
884 p = pmExpression();
885 if (p == NULL)
886 {
887 return NULL;
888 }
889 qn->setNode(1, p);
890 qn->setNode(0, n.release());
891 return qn.release();
892 }
893 return n.release();
894 }
895
896 wxPluralFormsNode* wxPluralFormsParser::pmExpression()
897 {
898 wxPluralFormsNodePtr n;
899 if (token().type() == wxPluralFormsToken::T_N
900 || token().type() == wxPluralFormsToken::T_NUMBER)
901 {
902 n.reset(new wxPluralFormsNode(token()));
903 if (!nextToken())
904 {
905 return NULL;
906 }
907 }
908 else if (token().type() == wxPluralFormsToken::T_LEFT_BRACKET) {
909 if (!nextToken())
910 {
911 return NULL;
912 }
913 wxPluralFormsNode* p = expression();
914 if (p == NULL)
915 {
916 return NULL;
917 }
918 n.reset(p);
919 if (token().type() != wxPluralFormsToken::T_RIGHT_BRACKET)
920 {
921 return NULL;
922 }
923 if (!nextToken())
924 {
925 return NULL;
926 }
927 }
928 else
929 {
930 return NULL;
931 }
932 return n.release();
933 }
934
935 wxPluralFormsCalculator* wxPluralFormsCalculator::make(const char* s)
936 {
937 wxPluralFormsCalculatorPtr calculator(new wxPluralFormsCalculator);
938 if (s != NULL)
939 {
940 wxPluralFormsScanner scanner(s);
941 wxPluralFormsParser p(scanner);
942 if (!p.parse(*calculator))
943 {
944 return NULL;
945 }
946 }
947 return calculator.release();
948 }
949
950
951
952
953 // ----------------------------------------------------------------------------
954 // wxMsgCatalogFile corresponds to one disk-file message catalog.
955 //
956 // This is a "low-level" class and is used only by wxMsgCatalog
957 // NOTE: for the documentation of the binary catalog (.MO) files refer to
958 // the GNU gettext manual:
959 // http://www.gnu.org/software/autoconf/manual/gettext/MO-Files.html
960 // ----------------------------------------------------------------------------
961
962 class wxMsgCatalogFile
963 {
964 public:
965 typedef wxScopedCharBuffer DataBuffer;
966
967 // ctor & dtor
968 wxMsgCatalogFile();
969 ~wxMsgCatalogFile();
970
971 // load the catalog from disk
972 bool LoadFile(const wxString& filename,
973 wxPluralFormsCalculatorPtr& rPluralFormsCalculator);
974 bool LoadData(const DataBuffer& data,
975 wxPluralFormsCalculatorPtr& rPluralFormsCalculator);
976
977 // fills the hash with string-translation pairs
978 bool FillHash(wxStringToStringHashMap& hash, const wxString& domain) const;
979
980 // return the charset of the strings in this catalog or empty string if
981 // none/unknown
982 wxString GetCharset() const { return m_charset; }
983
984 private:
985 // this implementation is binary compatible with GNU gettext() version 0.10
986
987 // an entry in the string table
988 struct wxMsgTableEntry
989 {
990 size_t32 nLen; // length of the string
991 size_t32 ofsString; // pointer to the string
992 };
993
994 // header of a .mo file
995 struct wxMsgCatalogHeader
996 {
997 size_t32 magic, // offset +00: magic id
998 revision, // +04: revision
999 numStrings; // +08: number of strings in the file
1000 size_t32 ofsOrigTable, // +0C: start of original string table
1001 ofsTransTable; // +10: start of translated string table
1002 size_t32 nHashSize, // +14: hash table size
1003 ofsHashTable; // +18: offset of hash table start
1004 };
1005
1006 // all data is stored here
1007 DataBuffer m_data;
1008
1009 // data description
1010 size_t32 m_numStrings; // number of strings in this domain
1011 wxMsgTableEntry *m_pOrigTable, // pointer to original strings
1012 *m_pTransTable; // translated
1013
1014 wxString m_charset; // from the message catalog header
1015
1016
1017 // swap the 2 halves of 32 bit integer if needed
1018 size_t32 Swap(size_t32 ui) const
1019 {
1020 return m_bSwapped ? (ui << 24) | ((ui & 0xff00) << 8) |
1021 ((ui >> 8) & 0xff00) | (ui >> 24)
1022 : ui;
1023 }
1024
1025 const char *StringAtOfs(wxMsgTableEntry *pTable, size_t32 n) const
1026 {
1027 const wxMsgTableEntry * const ent = pTable + n;
1028
1029 // this check could fail for a corrupt message catalog
1030 size_t32 ofsString = Swap(ent->ofsString);
1031 if ( ofsString + Swap(ent->nLen) > m_data.length())
1032 {
1033 return NULL;
1034 }
1035
1036 return m_data.data() + ofsString;
1037 }
1038
1039 bool m_bSwapped; // wrong endianness?
1040
1041 wxDECLARE_NO_COPY_CLASS(wxMsgCatalogFile);
1042 };
1043
1044 // ----------------------------------------------------------------------------
1045 // wxMsgCatalogFile class
1046 // ----------------------------------------------------------------------------
1047
1048 wxMsgCatalogFile::wxMsgCatalogFile()
1049 {
1050 }
1051
1052 wxMsgCatalogFile::~wxMsgCatalogFile()
1053 {
1054 }
1055
1056 // open disk file and read in it's contents
1057 bool wxMsgCatalogFile::LoadFile(const wxString& filename,
1058 wxPluralFormsCalculatorPtr& rPluralFormsCalculator)
1059 {
1060 wxFile fileMsg(filename);
1061 if ( !fileMsg.IsOpened() )
1062 return false;
1063
1064 // get the file size (assume it is less than 4GB...)
1065 wxFileOffset lenFile = fileMsg.Length();
1066 if ( lenFile == wxInvalidOffset )
1067 return false;
1068
1069 size_t nSize = wx_truncate_cast(size_t, lenFile);
1070 wxASSERT_MSG( nSize == lenFile + size_t(0), wxS("message catalog bigger than 4GB?") );
1071
1072 wxMemoryBuffer filedata;
1073
1074 // read the whole file in memory
1075 if ( fileMsg.Read(filedata.GetWriteBuf(nSize), nSize) != lenFile )
1076 return false;
1077
1078 filedata.UngetWriteBuf(nSize);
1079
1080 bool ok = LoadData
1081 (
1082 DataBuffer::CreateOwned((char*)filedata.release(), nSize),
1083 rPluralFormsCalculator
1084 );
1085 if ( !ok )
1086 {
1087 wxLogWarning(_("'%s' is not a valid message catalog."), filename.c_str());
1088 return false;
1089 }
1090
1091 return true;
1092 }
1093
1094
1095 bool wxMsgCatalogFile::LoadData(const DataBuffer& data,
1096 wxPluralFormsCalculatorPtr& rPluralFormsCalculator)
1097 {
1098 // examine header
1099 bool bValid = data.length() > sizeof(wxMsgCatalogHeader);
1100
1101 const wxMsgCatalogHeader *pHeader = (wxMsgCatalogHeader *)data.data();
1102 if ( bValid ) {
1103 // we'll have to swap all the integers if it's true
1104 m_bSwapped = pHeader->magic == MSGCATALOG_MAGIC_SW;
1105
1106 // check the magic number
1107 bValid = m_bSwapped || pHeader->magic == MSGCATALOG_MAGIC;
1108 }
1109
1110 if ( !bValid ) {
1111 // it's either too short or has incorrect magic number
1112 wxLogWarning(_("Invalid message catalog."));
1113 return false;
1114 }
1115
1116 m_data = data;
1117
1118 // initialize
1119 m_numStrings = Swap(pHeader->numStrings);
1120 m_pOrigTable = (wxMsgTableEntry *)(data.data() +
1121 Swap(pHeader->ofsOrigTable));
1122 m_pTransTable = (wxMsgTableEntry *)(data.data() +
1123 Swap(pHeader->ofsTransTable));
1124
1125 // now parse catalog's header and try to extract catalog charset and
1126 // plural forms formula from it:
1127
1128 const char* headerData = StringAtOfs(m_pOrigTable, 0);
1129 if ( headerData && headerData[0] == '\0' )
1130 {
1131 // Extract the charset:
1132 const char * const header = StringAtOfs(m_pTransTable, 0);
1133 const char *
1134 cset = strstr(header, "Content-Type: text/plain; charset=");
1135 if ( cset )
1136 {
1137 cset += 34; // strlen("Content-Type: text/plain; charset=")
1138
1139 const char * const csetEnd = strchr(cset, '\n');
1140 if ( csetEnd )
1141 {
1142 m_charset = wxString(cset, csetEnd - cset);
1143 if ( m_charset == wxS("CHARSET") )
1144 {
1145 // "CHARSET" is not valid charset, but lazy translator
1146 m_charset.clear();
1147 }
1148 }
1149 }
1150 // else: incorrectly filled Content-Type header
1151
1152 // Extract plural forms:
1153 const char * plurals = strstr(header, "Plural-Forms:");
1154 if ( plurals )
1155 {
1156 plurals += 13; // strlen("Plural-Forms:")
1157 const char * const pluralsEnd = strchr(plurals, '\n');
1158 if ( pluralsEnd )
1159 {
1160 const size_t pluralsLen = pluralsEnd - plurals;
1161 wxCharBuffer buf(pluralsLen);
1162 strncpy(buf.data(), plurals, pluralsLen);
1163 wxPluralFormsCalculator * const
1164 pCalculator = wxPluralFormsCalculator::make(buf);
1165 if ( pCalculator )
1166 {
1167 rPluralFormsCalculator.reset(pCalculator);
1168 }
1169 else
1170 {
1171 wxLogVerbose(_("Failed to parse Plural-Forms: '%s'"),
1172 buf.data());
1173 }
1174 }
1175 }
1176
1177 if ( !rPluralFormsCalculator.get() )
1178 rPluralFormsCalculator.reset(wxPluralFormsCalculator::make());
1179 }
1180
1181 // everything is fine
1182 return true;
1183 }
1184
1185 bool wxMsgCatalogFile::FillHash(wxStringToStringHashMap& hash,
1186 const wxString& domain) const
1187 {
1188 wxUnusedVar(domain); // silence warning in Unicode build
1189
1190 // conversion to use to convert catalog strings to the GUI encoding
1191 wxMBConv *inputConv = NULL;
1192 wxMBConv *inputConvPtr = NULL; // same as inputConv but safely deleteable
1193
1194 if ( !m_charset.empty() )
1195 {
1196 #if !wxUSE_UNICODE && wxUSE_FONTMAP
1197 // determine if we need any conversion at all
1198 wxFontEncoding encCat = wxFontMapperBase::GetEncodingFromName(m_charset);
1199 if ( encCat != wxLocale::GetSystemEncoding() )
1200 #endif
1201 {
1202 inputConvPtr =
1203 inputConv = new wxCSConv(m_charset);
1204 }
1205 }
1206 else // no need or not possible to convert the encoding
1207 {
1208 #if wxUSE_UNICODE
1209 // we must somehow convert the narrow strings in the message catalog to
1210 // wide strings, so use the default conversion if we have no charset
1211 inputConv = wxConvCurrent;
1212 #endif
1213 }
1214
1215 #if !wxUSE_UNICODE
1216 wxString msgIdCharset = gs_msgIdCharset[domain];
1217
1218 // conversion to apply to msgid strings before looking them up: we only
1219 // need it if the msgids are neither in 7 bit ASCII nor in the same
1220 // encoding as the catalog
1221 wxCSConv *sourceConv = msgIdCharset.empty() || (msgIdCharset == m_charset)
1222 ? NULL
1223 : new wxCSConv(msgIdCharset);
1224 #endif // !wxUSE_UNICODE
1225
1226 for (size_t32 i = 0; i < m_numStrings; i++)
1227 {
1228 const char *data = StringAtOfs(m_pOrigTable, i);
1229 if (!data)
1230 return false; // may happen for invalid MO files
1231
1232 wxString msgid;
1233 #if wxUSE_UNICODE
1234 msgid = wxString(data, *inputConv);
1235 #else // ASCII
1236 if ( inputConv && sourceConv )
1237 msgid = wxString(inputConv->cMB2WC(data), *sourceConv);
1238 else
1239 msgid = data;
1240 #endif // wxUSE_UNICODE
1241
1242 data = StringAtOfs(m_pTransTable, i);
1243 if (!data)
1244 return false; // may happen for invalid MO files
1245
1246 size_t length = Swap(m_pTransTable[i].nLen);
1247 size_t offset = 0;
1248 size_t index = 0;
1249 while (offset < length)
1250 {
1251 const char * const str = data + offset;
1252
1253 wxString msgstr;
1254 #if wxUSE_UNICODE
1255 msgstr = wxString(str, *inputConv);
1256 #else
1257 if ( inputConv )
1258 msgstr = wxString(inputConv->cMB2WC(str), *wxConvUI);
1259 else
1260 msgstr = str;
1261 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1262
1263 if ( !msgstr.empty() )
1264 {
1265 hash[index == 0 ? msgid : msgid + wxChar(index)] = msgstr;
1266 }
1267
1268 // skip this string
1269 // IMPORTANT: accesses to the 'data' pointer are valid only for
1270 // the first 'length+1' bytes (GNU specs says that the
1271 // final NUL is not counted in length); using wxStrnlen()
1272 // we make sure we don't access memory beyond the valid range
1273 // (which otherwise may happen for invalid MO files):
1274 offset += wxStrnlen(str, length - offset) + 1;
1275 ++index;
1276 }
1277 }
1278
1279 #if !wxUSE_UNICODE
1280 delete sourceConv;
1281 #endif
1282 delete inputConvPtr;
1283
1284 return true;
1285 }
1286
1287
1288 // ----------------------------------------------------------------------------
1289 // wxMsgCatalog class
1290 // ----------------------------------------------------------------------------
1291
1292 #if !wxUSE_UNICODE
1293 wxMsgCatalog::~wxMsgCatalog()
1294 {
1295 if ( m_conv )
1296 {
1297 if ( wxConvUI == m_conv )
1298 {
1299 // we only change wxConvUI if it points to wxConvLocal so we reset
1300 // it back to it too
1301 wxConvUI = &wxConvLocal;
1302 }
1303
1304 delete m_conv;
1305 }
1306 }
1307 #endif // !wxUSE_UNICODE
1308
1309 /* static */
1310 wxMsgCatalog *wxMsgCatalog::CreateFromFile(const wxString& filename,
1311 const wxString& domain)
1312 {
1313 wxScopedPtr<wxMsgCatalog> cat(new wxMsgCatalog(domain));
1314
1315 wxMsgCatalogFile file;
1316
1317 if ( !file.LoadFile(filename, cat->m_pluralFormsCalculator) )
1318 return NULL;
1319
1320 if ( !file.FillHash(cat->m_messages, domain) )
1321 return NULL;
1322
1323 return cat.release();
1324 }
1325
1326 /* static */
1327 wxMsgCatalog *wxMsgCatalog::CreateFromData(const wxScopedCharBuffer& data,
1328 const wxString& domain)
1329 {
1330 wxScopedPtr<wxMsgCatalog> cat(new wxMsgCatalog(domain));
1331
1332 wxMsgCatalogFile file;
1333
1334 if ( !file.LoadData(data, cat->m_pluralFormsCalculator) )
1335 return NULL;
1336
1337 if ( !file.FillHash(cat->m_messages, domain) )
1338 return NULL;
1339
1340 return cat.release();
1341 }
1342
1343 const wxString *wxMsgCatalog::GetString(const wxString& str, unsigned n) const
1344 {
1345 int index = 0;
1346 if (n != UINT_MAX)
1347 {
1348 index = m_pluralFormsCalculator->evaluate(n);
1349 }
1350 wxStringToStringHashMap::const_iterator i;
1351 if (index != 0)
1352 {
1353 i = m_messages.find(wxString(str) + wxChar(index)); // plural
1354 }
1355 else
1356 {
1357 i = m_messages.find(str);
1358 }
1359
1360 if ( i != m_messages.end() )
1361 {
1362 return &i->second;
1363 }
1364 else
1365 return NULL;
1366 }
1367
1368
1369 // ----------------------------------------------------------------------------
1370 // wxTranslations
1371 // ----------------------------------------------------------------------------
1372
1373 namespace
1374 {
1375
1376 wxTranslations *gs_translations = NULL;
1377 bool gs_translationsOwned = false;
1378
1379 } // anonymous namespace
1380
1381
1382 /*static*/
1383 wxTranslations *wxTranslations::Get()
1384 {
1385 return gs_translations;
1386 }
1387
1388 /*static*/
1389 void wxTranslations::Set(wxTranslations *t)
1390 {
1391 if ( gs_translationsOwned )
1392 delete gs_translations;
1393 gs_translations = t;
1394 gs_translationsOwned = true;
1395 }
1396
1397 /*static*/
1398 void wxTranslations::SetNonOwned(wxTranslations *t)
1399 {
1400 if ( gs_translationsOwned )
1401 delete gs_translations;
1402 gs_translations = t;
1403 gs_translationsOwned = false;
1404 }
1405
1406
1407 wxTranslations::wxTranslations()
1408 {
1409 m_pMsgCat = NULL;
1410 m_loader = new wxFileTranslationsLoader;
1411 }
1412
1413
1414 wxTranslations::~wxTranslations()
1415 {
1416 delete m_loader;
1417
1418 // free catalogs memory
1419 wxMsgCatalog *pTmpCat;
1420 while ( m_pMsgCat != NULL )
1421 {
1422 pTmpCat = m_pMsgCat;
1423 m_pMsgCat = m_pMsgCat->m_pNext;
1424 delete pTmpCat;
1425 }
1426 }
1427
1428
1429 void wxTranslations::SetLoader(wxTranslationsLoader *loader)
1430 {
1431 wxCHECK_RET( loader, "loader can't be NULL" );
1432
1433 delete m_loader;
1434 m_loader = loader;
1435 }
1436
1437
1438 void wxTranslations::SetLanguage(wxLanguage lang)
1439 {
1440 if ( lang == wxLANGUAGE_DEFAULT )
1441 SetLanguage("");
1442 else
1443 SetLanguage(wxLocale::GetLanguageCanonicalName(lang));
1444 }
1445
1446 void wxTranslations::SetLanguage(const wxString& lang)
1447 {
1448 m_lang = lang;
1449 }
1450
1451
1452 wxArrayString wxTranslations::GetAvailableTranslations(const wxString& domain) const
1453 {
1454 wxCHECK_MSG( m_loader, wxArrayString(), "loader can't be NULL" );
1455
1456 return m_loader->GetAvailableTranslations(domain);
1457 }
1458
1459
1460 bool wxTranslations::AddStdCatalog()
1461 {
1462 if ( !AddCatalog(wxS("wxstd")) )
1463 return false;
1464
1465 // there may be a catalog with toolkit specific overrides, it is not
1466 // an error if this does not exist
1467 wxString port(wxPlatformInfo::Get().GetPortIdName());
1468 if ( !port.empty() )
1469 {
1470 AddCatalog(port.BeforeFirst(wxS('/')).MakeLower());
1471 }
1472
1473 return true;
1474 }
1475
1476
1477 bool wxTranslations::AddCatalog(const wxString& domain)
1478 {
1479 return AddCatalog(domain, wxLANGUAGE_ENGLISH_US);
1480 }
1481
1482 #if !wxUSE_UNICODE
1483 bool wxTranslations::AddCatalog(const wxString& domain,
1484 wxLanguage msgIdLanguage,
1485 const wxString& msgIdCharset)
1486 {
1487 gs_msgIdCharset[domain] = msgIdCharset;
1488 return AddCatalog(domain, msgIdLanguage);
1489 }
1490 #endif // !wxUSE_UNICODE
1491
1492 bool wxTranslations::AddCatalog(const wxString& domain,
1493 wxLanguage msgIdLanguage)
1494 {
1495 const wxString msgIdLang = wxLocale::GetLanguageCanonicalName(msgIdLanguage);
1496 const wxString domain_lang = GetBestTranslation(domain, msgIdLang);
1497
1498 if ( domain_lang.empty() )
1499 {
1500 wxLogTrace(TRACE_I18N,
1501 wxS("no suitable translation for domain '%s' found"),
1502 domain);
1503 return false;
1504 }
1505
1506 wxLogTrace(TRACE_I18N,
1507 wxS("adding '%s' translation for domain '%s' (msgid language '%s')"),
1508 domain_lang, domain, msgIdLang);
1509
1510 // It is OK to not load catalog if the msgid language and m_language match,
1511 // in which case we can directly display the texts embedded in program's
1512 // source code:
1513 if ( msgIdLang == domain_lang )
1514 return true;
1515
1516 return LoadCatalog(domain, domain_lang);
1517 }
1518
1519
1520 bool wxTranslations::LoadCatalog(const wxString& domain, const wxString& lang)
1521 {
1522 wxCHECK_MSG( m_loader, false, "loader can't be NULL" );
1523
1524 wxMsgCatalog *cat = NULL;
1525
1526 #if wxUSE_FONTMAP
1527 // first look for the catalog for this language and the current locale:
1528 // notice that we don't use the system name for the locale as this would
1529 // force us to install catalogs in different locations depending on the
1530 // system but always use the canonical name
1531 wxFontEncoding encSys = wxLocale::GetSystemEncoding();
1532 if ( encSys != wxFONTENCODING_SYSTEM )
1533 {
1534 wxString fullname(lang);
1535 fullname << wxS('.') << wxFontMapperBase::GetEncodingName(encSys);
1536
1537 cat = m_loader->LoadCatalog(domain, fullname);
1538 }
1539 #endif // wxUSE_FONTMAP
1540
1541 if ( !cat )
1542 {
1543 // Next try: use the provided name language name:
1544 cat = m_loader->LoadCatalog(domain, lang);
1545 }
1546
1547 if ( !cat )
1548 {
1549 // Also try just base locale name: for things like "fr_BE" (Belgium
1550 // French) we should use fall back on plain "fr" if no Belgium-specific
1551 // message catalogs exist
1552 wxString baselang = lang.BeforeFirst('_');
1553 if ( lang != baselang )
1554 cat = m_loader->LoadCatalog(domain, baselang);
1555 }
1556
1557 if ( cat )
1558 {
1559 // add it to the head of the list so that in GetString it will
1560 // be searched before the catalogs added earlier
1561 cat->m_pNext = m_pMsgCat;
1562 m_pMsgCat = cat;
1563
1564 return true;
1565 }
1566 else
1567 {
1568 // Nothing worked, the catalog just isn't there
1569 wxLogTrace(TRACE_I18N,
1570 "Catalog \"%s.mo\" not found for language \"%s\".",
1571 domain, lang);
1572 return false;
1573 }
1574 }
1575
1576 // check if the given catalog is loaded
1577 bool wxTranslations::IsLoaded(const wxString& domain) const
1578 {
1579 return FindCatalog(domain) != NULL;
1580 }
1581
1582 wxString wxTranslations::GetBestTranslation(const wxString& domain,
1583 wxLanguage msgIdLanguage)
1584 {
1585 const wxString lang = wxLocale::GetLanguageCanonicalName(msgIdLanguage);
1586 return GetBestTranslation(domain, lang);
1587 }
1588
1589 wxString wxTranslations::GetBestTranslation(const wxString& domain,
1590 const wxString& msgIdLanguage)
1591 {
1592 // explicitly set language should always be respected
1593 if ( !m_lang.empty() )
1594 return m_lang;
1595
1596 wxArrayString available(GetAvailableTranslations(domain));
1597 // it's OK to have duplicates, so just add msgid language
1598 available.push_back(msgIdLanguage);
1599 available.push_back(msgIdLanguage.BeforeFirst('_'));
1600
1601 wxLogTrace(TRACE_I18N, "choosing best language for domain '%s'", domain);
1602 LogTraceArray(" - available translations", available);
1603 const wxString lang = GetPreferredUILanguage(available);
1604 wxLogTrace(TRACE_I18N, " => using language '%s'", lang);
1605 return lang;
1606 }
1607
1608
1609 namespace
1610 {
1611 WX_DECLARE_HASH_SET(wxString, wxStringHash, wxStringEqual,
1612 wxLocaleUntranslatedStrings);
1613 }
1614
1615 /* static */
1616 const wxString& wxTranslations::GetUntranslatedString(const wxString& str)
1617 {
1618 static wxLocaleUntranslatedStrings s_strings;
1619
1620 wxLocaleUntranslatedStrings::iterator i = s_strings.find(str);
1621 if ( i == s_strings.end() )
1622 return *s_strings.insert(str).first;
1623
1624 return *i;
1625 }
1626
1627
1628 const wxString& wxTranslations::GetString(const wxString& origString,
1629 const wxString& domain) const
1630 {
1631 return GetString(origString, origString, UINT_MAX, domain);
1632 }
1633
1634 const wxString& wxTranslations::GetString(const wxString& origString,
1635 const wxString& origString2,
1636 unsigned n,
1637 const wxString& domain) const
1638 {
1639 if ( origString.empty() )
1640 return GetUntranslatedString(origString);
1641
1642 const wxString *trans = NULL;
1643 wxMsgCatalog *pMsgCat;
1644
1645 if ( !domain.empty() )
1646 {
1647 pMsgCat = FindCatalog(domain);
1648
1649 // does the catalog exist?
1650 if ( pMsgCat != NULL )
1651 trans = pMsgCat->GetString(origString, n);
1652 }
1653 else
1654 {
1655 // search in all domains
1656 for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext )
1657 {
1658 trans = pMsgCat->GetString(origString, n);
1659 if ( trans != NULL ) // take the first found
1660 break;
1661 }
1662 }
1663
1664 if ( trans == NULL )
1665 {
1666 wxLogTrace
1667 (
1668 TRACE_I18N,
1669 "string \"%s\"%s not found in %slocale '%s'.",
1670 origString,
1671 (n != UINT_MAX ? wxString::Format("[%ld]", (long)n) : wxString()),
1672 (!domain.empty() ? wxString::Format("domain '%s' ", domain) : wxString()),
1673 m_lang
1674 );
1675
1676 if (n == UINT_MAX)
1677 return GetUntranslatedString(origString);
1678 else
1679 return GetUntranslatedString(n == 1 ? origString : origString2);
1680 }
1681
1682 return *trans;
1683 }
1684
1685
1686 wxString wxTranslations::GetHeaderValue(const wxString& header,
1687 const wxString& domain) const
1688 {
1689 if ( header.empty() )
1690 return wxEmptyString;
1691
1692 const wxString *trans = NULL;
1693 wxMsgCatalog *pMsgCat;
1694
1695 if ( !domain.empty() )
1696 {
1697 pMsgCat = FindCatalog(domain);
1698
1699 // does the catalog exist?
1700 if ( pMsgCat == NULL )
1701 return wxEmptyString;
1702
1703 trans = pMsgCat->GetString(wxEmptyString, UINT_MAX);
1704 }
1705 else
1706 {
1707 // search in all domains
1708 for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext )
1709 {
1710 trans = pMsgCat->GetString(wxEmptyString, UINT_MAX);
1711 if ( trans != NULL ) // take the first found
1712 break;
1713 }
1714 }
1715
1716 if ( !trans || trans->empty() )
1717 return wxEmptyString;
1718
1719 size_t found = trans->find(header);
1720 if ( found == wxString::npos )
1721 return wxEmptyString;
1722
1723 found += header.length() + 2 /* ': ' */;
1724
1725 // Every header is separated by \n
1726
1727 size_t endLine = trans->find(wxS('\n'), found);
1728 size_t len = (endLine == wxString::npos) ?
1729 wxString::npos : (endLine - found);
1730
1731 return trans->substr(found, len);
1732 }
1733
1734
1735 // find catalog by name in a linked list, return NULL if !found
1736 wxMsgCatalog *wxTranslations::FindCatalog(const wxString& domain) const
1737 {
1738 // linear search in the linked list
1739 wxMsgCatalog *pMsgCat;
1740 for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext )
1741 {
1742 if ( pMsgCat->GetDomain() == domain )
1743 return pMsgCat;
1744 }
1745
1746 return NULL;
1747 }
1748
1749 // ----------------------------------------------------------------------------
1750 // wxFileTranslationsLoader
1751 // ----------------------------------------------------------------------------
1752
1753 namespace
1754 {
1755
1756 // the list of the directories to search for message catalog files
1757 wxArrayString gs_searchPrefixes;
1758
1759 // return the directories to search for message catalogs under the given
1760 // prefix, separated by wxPATH_SEP
1761 wxString GetMsgCatalogSubdirs(const wxString& prefix, const wxString& lang)
1762 {
1763 // Search first in Unix-standard prefix/lang/LC_MESSAGES, then in
1764 // prefix/lang.
1765 //
1766 // Note that we use LC_MESSAGES on all platforms and not just Unix, because
1767 // it doesn't cost much to look into one more directory and doing it this
1768 // way has two important benefits:
1769 // a) we don't break compatibility with wx-2.6 and older by stopping to
1770 // look in a directory where the catalogs used to be and thus silently
1771 // breaking apps after they are recompiled against the latest wx
1772 // b) it makes it possible to package app's support files in the same
1773 // way on all target platforms
1774 const wxString prefixAndLang = wxFileName(prefix, lang).GetFullPath();
1775
1776 wxString searchPath;
1777 searchPath.reserve(4*prefixAndLang.length());
1778
1779 searchPath
1780 #ifdef __WXOSX__
1781 << prefixAndLang << ".lproj/LC_MESSAGES" << wxPATH_SEP
1782 << prefixAndLang << ".lproj" << wxPATH_SEP
1783 #endif
1784 << prefixAndLang << wxFILE_SEP_PATH << "LC_MESSAGES" << wxPATH_SEP
1785 << prefixAndLang << wxPATH_SEP
1786 ;
1787
1788 return searchPath;
1789 }
1790
1791 bool HasMsgCatalogInDir(const wxString& dir, const wxString& domain)
1792 {
1793 return wxFileName(dir, domain, "mo").FileExists() ||
1794 wxFileName(dir + wxFILE_SEP_PATH + "LC_MESSAGES", domain, "mo").FileExists();
1795 }
1796
1797 // get prefixes to locale directories; if lang is empty, don't point to
1798 // OSX's .lproj bundles
1799 wxArrayString GetSearchPrefixes()
1800 {
1801 wxArrayString paths;
1802
1803 // first take the entries explicitly added by the program
1804 paths = gs_searchPrefixes;
1805
1806 #if wxUSE_STDPATHS
1807 // then look in the standard location
1808 wxString stdp;
1809 stdp = wxStandardPaths::Get().GetResourcesDir();
1810 if ( paths.Index(stdp) == wxNOT_FOUND )
1811 paths.Add(stdp);
1812 #endif // wxUSE_STDPATHS
1813
1814 // last look in default locations
1815 #ifdef __UNIX__
1816 // LC_PATH is a standard env var containing the search path for the .mo
1817 // files
1818 const char *pszLcPath = wxGetenv("LC_PATH");
1819 if ( pszLcPath )
1820 {
1821 const wxString lcp = pszLcPath;
1822 if ( paths.Index(lcp) == wxNOT_FOUND )
1823 paths.Add(lcp);
1824 }
1825
1826 // also add the one from where wxWin was installed:
1827 wxString wxp = wxGetInstallPrefix();
1828 if ( !wxp.empty() )
1829 {
1830 wxp += wxS("/share/locale");
1831 if ( paths.Index(wxp) == wxNOT_FOUND )
1832 paths.Add(wxp);
1833 }
1834 #endif // __UNIX__
1835
1836 return paths;
1837 }
1838
1839 // construct the search path for the given language
1840 wxString GetFullSearchPath(const wxString& lang)
1841 {
1842 wxString searchPath;
1843 searchPath.reserve(500);
1844
1845 const wxArrayString prefixes = GetSearchPrefixes();
1846
1847 for ( wxArrayString::const_iterator i = prefixes.begin();
1848 i != prefixes.end();
1849 ++i )
1850 {
1851 const wxString p = GetMsgCatalogSubdirs(*i, lang);
1852
1853 if ( !searchPath.empty() )
1854 searchPath += wxPATH_SEP;
1855 searchPath += p;
1856 }
1857
1858 return searchPath;
1859 }
1860
1861 } // anonymous namespace
1862
1863
1864 void wxFileTranslationsLoader::AddCatalogLookupPathPrefix(const wxString& prefix)
1865 {
1866 if ( gs_searchPrefixes.Index(prefix) == wxNOT_FOUND )
1867 {
1868 gs_searchPrefixes.Add(prefix);
1869 }
1870 //else: already have it
1871 }
1872
1873
1874 wxMsgCatalog *wxFileTranslationsLoader::LoadCatalog(const wxString& domain,
1875 const wxString& lang)
1876 {
1877 wxString searchPath = GetFullSearchPath(lang);
1878
1879 LogTraceLargeArray
1880 (
1881 wxString::Format("looking for \"%s.mo\" in search path", domain),
1882 wxSplit(searchPath, wxPATH_SEP[0])
1883 );
1884
1885 wxFileName fn(domain);
1886 fn.SetExt(wxS("mo"));
1887
1888 wxString strFullName;
1889 if ( !wxFindFileInPath(&strFullName, searchPath, fn.GetFullPath()) )
1890 return NULL;
1891
1892 // open file and read its data
1893 wxLogVerbose(_("using catalog '%s' from '%s'."), domain, strFullName.c_str());
1894 wxLogTrace(TRACE_I18N, wxS("Using catalog \"%s\"."), strFullName.c_str());
1895
1896 return wxMsgCatalog::CreateFromFile(strFullName, domain);
1897 }
1898
1899
1900 wxArrayString wxFileTranslationsLoader::GetAvailableTranslations(const wxString& domain) const
1901 {
1902 wxArrayString langs;
1903 const wxArrayString prefixes = GetSearchPrefixes();
1904
1905 LogTraceLargeArray
1906 (
1907 wxString::Format("looking for available translations of \"%s\" in search path", domain),
1908 prefixes
1909 );
1910
1911 for ( wxArrayString::const_iterator i = prefixes.begin();
1912 i != prefixes.end();
1913 ++i )
1914 {
1915 if ( i->empty() )
1916 continue;
1917 wxDir dir;
1918 if ( !dir.Open(*i) )
1919 continue;
1920
1921 wxString lang;
1922 for ( bool ok = dir.GetFirst(&lang, "", wxDIR_DIRS);
1923 ok;
1924 ok = dir.GetNext(&lang) )
1925 {
1926 const wxString langdir = *i + wxFILE_SEP_PATH + lang;
1927 if ( HasMsgCatalogInDir(langdir, domain) )
1928 {
1929 #ifdef __WXOSX__
1930 wxString rest;
1931 if ( lang.EndsWith(".lproj", &rest) )
1932 lang = rest;
1933 #endif // __WXOSX__
1934
1935 wxLogTrace(TRACE_I18N,
1936 "found %s translation of \"%s\" in %s",
1937 lang, domain, langdir);
1938 langs.push_back(lang);
1939 }
1940 }
1941 }
1942
1943 return langs;
1944 }
1945
1946
1947 // ----------------------------------------------------------------------------
1948 // wxResourceTranslationsLoader
1949 // ----------------------------------------------------------------------------
1950
1951 #ifdef __WINDOWS__
1952
1953 wxMsgCatalog *wxResourceTranslationsLoader::LoadCatalog(const wxString& domain,
1954 const wxString& lang)
1955 {
1956 const void *mo_data = NULL;
1957 size_t mo_size = 0;
1958
1959 const wxString resname = wxString::Format("%s_%s", domain, lang);
1960
1961 if ( !wxLoadUserResource(&mo_data, &mo_size,
1962 resname,
1963 GetResourceType().t_str(),
1964 GetModule()) )
1965 return NULL;
1966
1967 wxLogTrace(TRACE_I18N,
1968 "Using catalog from Windows resource \"%s\".", resname);
1969
1970 wxMsgCatalog *cat = wxMsgCatalog::CreateFromData(
1971 wxCharBuffer::CreateNonOwned(static_cast<const char*>(mo_data), mo_size),
1972 domain);
1973
1974 if ( !cat )
1975 {
1976 wxLogWarning(_("Resource '%s' is not a valid message catalog."), resname);
1977 }
1978
1979 return cat;
1980 }
1981
1982 namespace
1983 {
1984
1985 struct EnumCallbackData
1986 {
1987 wxString prefix;
1988 wxArrayString langs;
1989 };
1990
1991 BOOL CALLBACK EnumTranslations(HMODULE WXUNUSED(hModule),
1992 LPCTSTR WXUNUSED(lpszType),
1993 LPTSTR lpszName,
1994 LONG_PTR lParam)
1995 {
1996 wxString name(lpszName);
1997 name.MakeLower(); // resource names are case insensitive
1998
1999 EnumCallbackData *data = reinterpret_cast<EnumCallbackData*>(lParam);
2000
2001 wxString lang;
2002 if ( name.StartsWith(data->prefix, &lang) && !lang.empty() )
2003 data->langs.push_back(lang);
2004
2005 return TRUE; // continue enumeration
2006 }
2007
2008 } // anonymous namespace
2009
2010
2011 wxArrayString wxResourceTranslationsLoader::GetAvailableTranslations(const wxString& domain) const
2012 {
2013 EnumCallbackData data;
2014 data.prefix = domain + "_";
2015 data.prefix.MakeLower(); // resource names are case insensitive
2016
2017 if ( !EnumResourceNames(GetModule(),
2018 GetResourceType().t_str(),
2019 EnumTranslations,
2020 reinterpret_cast<LONG_PTR>(&data)) )
2021 {
2022 const DWORD err = GetLastError();
2023 if ( err != NO_ERROR && err != ERROR_RESOURCE_TYPE_NOT_FOUND )
2024 {
2025 wxLogSysError(_("Couldn't enumerate translations"));
2026 }
2027 }
2028
2029 return data.langs;
2030 }
2031
2032 #endif // __WINDOWS__
2033
2034
2035 // ----------------------------------------------------------------------------
2036 // wxTranslationsModule module (for destruction of gs_translations)
2037 // ----------------------------------------------------------------------------
2038
2039 class wxTranslationsModule: public wxModule
2040 {
2041 DECLARE_DYNAMIC_CLASS(wxTranslationsModule)
2042 public:
2043 wxTranslationsModule() {}
2044
2045 bool OnInit()
2046 {
2047 return true;
2048 }
2049
2050 void OnExit()
2051 {
2052 if ( gs_translationsOwned )
2053 delete gs_translations;
2054 gs_translations = NULL;
2055 gs_translationsOwned = true;
2056 }
2057 };
2058
2059 IMPLEMENT_DYNAMIC_CLASS(wxTranslationsModule, wxModule)
2060
2061 #endif // wxUSE_INTL
wxWidgets (Impactor)