nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1998 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 */
17  
18 /*
19 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
20 * file for a list of people on the GLib Team. See the ChangeLog
21 * files for a list of changes. These files are distributed with
22 * GLib at ftp://ftp.gtk.org/pub/gtk/.
23 */
24  
25 #include "config.h"
26  
27 #include "ggettext.h"
28 #include "glibintl.h"
29 #include "glib-private.h"
30  
31 #include "galloca.h"
32 #include "gthread.h"
33 #include "gmem.h"
34 #ifdef G_OS_WIN32
35 #include "gwin32.h"
36 #include "gfileutils.h"
37 #include "gstrfuncs.h"
38 #include "glib-init.h"
39 #endif
40  
41 #include <string.h>
42 #include <locale.h>
43 #include <libintl.h>
44  
45 #ifdef G_OS_WIN32
46  
47 /**
48 * _glib_get_locale_dir:
49 *
50 * Return the path to the share\locale or lib\locale subfolder of the
51 * GLib installation folder. The path is in the system codepage. We
52 * have to use system codepage as bindtextdomain() doesn't have a
53 * UTF-8 interface.
54 */
55 gchar *
56 _glib_get_locale_dir (void)
57 {
58 gchar *install_dir = NULL, *locale_dir;
59 gchar *retval = NULL;
60  
61 if (glib_dll != NULL)
62 install_dir = g_win32_get_package_installation_directory_of_module (glib_dll);
63  
64 if (install_dir)
65 {
66 /*
67 * Append "/share/locale" or "/lib/locale" depending on whether
68 * autoconfigury detected GNU gettext or not.
69 */
70 const char *p = GLIB_LOCALE_DIR + strlen (GLIB_LOCALE_DIR);
71 while (*--p != '/')
72 ;
73 while (*--p != '/')
74 ;
75  
76 locale_dir = g_build_filename (install_dir, p, NULL);
77  
78 retval = g_win32_locale_filename_from_utf8 (locale_dir);
79  
80 g_free (install_dir);
81 g_free (locale_dir);
82 }
83  
84 if (retval)
85 return retval;
86 else
87 return g_strdup ("");
88 }
89  
90 #undef GLIB_LOCALE_DIR
91  
92 #endif /* G_OS_WIN32 */
93  
94  
95 static void
96 ensure_gettext_initialized (void)
97 {
98 static gsize initialised;
99  
100 if (g_once_init_enter (&initialised))
101 {
102 #ifdef G_OS_WIN32
103 gchar *tmp = _glib_get_locale_dir ();
104 bindtextdomain (GETTEXT_PACKAGE, tmp);
105 g_free (tmp);
106 #else
107 bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
108 #endif
109 # ifdef HAVE_BIND_TEXTDOMAIN_CODESET
110 bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
111 # endif
112 g_once_init_leave (&initialised, TRUE);
113 }
114 }
115  
116 /**
117 * glib_gettext:
118 * @str: The string to be translated
119 *
120 * Returns the translated string from the glib translations.
121 * This is an internal function and should only be used by
122 * the internals of glib (such as libgio).
123 *
124 * Returns: the transation of @str to the current locale
125 */
126 const gchar *
127 glib_gettext (const gchar *str)
128 {
129 ensure_gettext_initialized ();
130  
131 return g_dgettext (GETTEXT_PACKAGE, str);
132 }
133  
134 /**
135 * glib_pgettext:
136 * @msgctxtid: a combined message context and message id, separated
137 * by a \004 character
138 * @msgidoffset: the offset of the message id in @msgctxid
139 *
140 * This function is a variant of glib_gettext() which supports
141 * a disambiguating message context. See g_dpgettext() for full
142 * details.
143 *
144 * This is an internal function and should only be used by
145 * the internals of glib (such as libgio).
146 *
147 * Returns: the translation of @str to the current locale
148 */
149 const gchar *
150 glib_pgettext (const gchar *msgctxtid,
151 gsize msgidoffset)
152 {
153 ensure_gettext_initialized ();
154  
155 return g_dpgettext (GETTEXT_PACKAGE, msgctxtid, msgidoffset);
156 }
157  
158 /**
159 * g_strip_context:
160 * @msgid: a string
161 * @msgval: another string
162 *
163 * An auxiliary function for gettext() support (see Q_()).
164 *
165 * Returns: @msgval, unless @msgval is identical to @msgid
166 * and contains a '|' character, in which case a pointer to
167 * the substring of msgid after the first '|' character is returned.
168 *
169 * Since: 2.4
170 */
171 const gchar *
172 g_strip_context (const gchar *msgid,
173 const gchar *msgval)
174 {
175 if (msgval == msgid)
176 {
177 const char *c = strchr (msgid, '|');
178 if (c != NULL)
179 return c + 1;
180 }
181  
182 return msgval;
183 }
184  
185 /**
186 * g_dpgettext:
187 * @domain: (allow-none): the translation domain to use, or %NULL to use
188 * the domain set with textdomain()
189 * @msgctxtid: a combined message context and message id, separated
190 * by a \004 character
191 * @msgidoffset: the offset of the message id in @msgctxid
192 *
193 * This function is a variant of g_dgettext() which supports
194 * a disambiguating message context. GNU gettext uses the
195 * '\004' character to separate the message context and
196 * message id in @msgctxtid.
197 * If 0 is passed as @msgidoffset, this function will fall back to
198 * trying to use the deprecated convention of using "|" as a separation
199 * character.
200 *
201 * This uses g_dgettext() internally. See that functions for differences
202 * with dgettext() proper.
203 *
204 * Applications should normally not use this function directly,
205 * but use the C_() macro for translations with context.
206 *
207 * Returns: The translated string
208 *
209 * Since: 2.16
210 */
211 const gchar *
212 g_dpgettext (const gchar *domain,
213 const gchar *msgctxtid,
214 gsize msgidoffset)
215 {
216 const gchar *translation;
217 gchar *sep;
218  
219 translation = g_dgettext (domain, msgctxtid);
220  
221 if (translation == msgctxtid)
222 {
223 if (msgidoffset > 0)
224 return msgctxtid + msgidoffset;
225 sep = strchr (msgctxtid, '|');
226  
227 if (sep)
228 {
229 /* try with '\004' instead of '|', in case
230 * xgettext -kQ_:1g was used
231 */
232 gchar *tmp = g_alloca (strlen (msgctxtid) + 1);
233 strcpy (tmp, msgctxtid);
234 tmp[sep - msgctxtid] = '\004';
235  
236 translation = g_dgettext (domain, tmp);
237  
238 if (translation == tmp)
239 return sep + 1;
240 }
241 }
242  
243 return translation;
244 }
245  
246 /* This function is taken from gettext.h
247 * GNU gettext uses '\004' to separate context and msgid in .mo files.
248 */
249 /**
250 * g_dpgettext2:
251 * @domain: (allow-none): the translation domain to use, or %NULL to use
252 * the domain set with textdomain()
253 * @context: the message context
254 * @msgid: the message
255 *
256 * This function is a variant of g_dgettext() which supports
257 * a disambiguating message context. GNU gettext uses the
258 * '\004' character to separate the message context and
259 * message id in @msgctxtid.
260 *
261 * This uses g_dgettext() internally. See that functions for differences
262 * with dgettext() proper.
263 *
264 * This function differs from C_() in that it is not a macro and
265 * thus you may use non-string-literals as context and msgid arguments.
266 *
267 * Returns: The translated string
268 *
269 * Since: 2.18
270 */
271 const gchar *
272 g_dpgettext2 (const gchar *domain,
273 const gchar *msgctxt,
274 const gchar *msgid)
275 {
276 size_t msgctxt_len = strlen (msgctxt) + 1;
277 size_t msgid_len = strlen (msgid) + 1;
278 const char *translation;
279 char* msg_ctxt_id;
280  
281 msg_ctxt_id = g_alloca (msgctxt_len + msgid_len);
282  
283 memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1);
284 msg_ctxt_id[msgctxt_len - 1] = '\004';
285 memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len);
286  
287 translation = g_dgettext (domain, msg_ctxt_id);
288  
289 if (translation == msg_ctxt_id)
290 {
291 /* try the old way of doing message contexts, too */
292 msg_ctxt_id[msgctxt_len - 1] = '|';
293 translation = g_dgettext (domain, msg_ctxt_id);
294  
295 if (translation == msg_ctxt_id)
296 return msgid;
297 }
298  
299 return translation;
300 }
301  
302 static gboolean
303 _g_dgettext_should_translate (void)
304 {
305 static gsize translate = 0;
306 enum {
307 SHOULD_TRANSLATE = 1,
308 SHOULD_NOT_TRANSLATE = 2
309 };
310  
311 if (G_UNLIKELY (g_once_init_enter (&translate)))
312 {
313 gboolean should_translate = TRUE;
314  
315 const char *default_domain = textdomain (NULL);
316 const char *translator_comment = gettext ("");
317 #ifndef G_OS_WIN32
318 const char *translate_locale = setlocale (LC_MESSAGES, NULL);
319 #else
320 const char *translate_locale = g_win32_getlocale ();
321 #endif
322 /* We should NOT translate only if all the following hold:
323 * - user has called textdomain() and set textdomain to non-default
324 * - default domain has no translations
325 * - locale does not start with "en_" and is not "C"
326 *
327 * Rationale:
328 * - If text domain is still the default domain, maybe user calls
329 * it later. Continue with old behavior of translating.
330 * - If locale starts with "en_", we can continue using the
331 * translations even if the app doesn't have translations for
332 * this locale. That is, en_UK and en_CA for example.
333 * - If locale is "C", maybe user calls setlocale(LC_ALL,"") later.
334 * Continue with old behavior of translating.
335 */
336 if (!default_domain || !translator_comment || !translate_locale ||
337 (0 != strcmp (default_domain, "messages") &&
338 '\0' == *translator_comment &&
339  
340  
341 should_translate = FALSE;
342  
343 g_once_init_leave (&translate,
344 should_translate ?
345 SHOULD_TRANSLATE :
346 SHOULD_NOT_TRANSLATE);
347 }
348  
349 return translate == SHOULD_TRANSLATE;
350 }
351  
352 /**
353 * g_dgettext:
354 * @domain: (allow-none): the translation domain to use, or %NULL to use
355 * the domain set with textdomain()
356 * @msgid: message to translate
357 *
358 * This function is a wrapper of dgettext() which does not translate
359 * the message if the default domain as set with textdomain() has no
360 * translations for the current locale.
361 *
362 * The advantage of using this function over dgettext() proper is that
363 * libraries using this function (like GTK+) will not use translations
364 * if the application using the library does not have translations for
365 * the current locale. This results in a consistent English-only
366 * interface instead of one having partial translations. For this
367 * feature to work, the call to textdomain() and setlocale() should
368 * precede any g_dgettext() invocations. For GTK+, it means calling
369 * textdomain() before gtk_init or its variants.
370 *
371 * This function disables translations if and only if upon its first
372 * call all the following conditions hold:
373 *
374 * - @domain is not %NULL
375 *
376 * - textdomain() has been called to set a default text domain
377 *
378 * - there is no translations available for the default text domain
379 * and the current locale
380 *
381 * - current locale is not "C" or any English locales (those
382 * starting with "en_")
383 *
384 * Note that this behavior may not be desired for example if an application
385 * has its untranslated messages in a language other than English. In those
386 * cases the application should call textdomain() after initializing GTK+.
387 *
388 * Applications should normally not use this function directly,
389 * but use the _() macro for translations.
390 *
391 * Returns: The translated string
392 *
393 * Since: 2.18
394 */
395 const gchar *
396 g_dgettext (const gchar *domain,
397 const gchar *msgid)
398 {
399 if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
400 return msgid;
401  
402 return dgettext (domain, msgid);
403 }
404  
405 /**
406 * g_dcgettext:
407 * @domain: (allow-none): the translation domain to use, or %NULL to use
408 * the domain set with textdomain()
409 * @msgid: message to translate
410 * @category: a locale category
411 *
412 * This is a variant of g_dgettext() that allows specifying a locale
413 * category instead of always using `LC_MESSAGES`. See g_dgettext() for
414 * more information about how this functions differs from calling
415 * dcgettext() directly.
416 *
417 * Returns: the translated string for the given locale category
418 *
419 * Since: 2.26
420 */
421 const gchar *
422 g_dcgettext (const gchar *domain,
423 const gchar *msgid,
424 gint category)
425 {
426 if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
427 return msgid;
428  
429 return dcgettext (domain, msgid, category);
430 }
431  
432 /**
433 * g_dngettext:
434 * @domain: (allow-none): the translation domain to use, or %NULL to use
435 * the domain set with textdomain()
436 * @msgid: message to translate
437 * @msgid_plural: plural form of the message
438 * @n: the quantity for which translation is needed
439 *
440 * This function is a wrapper of dngettext() which does not translate
441 * the message if the default domain as set with textdomain() has no
442 * translations for the current locale.
443 *
444 * See g_dgettext() for details of how this differs from dngettext()
445 * proper.
446 *
447 * Returns: The translated string
448 *
449 * Since: 2.18
450 */
451 const gchar *
452 g_dngettext (const gchar *domain,
453 const gchar *msgid,
454 const gchar *msgid_plural,
455 gulong n)
456 {
457 if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
458 return n == 1 ? msgid : msgid_plural;
459  
460 return dngettext (domain, msgid, msgid_plural, n);
461 }
462  
463  
464 /**
465 * SECTION:i18n
466 * @title: Internationalization
467 * @short_description: gettext support macros
468 * @see_also: the gettext manual
469 *
470 * GLib doesn't force any particular localization method upon its users.
471 * But since GLib itself is localized using the gettext() mechanism, it seems
472 * natural to offer the de-facto standard gettext() support macros in an
473 * easy-to-use form.
474 *
475 * In order to use these macros in an application, you must include
476 * `<glib/gi18n.h>`. For use in a library, you must include
477 * `<glib/gi18n-lib.h>`
478 * after defining the %GETTEXT_PACKAGE macro suitably for your library:
479 * |[<!-- language="C" -->
480 * #define GETTEXT_PACKAGE "gtk20"
481 * #include <glib/gi18n-lib.h>
482 * ]|
483 * For an application, note that you also have to call bindtextdomain(),
484 * bind_textdomain_codeset(), textdomain() and setlocale() early on in your
485 * main() to make gettext() work. For example:
486 * |[<!-- language="C" -->
487 * #include <glib/gi18n.h>
488 * #include <locale.h>
489 *
490 * int
491 * main (int argc, char **argv)
492 * {
493 * setlocale (LC_ALL, "");
494 * bindtextdomain (GETTEXT_PACKAGE, DATADIR "/locale");
495 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
496 * textdomain (GETTEXT_PACKAGE);
497 *
498 * // Rest of your application.
499 * }
500 * ]|
501 * where `DATADIR` is as typically provided by automake.
502 *
503 * For a library, you only have to call bindtextdomain() and
504 * bind_textdomain_codeset() in your initialization function. If your library
505 * doesn't have an initialization function, you can call the functions before
506 * the first translated message.
507 *
508 * The
509 * [gettext manual](http://www.gnu.org/software/gettext/manual/gettext.html#Maintainers)
510 * covers details of how to integrate gettext into a project’s build system and
511 * workflow.
512 */
513  
514 /**
515 * _:
516 * @String: the string to be translated
517 *
518 * Marks a string for translation, gets replaced with the translated string
519 * at runtime.
520 *
521 * Since: 2.4
522 */
523  
524 /**
525 * Q_:
526 * @String: the string to be translated, with a '|'-separated prefix
527 * which must not be translated
528 *
529 * Like _(), but handles context in message ids. This has the advantage
530 * that the string can be adorned with a prefix to guarantee uniqueness
531 * and provide context to the translator.
532 *
533 * One use case given in the gettext manual is GUI translation, where one
534 * could e.g. disambiguate two "Open" menu entries as "File|Open" and
535 * "Printer|Open". Another use case is the string "Russian" which may
536 * have to be translated differently depending on whether it's the name
537 * of a character set or a language. This could be solved by using
538 * "charset|Russian" and "language|Russian".
539 *
540 * See the C_() macro for a different way to mark up translatable strings
541 * with context.
542 *
543 * If you are using the Q_() macro, you need to make sure that you pass
544 * `--keyword=Q_` to xgettext when extracting messages.
545 * If you are using GNU gettext >= 0.15, you can also use
546 * `--keyword=Q_:1g` to let xgettext split the context
547 * string off into a msgctxt line in the po file.
548 *
549 * Returns: the translated message
550 *
551 * Since: 2.4
552 */
553  
554 /**
555 * C_:
556 * @Context: a message context, must be a string literal
557 * @String: a message id, must be a string literal
558 *
559 * Uses gettext to get the translation for @String. @Context is
560 * used as a context. This is mainly useful for short strings which
561 * may need different translations, depending on the context in which
562 * they are used.
563 * |[<!-- language="C" -->
564 * label1 = C_("Navigation", "Back");
565 * label2 = C_("Body part", "Back");
566 * ]|
567 *
568 * If you are using the C_() macro, you need to make sure that you pass
569 * `--keyword=C_:1c,2` to xgettext when extracting messages.
570 * Note that this only works with GNU gettext >= 0.15.
571 *
572 * Returns: the translated message
573 *
574 * Since: 2.16
575 */
576  
577 /**
578 * N_:
579 * @String: the string to be translated
580 *
581 * Only marks a string for translation. This is useful in situations
582 * where the translated strings can't be directly used, e.g. in string
583 * array initializers. To get the translated string, call gettext()
584 * at runtime.
585 * |[<!-- language="C" -->
586 * {
587 * static const char *messages[] = {
588 * N_("some very meaningful message"),
589 * N_("and another one")
590 * };
591 * const char *string;
592 * ...
593 * string
594 * = index &gt; 1 ? _("a default message") : gettext (messages[index]);
595 *
596 * fputs (string);
597 * ...
598 * }
599 * ]|
600 *
601 * Since: 2.4
602 */
603  
604 /**
605 * NC_:
606 * @Context: a message context, must be a string literal
607 * @String: a message id, must be a string literal
608 *
609 * Only marks a string for translation, with context.
610 * This is useful in situations where the translated strings can't
611 * be directly used, e.g. in string array initializers. To get the
612 * translated string, you should call g_dpgettext2() at runtime.
613 *
614 * |[<!-- language="C" -->
615 * {
616 * static const char *messages[] = {
617 * NC_("some context", "some very meaningful message"),
618 * NC_("some context", "and another one")
619 * };
620 * const char *string;
621 * ...
622 * string
623 * = index > 1 ? g_dpgettext2 (NULL, "some context", "a default message")
624 * : g_dpgettext2 (NULL, "some context", messages[index]);
625 *
626 * fputs (string);
627 * ...
628 * }
629 * ]|
630 *
631 * If you are using the NC_() macro, you need to make sure that you pass
632 * `--keyword=NC_:1c,2` to xgettext when extracting messages.
633 * Note that this only works with GNU gettext >= 0.15. Intltool has support
634 * for the NC_() macro since version 0.40.1.
635 *
636 * Since: 2.18
637 */
638