]>
Commit | Line | Data |
---|---|---|
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 wxString& 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 |