]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/language.c
projects / thirdparty / cups.git / blob
? search:


e6d2d44aad459faea4ededb12b94a8555feae215
[thirdparty/cups.git] / cups / language.c
1 /*
2 * I18N/language support for CUPS.
3 *
4 * Copyright 2007-2017 by Apple Inc.
5 * Copyright 1997-2007 by Easy Software Products.
6 *
7 * These coded instructions, statements, and computer programs are the
8 * property of Apple Inc. and are protected by Federal copyright
9 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
10 * which should have been included with this file. If this file is
11 * missing or damaged, see the license at "http://www.cups.org/".
12 *
13 * This file is subject to the Apple OS-Developed Software exception.
14 */
15
16 /*
17 * Include necessary headers...
18 */
19
20 #include "cups-private.h"
21 #ifdef HAVE_LANGINFO_H
22 # include <langinfo.h>
23 #endif /* HAVE_LANGINFO_H */
24 #ifdef WIN32
25 # include <io.h>
26 #else
27 # include <unistd.h>
28 #endif /* WIN32 */
29 #ifdef HAVE_COREFOUNDATION_H
30 # include <CoreFoundation/CoreFoundation.h>
31 #endif /* HAVE_COREFOUNDATION_H */
32
33
34 /*
35 * Local globals...
36 */
37
38 static _cups_mutex_t lang_mutex = _CUPS_MUTEX_INITIALIZER;
39 /* Mutex to control access to cache */
40 static cups_lang_t *lang_cache = NULL;
41 /* Language string cache */
42 static const char * const lang_encodings[] =
43 { /* Encoding strings */
44 "us-ascii", "iso-8859-1",
45 "iso-8859-2", "iso-8859-3",
46 "iso-8859-4", "iso-8859-5",
47 "iso-8859-6", "iso-8859-7",
48 "iso-8859-8", "iso-8859-9",
49 "iso-8859-10", "utf-8",
50 "iso-8859-13", "iso-8859-14",
51 "iso-8859-15", "cp874",
52 "cp1250", "cp1251",
53 "cp1252", "cp1253",
54 "cp1254", "cp1255",
55 "cp1256", "cp1257",
56 "cp1258", "koi8-r",
57 "koi8-u", "iso-8859-11",
58 "iso-8859-16", "mac",
59 "unknown", "unknown",
60 "unknown", "unknown",
61 "unknown", "unknown",
62 "unknown", "unknown",
63 "unknown", "unknown",
64 "unknown", "unknown",
65 "unknown", "unknown",
66 "unknown", "unknown",
67 "unknown", "unknown",
68 "unknown", "unknown",
69 "unknown", "unknown",
70 "unknown", "unknown",
71 "unknown", "unknown",
72 "unknown", "unknown",
73 "unknown", "unknown",
74 "unknown", "unknown",
75 "unknown", "unknown",
76 "cp932", "cp936",
77 "cp949", "cp950",
78 "cp1361", "unknown",
79 "unknown", "unknown",
80 "unknown", "unknown",
81 "unknown", "unknown",
82 "unknown", "unknown",
83 "unknown", "unknown",
84 "unknown", "unknown",
85 "unknown", "unknown",
86 "unknown", "unknown",
87 "unknown", "unknown",
88 "unknown", "unknown",
89 "unknown", "unknown",
90 "unknown", "unknown",
91 "unknown", "unknown",
92 "unknown", "unknown",
93 "unknown", "unknown",
94 "unknown", "unknown",
95 "unknown", "unknown",
96 "unknown", "unknown",
97 "unknown", "unknown",
98 "unknown", "unknown",
99 "unknown", "unknown",
100 "unknown", "unknown",
101 "unknown", "unknown",
102 "unknown", "unknown",
103 "unknown", "unknown",
104 "unknown", "unknown",
105 "unknown", "unknown",
106 "unknown", "unknown",
107 "unknown", "unknown",
108 "euc-cn", "euc-jp",
109 "euc-kr", "euc-tw",
110 "shift_jisx0213"
111 };
112
113 #ifdef __APPLE__
114 typedef struct
115 {
116 const char * const language; /* Language ID */
117 const char * const locale; /* Locale ID */
118 } _apple_language_locale_t;
119
120 static const _apple_language_locale_t apple_language_locale[] =
121 { /* Language to locale ID LUT */
122 { "en", "en_US" },
123 { "nb", "no" },
124 { "nb_NO", "no" },
125 { "zh-Hans", "zh_CN" },
126 { "zh_HANS", "zh_CN" },
127 { "zh-Hant", "zh_TW" },
128 { "zh_HANT", "zh_TW" },
129 { "zh-Hant_CN", "zh_TW" }
130 };
131 #endif /* __APPLE__ */
132
133
134 /*
135 * Local functions...
136 */
137
138
139 #ifdef __APPLE__
140 static const char *appleLangDefault(void);
141 # ifdef CUPS_BUNDLEDIR
142 # ifndef CF_RETURNS_RETAINED
143 # if __has_feature(attribute_cf_returns_retained)
144 # define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
145 # else
146 # define CF_RETURNS_RETAINED
147 # endif /* __has_feature(attribute_cf_returns_retained) */
148 # endif /* !CF_RETURNED_RETAINED */
149 static cups_array_t *appleMessageLoad(const char *locale)
150 CF_RETURNS_RETAINED;
151 # endif /* CUPS_BUNDLEDIR */
152 #endif /* __APPLE__ */
153 static cups_lang_t *cups_cache_lookup(const char *name,
154 cups_encoding_t encoding);
155 static int cups_message_compare(_cups_message_t *m1,
156 _cups_message_t *m2);
157 static void cups_message_free(_cups_message_t *m);
158 static void cups_message_load(cups_lang_t *lang);
159 static void cups_unquote(char *d, const char *s);
160
161
162 #ifdef __APPLE__
163 /*
164 * '_cupsAppleLanguage()' - Get the Apple language identifier associated with a
165 * locale ID.
166 */
167
168 const char * /* O - Language ID */
169 _cupsAppleLanguage(const char *locale, /* I - Locale ID */
170 char *language,/* I - Language ID buffer */
171 size_t langsize) /* I - Size of language ID buffer */
172 {
173 int i; /* Looping var */
174 CFStringRef localeid, /* CF locale identifier */
175 langid; /* CF language identifier */
176
177
178 /*
179 * Copy the locale name and convert, as needed, to the Apple-specific
180 * locale identifier...
181 */
182
183 switch (strlen(locale))
184 {
185 default :
186 /*
187 * Invalid locale...
188 */
189
190 strlcpy(language, "en", langsize);
191 break;
192
193 case 2 :
194 strlcpy(language, locale, langsize);
195 break;
196
197 case 5 :
198 strlcpy(language, locale, langsize);
199
200 if (language[2] == '-')
201 {
202 /*
203 * Convert ll-cc to ll_CC...
204 */
205
206 language[2] = '_';
207 language[3] = (char)toupper(language[3] & 255);
208 language[4] = (char)toupper(language[4] & 255);
209 }
210 break;
211 }
212
213 for (i = 0;
214 i < (int)(sizeof(apple_language_locale) /
215 sizeof(apple_language_locale[0]));
216 i ++)
217 if (!strcmp(locale, apple_language_locale[i].locale))
218 {
219 strlcpy(language, apple_language_locale[i].language, sizeof(language));
220 break;
221 }
222
223 /*
224 * Attempt to map the locale ID to a language ID...
225 */
226
227 if ((localeid = CFStringCreateWithCString(kCFAllocatorDefault, language,
228 kCFStringEncodingASCII)) != NULL)
229 {
230 if ((langid = CFLocaleCreateCanonicalLanguageIdentifierFromString(
231 kCFAllocatorDefault, localeid)) != NULL)
232 {
233 CFStringGetCString(langid, language, (CFIndex)langsize, kCFStringEncodingASCII);
234 CFRelease(langid);
235 }
236
237 CFRelease(localeid);
238 }
239
240 /*
241 * Return what we got...
242 */
243
244 return (language);
245 }
246
247
248 /*
249 * '_cupsAppleLocale()' - Get the locale associated with an Apple language ID.
250 */
251
252 const char * /* O - Locale */
253 _cupsAppleLocale(CFStringRef languageName, /* I - Apple language ID */
254 char *locale, /* I - Buffer for locale */
255 size_t localesize) /* I - Size of buffer */
256 {
257 int i; /* Looping var */
258 CFStringRef localeName; /* Locale as a CF string */
259 #ifdef DEBUG
260 char temp[1024]; /* Temporary string */
261
262
263 if (!CFStringGetCString(languageName, temp, (CFIndex)sizeof(temp), kCFStringEncodingASCII))
264 temp[0] = '\0';
265
266 DEBUG_printf(("_cupsAppleLocale(languageName=%p(%s), locale=%p, localsize=%d)", (void *)languageName, temp, (void *)locale, (int)localesize));
267 #endif /* DEBUG */
268
269 localeName = CFLocaleCreateCanonicalLocaleIdentifierFromString(kCFAllocatorDefault, languageName);
270
271 if (localeName)
272 {
273 /*
274 * Copy the locale name and tweak as needed...
275 */
276
277 if (!CFStringGetCString(localeName, locale, (CFIndex)localesize, kCFStringEncodingASCII))
278 *locale = '\0';
279
280 DEBUG_printf(("_cupsAppleLocale: locale=\"%s\"", locale));
281
282 CFRelease(localeName);
283
284 /*
285 * Map new language identifiers to locales...
286 */
287
288 for (i = 0;
289 i < (int)(sizeof(apple_language_locale) /
290 sizeof(apple_language_locale[0]));
291 i ++)
292 {
293 size_t len = strlen(apple_language_locale[i].language);
294
295 if (!strcmp(locale, apple_language_locale[i].language) ||
296 (!strncmp(locale, apple_language_locale[i].language, len) && (locale[len] == '_' || locale[len] == '-')))
297 {
298 DEBUG_printf(("_cupsAppleLocale: Updating locale to \"%s\".", apple_language_locale[i].locale));
299 strlcpy(locale, apple_language_locale[i].locale, localesize);
300 break;
301 }
302 }
303 }
304 else
305 {
306 /*
307 * Just try the Apple language name...
308 */
309
310 if (!CFStringGetCString(languageName, locale, (CFIndex)localesize, kCFStringEncodingASCII))
311 *locale = '\0';
312 }
313
314 if (!*locale)
315 {
316 DEBUG_puts("_cupsAppleLocale: Returning NULL.");
317 return (NULL);
318 }
319
320 /*
321 * Convert language subtag into region subtag...
322 */
323
324 if (locale[2] == '-')
325 locale[2] = '_';
326 else if (locale[3] == '-')
327 locale[3] = '_';
328
329 if (!strchr(locale, '.'))
330 strlcat(locale, ".UTF-8", localesize);
331
332 DEBUG_printf(("_cupsAppleLocale: Returning \"%s\".", locale));
333
334 return (locale);
335 }
336 #endif /* __APPLE__ */
337
338
339 /*
340 * '_cupsEncodingName()' - Return the character encoding name string
341 * for the given encoding enumeration.
342 */
343
344 const char * /* O - Character encoding */
345 _cupsEncodingName(
346 cups_encoding_t encoding) /* I - Encoding value */
347 {
348 if (encoding < CUPS_US_ASCII ||
349 encoding >= (cups_encoding_t)(sizeof(lang_encodings) / sizeof(lang_encodings[0])))
350 {
351 DEBUG_printf(("1_cupsEncodingName(encoding=%d) = out of range (\"%s\")",
352 encoding, lang_encodings[0]));
353 return (lang_encodings[0]);
354 }
355 else
356 {
357 DEBUG_printf(("1_cupsEncodingName(encoding=%d) = \"%s\"",
358 encoding, lang_encodings[encoding]));
359 return (lang_encodings[encoding]);
360 }
361 }
362
363
364 /*
365 * 'cupsLangDefault()' - Return the default language.
366 */
367
368 cups_lang_t * /* O - Language data */
369 cupsLangDefault(void)
370 {
371 return (cupsLangGet(NULL));
372 }
373
374
375 /*
376 * 'cupsLangEncoding()' - Return the character encoding (us-ascii, etc.)
377 * for the given language.
378 */
379
380 const char * /* O - Character encoding */
381 cupsLangEncoding(cups_lang_t *lang) /* I - Language data */
382 {
383 if (lang == NULL)
384 return ((char*)lang_encodings[0]);
385 else
386 return ((char*)lang_encodings[lang->encoding]);
387 }
388
389
390 /*
391 * 'cupsLangFlush()' - Flush all language data out of the cache.
392 */
393
394 void
395 cupsLangFlush(void)
396 {
397 cups_lang_t *lang, /* Current language */
398 *next; /* Next language */
399
400
401 /*
402 * Free all languages in the cache...
403 */
404
405 _cupsMutexLock(&lang_mutex);
406
407 for (lang = lang_cache; lang != NULL; lang = next)
408 {
409 /*
410 * Free all messages...
411 */
412
413 _cupsMessageFree(lang->strings);
414
415 /*
416 * Then free the language structure itself...
417 */
418
419 next = lang->next;
420 free(lang);
421 }
422
423 lang_cache = NULL;
424
425 _cupsMutexUnlock(&lang_mutex);
426 }
427
428
429 /*
430 * 'cupsLangFree()' - Free language data.
431 *
432 * This does not actually free anything; use @link cupsLangFlush@ for that.
433 */
434
435 void
436 cupsLangFree(cups_lang_t *lang) /* I - Language to free */
437 {
438 _cupsMutexLock(&lang_mutex);
439
440 if (lang != NULL && lang->used > 0)
441 lang->used --;
442
443 _cupsMutexUnlock(&lang_mutex);
444 }
445
446
447 /*
448 * 'cupsLangGet()' - Get a language.
449 */
450
451 cups_lang_t * /* O - Language data */
452 cupsLangGet(const char *language) /* I - Language or locale */
453 {
454 int i; /* Looping var */
455 #ifndef __APPLE__
456 char locale[255]; /* Copy of locale name */
457 #endif /* !__APPLE__ */
458 char langname[16], /* Requested language name */
459 country[16], /* Country code */
460 charset[16], /* Character set */
461 *csptr, /* Pointer to CODESET string */
462 *ptr, /* Pointer into language/charset */
463 real[48]; /* Real language name */
464 cups_encoding_t encoding; /* Encoding to use */
465 cups_lang_t *lang; /* Current language... */
466 static const char * const locale_encodings[] =
467 { /* Locale charset names */
468 "ASCII", "ISO88591", "ISO88592", "ISO88593",
469 "ISO88594", "ISO88595", "ISO88596", "ISO88597",
470 "ISO88598", "ISO88599", "ISO885910", "UTF8",
471 "ISO885913", "ISO885914", "ISO885915", "CP874",
472 "CP1250", "CP1251", "CP1252", "CP1253",
473 "CP1254", "CP1255", "CP1256", "CP1257",
474 "CP1258", "KOI8R", "KOI8U", "ISO885911",
475 "ISO885916", "MACROMAN", "", "",
476
477 "", "", "", "",
478 "", "", "", "",
479 "", "", "", "",
480 "", "", "", "",
481 "", "", "", "",
482 "", "", "", "",
483 "", "", "", "",
484 "", "", "", "",
485
486 "CP932", "CP936", "CP949", "CP950",
487 "CP1361", "", "", "",
488 "", "", "", "",
489 "", "", "", "",
490 "", "", "", "",
491 "", "", "", "",
492 "", "", "", "",
493 "", "", "", "",
494
495 "", "", "", "",
496 "", "", "", "",
497 "", "", "", "",
498 "", "", "", "",
499 "", "", "", "",
500 "", "", "", "",
501 "", "", "", "",
502 "", "", "", "",
503
504 "EUCCN", "EUCJP", "EUCKR", "EUCTW",
505 "SHIFT_JISX0213"
506 };
507
508
509 DEBUG_printf(("2cupsLangGet(language=\"%s\")", language));
510
511 #ifdef __APPLE__
512 /*
513 * Set the character set to UTF-8...
514 */
515
516 strlcpy(charset, "UTF8", sizeof(charset));
517
518 /*
519 * Apple's setlocale doesn't give us the user's localization
520 * preference so we have to look it up this way...
521 */
522
523 if (!language)
524 {
525 if (!getenv("SOFTWARE") || (language = getenv("LANG")) == NULL)
526 language = appleLangDefault();
527
528 DEBUG_printf(("4cupsLangGet: language=\"%s\"", language));
529 }
530
531 #else
532 /*
533 * Set the charset to "unknown"...
534 */
535
536 charset[0] = '\0';
537
538 /*
539 * Use setlocale() to determine the currently set locale, and then
540 * fallback to environment variables to avoid setting the locale,
541 * since setlocale() is not thread-safe!
542 */
543
544 if (!language)
545 {
546 /*
547 * First see if the locale has been set; if it is still "C" or
548 * "POSIX", use the environment to get the default...
549 */
550
551 # ifdef LC_MESSAGES
552 ptr = setlocale(LC_MESSAGES, NULL);
553 # else
554 ptr = setlocale(LC_ALL, NULL);
555 # endif /* LC_MESSAGES */
556
557 DEBUG_printf(("4cupsLangGet: current locale is \"%s\"", ptr));
558
559 if (!ptr || !strcmp(ptr, "C") || !strcmp(ptr, "POSIX"))
560 {
561 /*
562 * Get the character set from the LC_CTYPE locale setting...
563 */
564
565 if ((ptr = getenv("LC_CTYPE")) == NULL)
566 if ((ptr = getenv("LC_ALL")) == NULL)
567 if ((ptr = getenv("LANG")) == NULL)
568 ptr = "en_US";
569
570 if ((csptr = strchr(ptr, '.')) != NULL)
571 {
572 /*
573 * Extract the character set from the environment...
574 */
575
576 for (ptr = charset, csptr ++; *csptr; csptr ++)
577 if (ptr < (charset + sizeof(charset) - 1) && _cups_isalnum(*csptr))
578 *ptr++ = *csptr;
579
580 *ptr = '\0';
581 }
582
583 /*
584 * Get the locale for messages from the LC_MESSAGES locale setting...
585 */
586
587 if ((ptr = getenv("LC_MESSAGES")) == NULL)
588 if ((ptr = getenv("LC_ALL")) == NULL)
589 if ((ptr = getenv("LANG")) == NULL)
590 ptr = "en_US";
591 }
592
593 if (ptr)
594 {
595 strlcpy(locale, ptr, sizeof(locale));
596 language = locale;
597
598 /*
599 * CUPS STR #2575: Map "nb" to "no" for back-compatibility...
600 */
601
602 if (!strncmp(locale, "nb", 2))
603 locale[1] = 'o';
604
605 DEBUG_printf(("4cupsLangGet: new language value is \"%s\"", language));
606 }
607 }
608 #endif /* __APPLE__ */
609
610 /*
611 * If "language" is NULL at this point, then chances are we are using
612 * a language that is not installed for the base OS.
613 */
614
615 if (!language)
616 {
617 /*
618 * Switch to the POSIX ("C") locale...
619 */
620
621 language = "C";
622 }
623
624 #ifdef CODESET
625 /*
626 * On systems that support the nl_langinfo(CODESET) call, use
627 * this value as the character set...
628 */
629
630 if (!charset[0] && (csptr = nl_langinfo(CODESET)) != NULL)
631 {
632 /*
633 * Copy all of the letters and numbers in the CODESET string...
634 */
635
636 for (ptr = charset; *csptr; csptr ++)
637 if (_cups_isalnum(*csptr) && ptr < (charset + sizeof(charset) - 1))
638 *ptr++ = *csptr;
639
640 *ptr = '\0';
641
642 DEBUG_printf(("4cupsLangGet: charset set to \"%s\" via "
643 "nl_langinfo(CODESET)...", charset));
644 }
645 #endif /* CODESET */
646
647 /*
648 * If we don't have a character set by now, default to UTF-8...
649 */
650
651 if (!charset[0])
652 strlcpy(charset, "UTF8", sizeof(charset));
653
654 /*
655 * Parse the language string passed in to a locale string. "C" is the
656 * standard POSIX locale and is copied unchanged. Otherwise the
657 * language string is converted from ll-cc[.charset] (language-country)
658 * to ll_CC[.CHARSET] to match the file naming convention used by all
659 * POSIX-compliant operating systems. Invalid language names are mapped
660 * to the POSIX locale.
661 */
662
663 country[0] = '\0';
664
665 if (language == NULL || !language[0] ||
666 !strcmp(language, "POSIX"))
667 strlcpy(langname, "C", sizeof(langname));
668 else
669 {
670 /*
671 * Copy the parts of the locale string over safely...
672 */
673
674 for (ptr = langname; *language; language ++)
675 if (*language == '_' || *language == '-' || *language == '.')
676 break;
677 else if (ptr < (langname + sizeof(langname) - 1))
678 *ptr++ = (char)tolower(*language & 255);
679
680 *ptr = '\0';
681
682 if (*language == '_' || *language == '-')
683 {
684 /*
685 * Copy the country code...
686 */
687
688 for (language ++, ptr = country; *language; language ++)
689 if (*language == '.')
690 break;
691 else if (ptr < (country + sizeof(country) - 1))
692 *ptr++ = (char)toupper(*language & 255);
693
694 *ptr = '\0';
695
696 /*
697 * Map Chinese region codes to legacy country codes.
698 */
699
700 if (!strcmp(language, "zh") && !strcmp(country, "HANS"))
701 strlcpy(country, "CN", sizeof(country));
702 if (!strcmp(language, "zh") && !strcmp(country, "HANT"))
703 strlcpy(country, "TW", sizeof(country));
704 }
705
706 if (*language == '.' && !charset[0])
707 {
708 /*
709 * Copy the encoding...
710 */
711
712 for (language ++, ptr = charset; *language; language ++)
713 if (_cups_isalnum(*language) && ptr < (charset + sizeof(charset) - 1))
714 *ptr++ = (char)toupper(*language & 255);
715
716 *ptr = '\0';
717 }
718
719 /*
720 * Force a POSIX locale for an invalid language name...
721 */
722
723 if (strlen(langname) != 2 && strlen(langname) != 3)
724 {
725 strlcpy(langname, "C", sizeof(langname));
726 country[0] = '\0';
727 charset[0] = '\0';
728 }
729 }
730
731 DEBUG_printf(("4cupsLangGet: langname=\"%s\", country=\"%s\", charset=\"%s\"",
732 langname, country, charset));
733
734 /*
735 * Figure out the desired encoding...
736 */
737
738 encoding = CUPS_AUTO_ENCODING;
739
740 if (charset[0])
741 {
742 for (i = 0;
743 i < (int)(sizeof(locale_encodings) / sizeof(locale_encodings[0]));
744 i ++)
745 if (!_cups_strcasecmp(charset, locale_encodings[i]))
746 {
747 encoding = (cups_encoding_t)i;
748 break;
749 }
750
751 if (encoding == CUPS_AUTO_ENCODING)
752 {
753 /*
754 * Map alternate names for various character sets...
755 */
756
757 if (!_cups_strcasecmp(charset, "iso-2022-jp") ||
758 !_cups_strcasecmp(charset, "sjis"))
759 encoding = CUPS_WINDOWS_932;
760 else if (!_cups_strcasecmp(charset, "iso-2022-cn"))
761 encoding = CUPS_WINDOWS_936;
762 else if (!_cups_strcasecmp(charset, "iso-2022-kr"))
763 encoding = CUPS_WINDOWS_949;
764 else if (!_cups_strcasecmp(charset, "big5"))
765 encoding = CUPS_WINDOWS_950;
766 }
767 }
768
769 DEBUG_printf(("4cupsLangGet: encoding=%d(%s)", encoding,
770 encoding == CUPS_AUTO_ENCODING ? "auto" :
771 lang_encodings[encoding]));
772
773 /*
774 * See if we already have this language/country loaded...
775 */
776
777 if (country[0])
778 snprintf(real, sizeof(real), "%s_%s", langname, country);
779 else
780 strlcpy(real, langname, sizeof(real));
781
782 _cupsMutexLock(&lang_mutex);
783
784 if ((lang = cups_cache_lookup(real, encoding)) != NULL)
785 {
786 _cupsMutexUnlock(&lang_mutex);
787
788 DEBUG_printf(("3cupsLangGet: Using cached copy of \"%s\"...", real));
789
790 return (lang);
791 }
792
793 /*
794 * See if there is a free language available; if so, use that
795 * record...
796 */
797
798 for (lang = lang_cache; lang != NULL; lang = lang->next)
799 if (lang->used == 0)
800 break;
801
802 if (lang == NULL)
803 {
804 /*
805 * Allocate memory for the language and add it to the cache.
806 */
807
808 if ((lang = calloc(sizeof(cups_lang_t), 1)) == NULL)
809 {
810 _cupsMutexUnlock(&lang_mutex);
811
812 return (NULL);
813 }
814
815 lang->next = lang_cache;
816 lang_cache = lang;
817 }
818 else
819 {
820 /*
821 * Free all old strings as needed...
822 */
823
824 _cupsMessageFree(lang->strings);
825 lang->strings = NULL;
826 }
827
828 /*
829 * Then assign the language and encoding fields...
830 */
831
832 lang->used ++;
833 strlcpy(lang->language, real, sizeof(lang->language));
834
835 if (encoding != CUPS_AUTO_ENCODING)
836 lang->encoding = encoding;
837 else
838 lang->encoding = CUPS_UTF8;
839
840 /*
841 * Return...
842 */
843
844 _cupsMutexUnlock(&lang_mutex);
845
846 return (lang);
847 }
848
849
850 /*
851 * '_cupsLangString()' - Get a message string.
852 *
853 * The returned string is UTF-8 encoded; use cupsUTF8ToCharset() to
854 * convert the string to the language encoding.
855 */
856
857 const char * /* O - Localized message */
858 _cupsLangString(cups_lang_t *lang, /* I - Language */
859 const char *message) /* I - Message */
860 {
861 const char *s; /* Localized message */
862
863
864 DEBUG_printf(("_cupsLangString(lang=%p, message=\"%s\")", (void *)lang, message));
865
866 /*
867 * Range check input...
868 */
869
870 if (!lang || !message || !*message)
871 return (message);
872
873 _cupsMutexLock(&lang_mutex);
874
875 /*
876 * Load the message catalog if needed...
877 */
878
879 if (!lang->strings)
880 cups_message_load(lang);
881
882 s = _cupsMessageLookup(lang->strings, message);
883
884 _cupsMutexUnlock(&lang_mutex);
885
886 return (s);
887 }
888
889
890 /*
891 * '_cupsMessageFree()' - Free a messages array.
892 */
893
894 void
895 _cupsMessageFree(cups_array_t *a) /* I - Message array */
896 {
897 #if defined(__APPLE__) && defined(CUPS_BUNDLEDIR)
898 /*
899 * Release the cups.strings dictionary as needed...
900 */
901
902 if (cupsArrayUserData(a))
903 CFRelease((CFDictionaryRef)cupsArrayUserData(a));
904 #endif /* __APPLE__ && CUPS_BUNDLEDIR */
905
906 /*
907 * Free the array...
908 */
909
910 cupsArrayDelete(a);
911 }
912
913
914 /*
915 * '_cupsMessageLoad()' - Load a .po file into a messages array.
916 */
917
918 cups_array_t * /* O - New message array */
919 _cupsMessageLoad(const char *filename, /* I - Message catalog to load */
920 int unquote) /* I - Unescape \foo in strings? */
921 {
922 cups_file_t *fp; /* Message file */
923 cups_array_t *a; /* Message array */
924 _cups_message_t *m; /* Current message */
925 char s[4096], /* String buffer */
926 *ptr, /* Pointer into buffer */
927 *temp; /* New string */
928 size_t length, /* Length of combined strings */
929 ptrlen; /* Length of string */
930
931
932 DEBUG_printf(("4_cupsMessageLoad(filename=\"%s\")", filename));
933
934 /*
935 * Create an array to hold the messages...
936 */
937
938 if ((a = _cupsMessageNew(NULL)) == NULL)
939 {
940 DEBUG_puts("5_cupsMessageLoad: Unable to allocate array!");
941 return (NULL);
942 }
943
944 /*
945 * Open the message catalog file...
946 */
947
948 if ((fp = cupsFileOpen(filename, "r")) == NULL)
949 {
950 DEBUG_printf(("5_cupsMessageLoad: Unable to open file: %s",
951 strerror(errno)));
952 return (a);
953 }
954
955 /*
956 * Read messages from the catalog file until EOF...
957 *
958 * The format is the GNU gettext .po format, which is fairly simple:
959 *
960 * msgid "some text"
961 * msgstr "localized text"
962 *
963 * The ID and localized text can span multiple lines using the form:
964 *
965 * msgid ""
966 * "some long text"
967 * msgstr ""
968 * "localized text spanning "
969 * "multiple lines"
970 */
971
972 m = NULL;
973
974 while (cupsFileGets(fp, s, sizeof(s)) != NULL)
975 {
976 /*
977 * Skip blank and comment lines...
978 */
979
980 if (s[0] == '#' || !s[0])
981 continue;
982
983 /*
984 * Strip the trailing quote...
985 */
986
987 if ((ptr = strrchr(s, '\"')) == NULL)
988 continue;
989
990 *ptr = '\0';
991
992 /*
993 * Find start of value...
994 */
995
996 if ((ptr = strchr(s, '\"')) == NULL)
997 continue;
998
999 ptr ++;
1000
1001 /*
1002 * Unquote the text...
1003 */
1004
1005 if (unquote)
1006 cups_unquote(ptr, ptr);
1007
1008 /*
1009 * Create or add to a message...
1010 */
1011
1012 if (!strncmp(s, "msgid", 5))
1013 {
1014 /*
1015 * Add previous message as needed...
1016 */
1017
1018 if (m)
1019 {
1020 if (m->str && m->str[0])
1021 {
1022 cupsArrayAdd(a, m);
1023 }
1024 else
1025 {
1026 /*
1027 * Translation is empty, don't add it... (STR #4033)
1028 */
1029
1030 free(m->id);
1031 if (m->str)
1032 free(m->str);
1033 free(m);
1034 }
1035 }
1036
1037 /*
1038 * Create a new message with the given msgid string...
1039 */
1040
1041 if ((m = (_cups_message_t *)calloc(1, sizeof(_cups_message_t))) == NULL)
1042 {
1043 cupsFileClose(fp);
1044 return (a);
1045 }
1046
1047 if ((m->id = strdup(ptr)) == NULL)
1048 {
1049 free(m);
1050 cupsFileClose(fp);
1051 return (a);
1052 }
1053 }
1054 else if (s[0] == '\"' && m)
1055 {
1056 /*
1057 * Append to current string...
1058 */
1059
1060 length = strlen(m->str ? m->str : m->id);
1061 ptrlen = strlen(ptr);
1062
1063 if ((temp = realloc(m->str ? m->str : m->id, length + ptrlen + 1)) == NULL)
1064 {
1065 if (m->str)
1066 free(m->str);
1067 free(m->id);
1068 free(m);
1069
1070 cupsFileClose(fp);
1071 return (a);
1072 }
1073
1074 if (m->str)
1075 {
1076 /*
1077 * Copy the new portion to the end of the msgstr string - safe
1078 * to use memcpy because the buffer is allocated to the correct
1079 * size...
1080 */
1081
1082 m->str = temp;
1083
1084 memcpy(m->str + length, ptr, ptrlen + 1);
1085 }
1086 else
1087 {
1088 /*
1089 * Copy the new portion to the end of the msgid string - safe
1090 * to use memcpy because the buffer is allocated to the correct
1091 * size...
1092 */
1093
1094 m->id = temp;
1095
1096 memcpy(m->id + length, ptr, ptrlen + 1);
1097 }
1098 }
1099 else if (!strncmp(s, "msgstr", 6) && m)
1100 {
1101 /*
1102 * Set the string...
1103 */
1104
1105 if ((m->str = strdup(ptr)) == NULL)
1106 {
1107 free(m->id);
1108 free(m);
1109
1110 cupsFileClose(fp);
1111 return (a);
1112 }
1113 }
1114 }
1115
1116 /*
1117 * Add the last message string to the array as needed...
1118 */
1119
1120 if (m)
1121 {
1122 if (m->str && m->str[0])
1123 {
1124 cupsArrayAdd(a, m);
1125 }
1126 else
1127 {
1128 /*
1129 * Translation is empty, don't add it... (STR #4033)
1130 */
1131
1132 free(m->id);
1133 if (m->str)
1134 free(m->str);
1135 free(m);
1136 }
1137 }
1138
1139 /*
1140 * Close the message catalog file and return the new array...
1141 */
1142
1143 cupsFileClose(fp);
1144
1145 DEBUG_printf(("5_cupsMessageLoad: Returning %d messages...",
1146 cupsArrayCount(a)));
1147
1148 return (a);
1149 }
1150
1151
1152 /*
1153 * '_cupsMessageLookup()' - Lookup a message string.
1154 */
1155
1156 const char * /* O - Localized message */
1157 _cupsMessageLookup(cups_array_t *a, /* I - Message array */
1158 const char *m) /* I - Message */
1159 {
1160 _cups_message_t key, /* Search key */
1161 *match; /* Matching message */
1162
1163
1164 DEBUG_printf(("_cupsMessageLookup(a=%p, m=\"%s\")", (void *)a, m));
1165
1166 /*
1167 * Lookup the message string; if it doesn't exist in the catalog,
1168 * then return the message that was passed to us...
1169 */
1170
1171 key.id = (char *)m;
1172 match = (_cups_message_t *)cupsArrayFind(a, &key);
1173
1174 #if defined(__APPLE__) && defined(CUPS_BUNDLEDIR)
1175 if (!match && cupsArrayUserData(a))
1176 {
1177 /*
1178 * Try looking the string up in the cups.strings dictionary...
1179 */
1180
1181 CFDictionaryRef dict; /* cups.strings dictionary */
1182 CFStringRef cfm, /* Message as a CF string */
1183 cfstr; /* Localized text as a CF string */
1184
1185 dict = (CFDictionaryRef)cupsArrayUserData(a);
1186 cfm = CFStringCreateWithCString(kCFAllocatorDefault, m,
1187 kCFStringEncodingUTF8);
1188 match = calloc(1, sizeof(_cups_message_t));
1189 match->id = strdup(m);
1190 cfstr = cfm ? CFDictionaryGetValue(dict, cfm) : NULL;
1191
1192 if (cfstr)
1193 {
1194 char buffer[1024]; /* Message buffer */
1195
1196 CFStringGetCString(cfstr, buffer, sizeof(buffer), kCFStringEncodingUTF8);
1197 match->str = strdup(buffer);
1198
1199 DEBUG_printf(("1_cupsMessageLookup: Found \"%s\" as \"%s\"...",
1200 m, buffer));
1201 }
1202 else
1203 {
1204 match->str = strdup(m);
1205
1206 DEBUG_printf(("1_cupsMessageLookup: Did not find \"%s\"...", m));
1207 }
1208
1209 cupsArrayAdd(a, match);
1210
1211 if (cfm)
1212 CFRelease(cfm);
1213 }
1214 #endif /* __APPLE__ && CUPS_BUNDLEDIR */
1215
1216 if (match && match->str)
1217 return (match->str);
1218 else
1219 return (m);
1220 }
1221
1222
1223 /*
1224 * '_cupsMessageNew()' - Make a new message catalog array.
1225 */
1226
1227 cups_array_t * /* O - Array */
1228 _cupsMessageNew(void *context) /* I - User data */
1229 {
1230 return (cupsArrayNew3((cups_array_func_t)cups_message_compare, context,
1231 (cups_ahash_func_t)NULL, 0,
1232 (cups_acopy_func_t)NULL,
1233 (cups_afree_func_t)cups_message_free));
1234 }
1235
1236
1237 #ifdef __APPLE__
1238 /*
1239 * 'appleLangDefault()' - Get the default locale string.
1240 */
1241
1242 static const char * /* O - Locale string */
1243 appleLangDefault(void)
1244 {
1245 CFBundleRef bundle; /* Main bundle (if any) */
1246 CFArrayRef bundleList; /* List of localizations in bundle */
1247 CFPropertyListRef localizationList = NULL;
1248 /* List of localization data */
1249 CFStringRef languageName; /* Current name */
1250 char *lang; /* LANG environment variable */
1251 _cups_globals_t *cg = _cupsGlobals();
1252 /* Pointer to library globals */
1253
1254
1255 DEBUG_puts("2appleLangDefault()");
1256
1257 /*
1258 * Only do the lookup and translation the first time.
1259 */
1260
1261 if (!cg->language[0])
1262 {
1263 if (getenv("SOFTWARE") != NULL && (lang = getenv("LANG")) != NULL)
1264 {
1265 DEBUG_printf(("3appleLangDefault: Using LANG=%s", lang));
1266 strlcpy(cg->language, lang, sizeof(cg->language));
1267 return (cg->language);
1268 }
1269 else if ((bundle = CFBundleGetMainBundle()) != NULL &&
1270 (bundleList = CFBundleCopyBundleLocalizations(bundle)) != NULL)
1271 {
1272 CFURLRef resources = CFBundleCopyResourcesDirectoryURL(bundle);
1273
1274 DEBUG_puts("3appleLangDefault: Getting localizationList from bundle.");
1275
1276 if (resources)
1277 {
1278 CFStringRef cfpath = CFURLCopyPath(resources);
1279 char path[1024];
1280
1281 if (cfpath)
1282 {
1283 /*
1284 * See if we have an Info.plist file in the bundle...
1285 */
1286
1287 CFStringGetCString(cfpath, path, sizeof(path), kCFStringEncodingUTF8);
1288 DEBUG_printf(("3appleLangDefault: Got a resource URL (\"%s\")", path));
1289 strlcat(path, "Contents/Info.plist", sizeof(path));
1290
1291 if (!access(path, R_OK))
1292 localizationList = CFBundleCopyPreferredLocalizationsFromArray(bundleList);
1293 else
1294 DEBUG_puts("3appleLangDefault: No Info.plist, ignoring resource URL...");
1295
1296 CFRelease(cfpath);
1297 }
1298
1299 CFRelease(resources);
1300 }
1301 else
1302 DEBUG_puts("3appleLangDefault: No resource URL.");
1303
1304 CFRelease(bundleList);
1305 }
1306
1307 if (!localizationList)
1308 {
1309 DEBUG_puts("3appleLangDefault: Getting localizationList from preferences.");
1310
1311 localizationList =
1312 CFPreferencesCopyAppValue(CFSTR("AppleLanguages"),
1313 kCFPreferencesCurrentApplication);
1314 }
1315
1316 if (localizationList)
1317 {
1318 #ifdef DEBUG
1319 if (CFGetTypeID(localizationList) == CFArrayGetTypeID())
1320 DEBUG_printf(("3appleLangDefault: Got localizationList, %d entries.",
1321 (int)CFArrayGetCount(localizationList)));
1322 else
1323 DEBUG_puts("3appleLangDefault: Got localizationList but not an array.");
1324 #endif /* DEBUG */
1325
1326 if (CFGetTypeID(localizationList) == CFArrayGetTypeID() &&
1327 CFArrayGetCount(localizationList) > 0)
1328 {
1329 languageName = CFArrayGetValueAtIndex(localizationList, 0);
1330
1331 if (languageName &&
1332 CFGetTypeID(languageName) == CFStringGetTypeID())
1333 {
1334 if (_cupsAppleLocale(languageName, cg->language, sizeof(cg->language)))
1335 DEBUG_printf(("3appleLangDefault: cg->language=\"%s\"",
1336 cg->language));
1337 else
1338 DEBUG_puts("3appleLangDefault: Unable to get locale.");
1339 }
1340 }
1341
1342 CFRelease(localizationList);
1343 }
1344
1345 /*
1346 * If we didn't find the language, default to en_US...
1347 */
1348
1349 if (!cg->language[0])
1350 {
1351 DEBUG_puts("3appleLangDefault: Defaulting to en_US.");
1352 strlcpy(cg->language, "en_US.UTF-8", sizeof(cg->language));
1353 }
1354 }
1355 else
1356 DEBUG_printf(("3appleLangDefault: Using previous locale \"%s\".", cg->language));
1357
1358 /*
1359 * Return the cached locale...
1360 */
1361
1362 return (cg->language);
1363 }
1364
1365
1366 # ifdef CUPS_BUNDLEDIR
1367 /*
1368 * 'appleMessageLoad()' - Load a message catalog from a localizable bundle.
1369 */
1370
1371 static cups_array_t * /* O - Message catalog */
1372 appleMessageLoad(const char *locale) /* I - Locale ID */
1373 {
1374 char filename[1024], /* Path to cups.strings file */
1375 applelang[256], /* Apple language ID */
1376 baselang[4]; /* Base language */
1377 CFURLRef url; /* URL to cups.strings file */
1378 CFReadStreamRef stream = NULL; /* File stream */
1379 CFPropertyListRef plist = NULL; /* Localization file */
1380 #ifdef DEBUG
1381 const char *cups_strings = getenv("CUPS_STRINGS");
1382 /* Test strings file */
1383 CFErrorRef error = NULL; /* Error when opening file */
1384 #endif /* DEBUG */
1385
1386
1387 DEBUG_printf(("appleMessageLoad(locale=\"%s\")", locale));
1388
1389 /*
1390 * Load the cups.strings file...
1391 */
1392
1393 #ifdef DEBUG
1394 if (cups_strings)
1395 {
1396 DEBUG_puts("1appleMessageLoad: Using debug CUPS_STRINGS file.");
1397 strlcpy(filename, cups_strings, sizeof(filename));
1398 }
1399 else
1400 #endif /* DEBUG */
1401
1402 snprintf(filename, sizeof(filename),
1403 CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings",
1404 _cupsAppleLanguage(locale, applelang, sizeof(applelang)));
1405
1406 if (access(filename, 0))
1407 {
1408 /*
1409 * <rdar://problem/22086642>
1410 *
1411 * Try with original locale string...
1412 */
1413
1414 DEBUG_printf(("1appleMessageLoad: \"%s\": %s", filename, strerror(errno)));
1415 snprintf(filename, sizeof(filename), CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings", locale);
1416 }
1417
1418 if (access(filename, 0))
1419 {
1420 /*
1421 * <rdar://problem/25292403>
1422 *
1423 * Try with just the language code...
1424 */
1425
1426 DEBUG_printf(("1appleMessageLoad: \"%s\": %s", filename, strerror(errno)));
1427
1428 strlcpy(baselang, locale, sizeof(baselang));
1429 if (baselang[3] == '-' || baselang[3] == '_')
1430 baselang[3] = '\0';
1431
1432 snprintf(filename, sizeof(filename), CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings", baselang);
1433 }
1434
1435 if (access(filename, 0))
1436 {
1437 /*
1438 * Try alternate lproj directory names...
1439 */
1440
1441 DEBUG_printf(("1appleMessageLoad: \"%s\": %s", filename, strerror(errno)));
1442
1443 if (!strncmp(locale, "en", 2))
1444 locale = "English";
1445 else if (!strncmp(locale, "nb", 2))
1446 locale = "no";
1447 else if (!strncmp(locale, "nl", 2))
1448 locale = "Dutch";
1449 else if (!strncmp(locale, "fr", 2))
1450 locale = "French";
1451 else if (!strncmp(locale, "de", 2))
1452 locale = "German";
1453 else if (!strncmp(locale, "it", 2))
1454 locale = "Italian";
1455 else if (!strncmp(locale, "ja", 2))
1456 locale = "Japanese";
1457 else if (!strncmp(locale, "es", 2))
1458 locale = "Spanish";
1459 else if (!strcmp(locale, "zh_HK") || !strncasecmp(locale, "zh-Hant", 7) || !strncasecmp(locale, "zh_Hant", 7))
1460 {
1461 /*
1462 * <rdar://problem/22130168>
1463 * <rdar://problem/27245567>
1464 *
1465 * Try zh_TW first, then zh... Sigh...
1466 */
1467
1468 if (!access(CUPS_BUNDLEDIR "/Resources/zh_TW.lproj/cups.strings", 0))
1469 locale = "zh_TW";
1470 else
1471 locale = "zh";
1472 }
1473 else if (strstr(locale, "_") != NULL || strstr(locale, "-") != NULL)
1474 {
1475 /*
1476 * Drop country code, just try language...
1477 */
1478
1479 strlcpy(baselang, locale, sizeof(baselang));
1480 if (baselang[2] == '-' || baselang[2] == '_')
1481 baselang[2] = '\0';
1482
1483 locale = baselang;
1484 }
1485
1486 snprintf(filename, sizeof(filename),
1487 CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings", locale);
1488 }
1489
1490 DEBUG_printf(("1appleMessageLoad: filename=\"%s\"", filename));
1491
1492 url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
1493 (UInt8 *)filename,
1494 (CFIndex)strlen(filename), false);
1495 if (url)
1496 {
1497 stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, url);
1498 if (stream)
1499 {
1500 /*
1501 * Read the property list containing the localization data.
1502 *
1503 * NOTE: This code currently generates a clang "potential leak"
1504 * warning, but the object is released in _cupsMessageFree().
1505 */
1506
1507 CFReadStreamOpen(stream);
1508
1509 #ifdef DEBUG
1510 plist = CFPropertyListCreateWithStream(kCFAllocatorDefault, stream, 0,
1511 kCFPropertyListImmutable, NULL,
1512 &error);
1513 if (error)
1514 {
1515 CFStringRef msg = CFErrorCopyDescription(error);
1516 /* Error message */
1517
1518 CFStringGetCString(msg, filename, sizeof(filename),
1519 kCFStringEncodingUTF8);
1520 DEBUG_printf(("1appleMessageLoad: %s", filename));
1521
1522 CFRelease(msg);
1523 CFRelease(error);
1524 }
1525
1526 #else
1527 plist = CFPropertyListCreateWithStream(kCFAllocatorDefault, stream, 0,
1528 kCFPropertyListImmutable, NULL,
1529 NULL);
1530 #endif /* DEBUG */
1531
1532 if (plist && CFGetTypeID(plist) != CFDictionaryGetTypeID())
1533 {
1534 CFRelease(plist);
1535 plist = NULL;
1536 }
1537
1538 CFRelease(stream);
1539 }
1540
1541 CFRelease(url);
1542 }
1543
1544 DEBUG_printf(("1appleMessageLoad: url=%p, stream=%p, plist=%p", url, stream,
1545 plist));
1546
1547 /*
1548 * Create and return an empty array to act as a cache for messages, passing the
1549 * plist as the user data.
1550 */
1551
1552 return (_cupsMessageNew((void *)plist));
1553 }
1554 # endif /* CUPS_BUNDLEDIR */
1555 #endif /* __APPLE__ */
1556
1557
1558 /*
1559 * 'cups_cache_lookup()' - Lookup a language in the cache...
1560 */
1561
1562 static cups_lang_t * /* O - Language data or NULL */
1563 cups_cache_lookup(
1564 const char *name, /* I - Name of locale */
1565 cups_encoding_t encoding) /* I - Encoding of locale */
1566 {
1567 cups_lang_t *lang; /* Current language */
1568
1569
1570 DEBUG_printf(("7cups_cache_lookup(name=\"%s\", encoding=%d(%s))", name,
1571 encoding, encoding == CUPS_AUTO_ENCODING ? "auto" :
1572 lang_encodings[encoding]));
1573
1574 /*
1575 * Loop through the cache and return a match if found...
1576 */
1577
1578 for (lang = lang_cache; lang != NULL; lang = lang->next)
1579 {
1580 DEBUG_printf(("9cups_cache_lookup: lang=%p, language=\"%s\", "
1581 "encoding=%d(%s)", (void *)lang, lang->language, lang->encoding,
1582 lang_encodings[lang->encoding]));
1583
1584 if (!strcmp(lang->language, name) &&
1585 (encoding == CUPS_AUTO_ENCODING || encoding == lang->encoding))
1586 {
1587 lang->used ++;
1588
1589 DEBUG_puts("8cups_cache_lookup: returning match!");
1590
1591 return (lang);
1592 }
1593 }
1594
1595 DEBUG_puts("8cups_cache_lookup: returning NULL!");
1596
1597 return (NULL);
1598 }
1599
1600
1601 /*
1602 * 'cups_message_compare()' - Compare two messages.
1603 */
1604
1605 static int /* O - Result of comparison */
1606 cups_message_compare(
1607 _cups_message_t *m1, /* I - First message */
1608 _cups_message_t *m2) /* I - Second message */
1609 {
1610 return (strcmp(m1->id, m2->id));
1611 }
1612
1613
1614 /*
1615 * 'cups_message_free()' - Free a message.
1616 */
1617
1618 static void
1619 cups_message_free(_cups_message_t *m) /* I - Message */
1620 {
1621 if (m->id)
1622 free(m->id);
1623
1624 if (m->str)
1625 free(m->str);
1626
1627 free(m);
1628 }
1629
1630
1631 /*
1632 * 'cups_message_load()' - Load the message catalog for a language.
1633 */
1634
1635 static void
1636 cups_message_load(cups_lang_t *lang) /* I - Language */
1637 {
1638 #if defined(__APPLE__) && defined(CUPS_BUNDLEDIR)
1639 lang->strings = appleMessageLoad(lang->language);
1640
1641 #else
1642 char filename[1024]; /* Filename for language locale file */
1643 _cups_globals_t *cg = _cupsGlobals();
1644 /* Pointer to library globals */
1645
1646
1647 snprintf(filename, sizeof(filename), "%s/%s/cups_%s.po", cg->localedir,
1648 lang->language, lang->language);
1649
1650 if (strchr(lang->language, '_') && access(filename, 0))
1651 {
1652 /*
1653 * Country localization not available, look for generic localization...
1654 */
1655
1656 snprintf(filename, sizeof(filename), "%s/%.2s/cups_%.2s.po", cg->localedir,
1657 lang->language, lang->language);
1658
1659 if (access(filename, 0))
1660 {
1661 /*
1662 * No generic localization, so use POSIX...
1663 */
1664
1665 DEBUG_printf(("4cups_message_load: access(\"%s\", 0): %s", filename,
1666 strerror(errno)));
1667
1668 snprintf(filename, sizeof(filename), "%s/C/cups_C.po", cg->localedir);
1669 }
1670 }
1671
1672 /*
1673 * Read the strings from the file...
1674 */
1675
1676 lang->strings = _cupsMessageLoad(filename, 1);
1677 #endif /* __APPLE__ && CUPS_BUNDLEDIR */
1678 }
1679
1680
1681 /*
1682 * 'cups_unquote()' - Unquote characters in strings...
1683 */
1684
1685 static void
1686 cups_unquote(char *d, /* O - Unquoted string */
1687 const char *s) /* I - Original string */
1688 {
1689 while (*s)
1690 {
1691 if (*s == '\\')
1692 {
1693 s ++;
1694 if (isdigit(*s))
1695 {
1696 *d = 0;
1697
1698 while (isdigit(*s))
1699 {
1700 *d = *d * 8 + *s - '0';
1701 s ++;
1702 }
1703
1704 d ++;
1705 }
1706 else
1707 {
1708 if (*s == 'n')
1709 *d ++ = '\n';
1710 else if (*s == 'r')
1711 *d ++ = '\r';
1712 else if (*s == 't')
1713 *d ++ = '\t';
1714 else
1715 *d++ = *s;
1716
1717 s ++;
1718 }
1719 }
1720 else
1721 *d++ = *s++;
1722 }
1723
1724 *d = '\0';
1725 }
Unnamed repository; edit this file 'description' to name the repository.