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


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