cups/language.c

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