cups/language.c

   1 /*
   2  * "$Id: language.c 6489 2007-04-30 17:55:15Z mike $"
   3  *
   4  *   I18N/language support for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 1997-2007 by Easy Software Products.
   7  *
   8  *   These coded instructions, statements, and computer programs are the
   9  *   property of Easy Software Products and are protected by Federal
  10  *   copyright law.  Distribution and use rights are outlined in the file
  11  *   "LICENSE.txt" which should have been included with this file.  If this
  12  *   file is missing or damaged please contact Easy Software Products
  13  *   at:
  14  *
  15  *       Attn: CUPS Licensing Information
  16  *       Easy Software Products
  17  *       44141 Airport View Drive, Suite 204
  18  *       Hollywood, Maryland 20636 USA
  19  *
  20  *       Voice: (301) 373-9600
  21  *       EMail: cups-info@cups.org
  22  *         WWW: http://www.cups.org
  23  *
  24  *   This file is subject to the Apple OS-Developed Software exception.
  25  *
  26  * Contents:
  27  *
  28  *   _cupsEncodingName()    - Return the character encoding name string
  29  *                            for the given encoding enumeration.
  30  *   cupsLangDefault()      - Return the default language.
  31  *   cupsLangEncoding()     - Return the character encoding (us-ascii, etc.)
  32  *                            for the given language.
  33  *   cupsLangFlush()        - Flush all language data out of the cache.
  34  *   cupsLangFree()         - Free language data.
  35  *   cupsLangGet()          - Get a language.
  36  *   _cupsLangString()      - Get a message string.
  37  *   _cupsMessageFree()     - Free a messages array.
  38  *   _cupsMessageLoad()     - Load a .po file into a messages array.
  39  *   _cupsMessageLookup()   - Lookup a message string.
  40  *   appleLangDefault()     - Get the default locale string.
  41  *   cups_cache_lookup()    - Lookup a language in the cache...
  42  *   cups_message_compare() - Compare two messages.
  43  *   cups_unquote()         - Unquote characters in strings...
  44  */
  45
  46 /*
  47  * Include necessary headers...
  48  */
  49
  50 #include "globals.h"
  51 #include "debug.h"
  52 #include <stdlib.h>
  53 #include <errno.h>
  54 #ifdef HAVE_LANGINFO_H
  55 #  include <langinfo.h>
  56 #endif /* HAVE_LANGINFO_H */
  57 #ifdef WIN32
  58 #  include <io.h>
  59 #else
  60 #  include <unistd.h>
  61 #endif /* WIN32 */
  62 #ifdef HAVE_COREFOUNDATION_H
  63 #  include <CoreFoundation/CoreFoundation.h>
  64 #endif /* HAVE_COREFOUNDATION_H */
  65
  66
  67 /*
  68  * Local globals...
  69  */
  70
  71 #ifdef HAVE_PTHREAD_H
  72 static pthread_mutex_t  lang_mutex = PTHREAD_MUTEX_INITIALIZER;
  73                                         /* Mutex to control access to cache */
  74 #endif /* HAVE_PTHREAD_H */
  75 static cups_lang_t      *lang_cache = NULL;
  76                                         /* Language string cache */
  77
  78
  79 /*
  80  * Local functions...
  81  */
  82
  83 #ifdef __APPLE__
  84 static const char       *appleLangDefault(void);
  85 #endif /* __APPLE__ */
  86 static cups_lang_t      *cups_cache_lookup(const char *name,
  87                                            cups_encoding_t encoding);
  88 static int              cups_message_compare(_cups_message_t *m1,
  89                                              _cups_message_t *m2);
  90 static void             cups_unquote(char *d, const char *s);
  91
  92
  93 /*
  94  * Local globals...
  95  */
  96
  97 static const char * const lang_encodings[] =
  98                         {               /* Encoding strings */
  99                           "us-ascii",           "iso-8859-1",
 100                           "iso-8859-2",         "iso-8859-3",
 101                           "iso-8859-4",         "iso-8859-5",
 102                           "iso-8859-6",         "iso-8859-7",
 103                           "iso-8859-8",         "iso-8859-9",
 104                           "iso-8859-10",        "utf-8",
 105                           "iso-8859-13",        "iso-8859-14",
 106                           "iso-8859-15",        "windows-874",
 107                           "windows-1250",       "windows-1251",
 108                           "windows-1252",       "windows-1253",
 109                           "windows-1254",       "windows-1255",
 110                           "windows-1256",       "windows-1257",
 111                           "windows-1258",       "koi8-r",
 112                           "koi8-u",             "iso-8859-11",
 113                           "iso-8859-16",        "mac-roman",
 114                           "unknown",            "unknown",
 115                           "unknown",            "unknown",
 116                           "unknown",            "unknown",
 117                           "unknown",            "unknown",
 118                           "unknown",            "unknown",
 119                           "unknown",            "unknown",
 120                           "unknown",            "unknown",
 121                           "unknown",            "unknown",
 122                           "unknown",            "unknown",
 123                           "unknown",            "unknown",
 124                           "unknown",            "unknown",
 125                           "unknown",            "unknown",
 126                           "unknown",            "unknown",
 127                           "unknown",            "unknown",
 128                           "unknown",            "unknown",
 129                           "unknown",            "unknown",
 130                           "unknown",            "unknown",
 131                           "windows-932",        "windows-936",
 132                           "windows-949",        "windows-950",
 133                           "windows-1361",       "unknown",
 134                           "unknown",            "unknown",
 135                           "unknown",            "unknown",
 136                           "unknown",            "unknown",
 137                           "unknown",            "unknown",
 138                           "unknown",            "unknown",
 139                           "unknown",            "unknown",
 140                           "unknown",            "unknown",
 141                           "unknown",            "unknown",
 142                           "unknown",            "unknown",
 143                           "unknown",            "unknown",
 144                           "unknown",            "unknown",
 145                           "unknown",            "unknown",
 146                           "unknown",            "unknown",
 147                           "unknown",            "unknown",
 148                           "unknown",            "unknown",
 149                           "unknown",            "unknown",
 150                           "unknown",            "unknown",
 151                           "unknown",            "unknown",
 152                           "unknown",            "unknown",
 153                           "unknown",            "unknown",
 154                           "unknown",            "unknown",
 155                           "unknown",            "unknown",
 156                           "unknown",            "unknown",
 157                           "unknown",            "unknown",
 158                           "unknown",            "unknown",
 159                           "unknown",            "unknown",
 160                           "unknown",            "unknown",
 161                           "unknown",            "unknown",
 162                           "unknown",            "unknown",
 163                           "euc-cn",             "euc-jp",
 164                           "euc-kr",             "euc-tw"
 165                         };
 166
 167
 168 /*
 169  * '_cupsEncodingName()' - Return the character encoding name string
 170  *                         for the given encoding enumeration.
 171  */
 172
 173 const char *                            /* O - Character encoding */
 174 _cupsEncodingName(
 175     cups_encoding_t encoding)           /* I - Encoding value */
 176 {
 177   if (encoding < 0 ||
 178       encoding >= (sizeof(lang_encodings) / sizeof(const char *)))
 179     return (lang_encodings[0]);
 180   else
 181     return (lang_encodings[encoding]);
 182 }
 183
 184
 185 /*
 186  * 'cupsLangDefault()' - Return the default language.
 187  */
 188
 189 cups_lang_t *                           /* O - Language data */
 190 cupsLangDefault(void)
 191 {
 192   return (cupsLangGet(NULL));
 193 }
 194
 195
 196 /*
 197  * 'cupsLangEncoding()' - Return the character encoding (us-ascii, etc.)
 198  *                        for the given language.
 199  */
 200
 201 const char *                            /* O - Character encoding */
 202 cupsLangEncoding(cups_lang_t *lang)     /* I - Language data */
 203 {
 204   if (lang == NULL)
 205     return ((char*)lang_encodings[0]);
 206   else
 207     return ((char*)lang_encodings[lang->encoding]);
 208 }
 209
 210
 211 /*
 212  * 'cupsLangFlush()' - Flush all language data out of the cache.
 213  */
 214
 215 void
 216 cupsLangFlush(void)
 217 {
 218   cups_lang_t   *lang,                  /* Current language */
 219                 *next;                  /* Next language */
 220
 221
 222  /*
 223   * Free all languages in the cache...
 224   */
 225
 226 #ifdef HAVE_PTHREAD_H
 227   pthread_mutex_lock(&lang_mutex);
 228 #endif /* HAVE_PTHREAD_H */
 229
 230   for (lang = lang_cache; lang != NULL; lang = next)
 231   {
 232    /*
 233     * Free all messages...
 234     */
 235
 236     _cupsMessageFree(lang->strings);
 237
 238    /*
 239     * Then free the language structure itself...
 240     */
 241
 242     next = lang->next;
 243     free(lang);
 244   }
 245
 246   lang_cache = NULL;
 247
 248 #ifdef HAVE_PTHREAD_H
 249   pthread_mutex_unlock(&lang_mutex);
 250 #endif /* HAVE_PTHREAD_H */
 251 }
 252
 253
 254 /*
 255  * 'cupsLangFree()' - Free language data.
 256  *
 257  * This does not actually free anything; use cupsLangFlush() for that.
 258  */
 259
 260 void
 261 cupsLangFree(cups_lang_t *lang)         /* I - Language to free */
 262 {
 263 #ifdef HAVE_PTHREAD_H
 264   pthread_mutex_lock(&lang_mutex);
 265 #endif /* HAVE_PTHREAD_H */
 266
 267   if (lang != NULL && lang->used > 0)
 268     lang->used --;
 269
 270 #ifdef HAVE_PTHREAD_H
 271   pthread_mutex_unlock(&lang_mutex);
 272 #endif /* HAVE_PTHREAD_H */
 273 }
 274
 275
 276 /*
 277  * 'cupsLangGet()' - Get a language.
 278  */
 279
 280 cups_lang_t *                           /* O - Language data */
 281 cupsLangGet(const char *language)       /* I - Language or locale */
 282 {
 283   int                   i;              /* Looping var */
 284 #ifndef __APPLE__
 285   char                  locale[255];    /* Copy of locale name */
 286 #endif /* !__APPLE__ */
 287   char                  langname[16],   /* Requested language name */
 288                         country[16],    /* Country code */
 289                         charset[16],    /* Character set */
 290                         *csptr,         /* Pointer to CODESET string */
 291                         *ptr,           /* Pointer into language/charset */
 292                         real[48],       /* Real language name */
 293                         filename[1024]; /* Filename for language locale file */
 294   cups_encoding_t       encoding;       /* Encoding to use */
 295   cups_lang_t           *lang;          /* Current language... */
 296   _cups_globals_t       *cg = _cupsGlobals();
 297                                         /* Pointer to library globals */
 298   static const char * const locale_encodings[] =
 299                 {                       /* Locale charset names */
 300                   "ASCII",      "ISO88591",     "ISO88592",     "ISO88593",
 301                   "ISO88594",   "ISO88595",     "ISO88596",     "ISO88597",
 302                   "ISO88598",   "ISO88599",     "ISO885910",    "UTF8",
 303                   "ISO885913",  "ISO885914",    "ISO885915",    "CP874",
 304                   "CP1250",     "CP1251",       "CP1252",       "CP1253",
 305                   "CP1254",     "CP1255",       "CP1256",       "CP1257",
 306                   "CP1258",     "KOI8R",        "KOI8U",        "ISO885911",
 307                   "ISO885916",  "MACROMAN",     "",             "",
 308
 309                   "",           "",             "",             "",
 310                   "",           "",             "",             "",
 311                   "",           "",             "",             "",
 312                   "",           "",             "",             "",
 313                   "",           "",             "",             "",
 314                   "",           "",             "",             "",
 315                   "",           "",             "",             "",
 316                   "",           "",             "",             "",
 317
 318                   "CP932",      "CP936",        "CP949",        "CP950",
 319                   "CP1361",     "",             "",             "",
 320                   "",           "",             "",             "",
 321                   "",           "",             "",             "",
 322                   "",           "",             "",             "",
 323                   "",           "",             "",             "",
 324                   "",           "",             "",             "",
 325                   "",           "",             "",             "",
 326
 327                   "",           "",             "",             "",
 328                   "",           "",             "",             "",
 329                   "",           "",             "",             "",
 330                   "",           "",             "",             "",
 331                   "",           "",             "",             "",
 332                   "",           "",             "",             "",
 333                   "",           "",             "",             "",
 334                   "",           "",             "",             "",
 335
 336                   "EUCCN",      "EUCJP",        "EUCKR",        "EUCTW"
 337                 };
 338
 339
 340   DEBUG_printf(("cupsLangGet(language=\"%s\")\n", language ? language : "(null)"));
 341
 342 #ifdef __APPLE__
 343  /*
 344   * Set the character set to UTF-8...
 345   */
 346
 347   strcpy(charset, "UTF8");
 348
 349  /*
 350   * Apple's setlocale doesn't give us the user's localization
 351   * preference so we have to look it up this way...
 352   */
 353
 354   if (!language)
 355     language = appleLangDefault();
 356
 357 #else
 358  /*
 359   * Set the charset to "unknown"...
 360   */
 361
 362   charset[0] = '\0';
 363
 364  /*
 365   * Use setlocale() to determine the currently set locale, and then
 366   * fallback to environment variables to avoid setting the locale,
 367   * since setlocale() is not thread-safe!
 368   */
 369
 370   if (!language)
 371   {
 372    /*
 373     * First see if the locale has been set; if it is still "C" or
 374     * "POSIX", use the environment to get the default...
 375     */
 376
 377 #  ifdef LC_MESSAGES
 378     ptr = setlocale(LC_MESSAGES, NULL);
 379 #  else
 380     ptr = setlocale(LC_ALL, NULL);
 381 #  endif /* LC_MESSAGES */
 382
 383     DEBUG_printf(("cupsLangGet: current locale is \"%s\"\n",
 384                   ptr ? ptr : "(null)"));
 385
 386     if (!ptr || !strcmp(ptr, "C") || !strcmp(ptr, "POSIX"))
 387     {
 388      /*
 389       * Get the character set from the LC_CTYPE locale setting...
 390       */
 391
 392       if ((ptr = getenv("LC_CTYPE")) == NULL)
 393         if ((ptr = getenv("LC_ALL")) == NULL)
 394           if ((ptr = getenv("LANG")) == NULL)
 395             ptr = "en_US";
 396
 397       if ((csptr = strchr(ptr, '.')) != NULL)
 398       {
 399        /*
 400         * Extract the character set from the environment...
 401         */
 402
 403         for (ptr = charset, csptr ++; *csptr; csptr ++)
 404           if (ptr < (charset + sizeof(charset) - 1) && isalnum(*csptr & 255))
 405             *ptr++ = *csptr;
 406
 407         *ptr = '\0';
 408       }
 409
 410      /*
 411       * Get the locale for messages from the LC_MESSAGES locale setting...
 412       */
 413
 414       if ((ptr = getenv("LC_MESSAGES")) == NULL)
 415         if ((ptr = getenv("LC_ALL")) == NULL)
 416           if ((ptr = getenv("LANG")) == NULL)
 417             ptr = "en_US";
 418     }
 419
 420     if (ptr)
 421     {
 422       strlcpy(locale, ptr, sizeof(locale));
 423       language = locale;
 424
 425       DEBUG_printf(("cupsLangGet: new language value is \"%s\"\n",
 426                     language ? language : "(null)"));
 427     }
 428   }
 429 #endif /* __APPLE__ */
 430
 431  /*
 432   * If "language" is NULL at this point, then chances are we are using
 433   * a language that is not installed for the base OS.
 434   */
 435
 436   if (!language)
 437   {
 438    /*
 439     * Switch to the POSIX ("C") locale...
 440     */
 441
 442     language = "C";
 443   }
 444
 445 #ifdef CODESET
 446  /*
 447   * On systems that support the nl_langinfo(CODESET) call, use
 448   * this value as the character set...
 449   */
 450
 451   if (!charset[0] && (csptr = nl_langinfo(CODESET)) != NULL)
 452   {
 453    /*
 454     * Copy all of the letters and numbers in the CODESET string...
 455     */
 456
 457     for (ptr = charset; *csptr; csptr ++)
 458       if (isalnum(*csptr & 255) && ptr < (charset + sizeof(charset) - 1))
 459         *ptr++ = *csptr;
 460
 461     *ptr = '\0';
 462
 463     DEBUG_printf(("cupsLangGet: charset set to \"%s\" via nl_langinfo(CODESET)...\n",
 464                   charset));
 465   }
 466 #endif /* CODESET */
 467
 468  /*
 469   * If we don't have a character set by now, default to UTF-8...
 470   */
 471
 472   if (!charset[0])
 473     strcpy(charset, "UTF8");
 474
 475  /*
 476   * Parse the language string passed in to a locale string. "C" is the
 477   * standard POSIX locale and is copied unchanged.  Otherwise the
 478   * language string is converted from ll-cc[.charset] (language-country)
 479   * to ll_CC[.CHARSET] to match the file naming convention used by all
 480   * POSIX-compliant operating systems.  Invalid language names are mapped
 481   * to the POSIX locale.
 482   */
 483
 484   country[0] = '\0';
 485
 486   if (language == NULL || !language[0] ||
 487       !strcmp(language, "POSIX"))
 488     strcpy(langname, "C");
 489   else
 490   {
 491    /*
 492     * Copy the parts of the locale string over safely...
 493     */
 494
 495     for (ptr = langname; *language; language ++)
 496       if (*language == '_' || *language == '-' || *language == '.')
 497         break;
 498       else if (ptr < (langname + sizeof(langname) - 1))
 499         *ptr++ = tolower(*language & 255);
 500
 501     *ptr = '\0';
 502
 503     if (*language == '_' || *language == '-')
 504     {
 505      /*
 506       * Copy the country code...
 507       */
 508
 509       for (language ++, ptr = country; *language; language ++)
 510         if (*language == '.')
 511           break;
 512         else if (ptr < (country + sizeof(country) - 1))
 513           *ptr++ = toupper(*language & 255);
 514
 515       *ptr = '\0';
 516     }
 517
 518     if (*language == '.' && !charset[0])
 519     {
 520      /*
 521       * Copy the encoding...
 522       */
 523
 524       for (language ++, ptr = charset; *language; language ++)
 525         if (isalnum(*language & 255) && ptr < (charset + sizeof(charset) - 1))
 526           *ptr++ = toupper(*language & 255);
 527
 528       *ptr = '\0';
 529     }
 530
 531    /*
 532     * Force a POSIX locale for an invalid language name...
 533     */
 534
 535     if (strlen(langname) != 2)
 536     {
 537       strcpy(langname, "C");
 538       country[0] = '\0';
 539       charset[0] = '\0';
 540     }
 541   }
 542
 543   DEBUG_printf(("cupsLangGet: langname=\"%s\", country=\"%s\", charset=\"%s\"\n",
 544                 langname, country, charset));
 545
 546  /*
 547   * Figure out the desired encoding...
 548   */
 549
 550   encoding = CUPS_AUTO_ENCODING;
 551
 552   if (charset[0])
 553   {
 554     for (i = 0;
 555          i < (int)(sizeof(locale_encodings) / sizeof(locale_encodings[0]));
 556          i ++)
 557       if (!strcasecmp(charset, locale_encodings[i]))
 558       {
 559         encoding = (cups_encoding_t)i;
 560         break;
 561       }
 562
 563     if (encoding == CUPS_AUTO_ENCODING)
 564     {
 565      /*
 566       * Map alternate names for various character sets...
 567       */
 568
 569       if (!strcasecmp(charset, "iso-2022-jp") ||
 570           !strcasecmp(charset, "sjis"))
 571         encoding = CUPS_WINDOWS_932;
 572       else if (!strcasecmp(charset, "iso-2022-cn"))
 573         encoding = CUPS_WINDOWS_936;
 574       else if (!strcasecmp(charset, "iso-2022-kr"))
 575         encoding = CUPS_WINDOWS_949;
 576       else if (!strcasecmp(charset, "big5"))
 577         encoding = CUPS_WINDOWS_950;
 578     }
 579   }
 580
 581   DEBUG_printf(("cupsLangGet: encoding=%d(%s)\n", encoding,
 582                 encoding == CUPS_AUTO_ENCODING ? "auto" :
 583                     lang_encodings[encoding]));
 584
 585  /*
 586   * See if we already have this language/country loaded...
 587   */
 588
 589   if (country[0])
 590   {
 591     snprintf(real, sizeof(real), "%s_%s", langname, country);
 592
 593     snprintf(filename, sizeof(filename), "%s/%s/cups_%s.po", cg->localedir,
 594              real, real);
 595   }
 596   else
 597   {
 598     strcpy(real, langname);
 599     filename[0] = '\0';                 /* anti-compiler-warning-code */
 600   }
 601
 602 #ifdef HAVE_PTHREAD_H
 603   pthread_mutex_lock(&lang_mutex);
 604 #endif /* HAVE_PTHREAD_H */
 605
 606   if ((lang = cups_cache_lookup(real, encoding)) != NULL)
 607   {
 608 #ifdef HAVE_PTHREAD_H
 609     pthread_mutex_unlock(&lang_mutex);
 610 #endif /* HAVE_PTHREAD_H */
 611
 612     return (lang);
 613   }
 614
 615   if (!country[0] || access(filename, 0))
 616   {
 617    /*
 618     * Country localization not available, look for generic localization...
 619     */
 620
 621     snprintf(filename, sizeof(filename), "%s/%s/cups_%s.po", cg->localedir,
 622              langname, langname);
 623
 624     if (access(filename, 0))
 625     {
 626      /*
 627       * No generic localization, so use POSIX...
 628       */
 629
 630       DEBUG_printf(("access(\"%s\", 0): %s\n", filename, strerror(errno)));
 631
 632       snprintf(filename, sizeof(filename), "%s/C/cups_C.po", cg->localedir);
 633     }
 634   }
 635
 636  /*
 637   * See if there is a free language available; if so, use that
 638   * record...
 639   */
 640
 641   for (lang = lang_cache; lang != NULL; lang = lang->next)
 642     if (lang->used == 0)
 643       break;
 644
 645   if (lang == NULL)
 646   {
 647    /*
 648     * Allocate memory for the language and add it to the cache.
 649     */
 650
 651     if ((lang = calloc(sizeof(cups_lang_t), 1)) == NULL)
 652     {
 653 #ifdef HAVE_PTHREAD_H
 654       pthread_mutex_unlock(&lang_mutex);
 655 #endif /* HAVE_PTHREAD_H */
 656
 657       return (NULL);
 658     }
 659
 660     lang->next = lang_cache;
 661     lang_cache = lang;
 662   }
 663   else
 664   {
 665    /*
 666     * Free all old strings as needed...
 667     */
 668
 669     _cupsMessageFree(lang->strings);
 670   }
 671
 672  /*
 673   * Then assign the language and encoding fields...
 674   */
 675
 676   lang->used ++;
 677   strlcpy(lang->language, real, sizeof(lang->language));
 678
 679   if (encoding != CUPS_AUTO_ENCODING)
 680     lang->encoding = encoding;
 681   else
 682     lang->encoding = CUPS_UTF8;
 683
 684  /*
 685   * Read the strings from the file...
 686   */
 687
 688   lang->strings = _cupsMessageLoad(filename);
 689
 690  /*
 691   * Return...
 692   */
 693
 694 #ifdef HAVE_PTHREAD_H
 695   pthread_mutex_unlock(&lang_mutex);
 696 #endif /* HAVE_PTHREAD_H */
 697
 698   return (lang);
 699 }
 700
 701
 702 /*
 703  * '_cupsLangString()' - Get a message string.
 704  *
 705  * The returned string is UTF-8 encoded; use cupsUTF8ToCharset() to
 706  * convert the string to the language encoding.
 707  */
 708
 709 const char *                            /* O - Localized message */
 710 _cupsLangString(cups_lang_t *lang,      /* I - Language */
 711                 const char  *message)   /* I - Message */
 712 {
 713  /*
 714   * Range check input...
 715   */
 716
 717   if (!lang || !message)
 718     return (message);
 719
 720 #ifdef HAVE_PTHREAD_H
 721   {
 722     const char *s;                      /* Localized message */
 723
 724     pthread_mutex_lock(&lang_mutex);
 725
 726     s = _cupsMessageLookup(lang->strings, message);
 727
 728     pthread_mutex_unlock(&lang_mutex);
 729
 730     return (s);
 731   }
 732 #else
 733   return (_cupsMessageLookup(lang->strings, message));
 734 #endif /* HAVE_PTHREAD_H */
 735 }
 736
 737
 738 /*
 739  * '_cupsMessageFree()' - Free a messages array.
 740  */
 741
 742 void
 743 _cupsMessageFree(cups_array_t *a)       /* I - Message array */
 744 {
 745   _cups_message_t       *m;             /* Current message */
 746
 747
 748   for (m = (_cups_message_t *)cupsArrayFirst(a);
 749        m;
 750        m = (_cups_message_t *)cupsArrayNext(a))
 751   {
 752    /*
 753     * Remove the message from the array, then free the message and strings.
 754     */
 755
 756     cupsArrayRemove(a, m);
 757
 758     if (m->id)
 759       free(m->id);
 760
 761     if (m->str)
 762       free(m->str);
 763
 764     free(m);
 765   }
 766
 767  /*
 768   * Free the array...
 769   */
 770
 771   cupsArrayDelete(a);
 772 }
 773
 774
 775 /*
 776  * '_cupsMessageLoad()' - Load a .po file into a messages array.
 777  */
 778
 779 cups_array_t *                          /* O - New message array */
 780 _cupsMessageLoad(const char *filename)  /* I - Message catalog to load */
 781 {
 782   cups_file_t           *fp;            /* Message file */
 783   cups_array_t          *a;             /* Message array */
 784   _cups_message_t       *m;             /* Current message */
 785   char                  s[4096],        /* String buffer */
 786                         *ptr,           /* Pointer into buffer */
 787                         *temp;          /* New string */
 788   int                   length;         /* Length of combined strings */
 789
 790
 791   DEBUG_printf(("_cupsMessageLoad(filename=\"%s\")\n", filename));
 792
 793  /*
 794   * Create an array to hold the messages...
 795   */
 796
 797   if ((a = cupsArrayNew((cups_array_func_t)cups_message_compare, NULL)) == NULL)
 798     return (NULL);
 799
 800  /*
 801   * Open the message catalog file...
 802   */
 803
 804   if ((fp = cupsFileOpen(filename, "r")) == NULL)
 805     return (a);
 806
 807  /*
 808   * Read messages from the catalog file until EOF...
 809   *
 810   * The format is the GNU gettext .po format, which is fairly simple:
 811   *
 812   *     msgid "some text"
 813   *     msgstr "localized text"
 814   *
 815   * The ID and localized text can span multiple lines using the form:
 816   *
 817   *     msgid ""
 818   *     "some long text"
 819   *     msgstr ""
 820   *     "localized text spanning "
 821   *     "multiple lines"
 822   */
 823
 824   m = NULL;
 825
 826   while (cupsFileGets(fp, s, sizeof(s)) != NULL)
 827   {
 828    /*
 829     * Skip blank and comment lines...
 830     */
 831
 832     if (s[0] == '#' || !s[0])
 833       continue;
 834
 835    /*
 836     * Strip the trailing quote...
 837     */
 838
 839     if ((ptr = strrchr(s, '\"')) == NULL)
 840       continue;
 841
 842     *ptr = '\0';
 843
 844    /*
 845     * Find start of value...
 846     */
 847
 848     if ((ptr = strchr(s, '\"')) == NULL)
 849       continue;
 850
 851     ptr ++;
 852
 853    /*
 854     * Unquote the text...
 855     */
 856
 857     cups_unquote(ptr, ptr);
 858
 859    /*
 860     * Create or add to a message...
 861     */
 862
 863     if (!strncmp(s, "msgid", 5))
 864     {
 865      /*
 866       * Add previous message as needed...
 867       */
 868
 869       if (m)
 870         cupsArrayAdd(a, m);
 871
 872      /*
 873       * Create a new message with the given msgid string...
 874       */
 875
 876       if ((m = (_cups_message_t *)calloc(1, sizeof(_cups_message_t))) == NULL)
 877       {
 878         cupsFileClose(fp);
 879         return (a);
 880       }
 881
 882       m->id = strdup(ptr);
 883     }
 884     else if (s[0] == '\"' && m)
 885     {
 886      /*
 887       * Append to current string...
 888       */
 889
 890       length = (int)strlen(m->str ? m->str : m->id);
 891
 892       if ((temp = realloc(m->str ? m->str : m->id,
 893                           length + strlen(ptr) + 1)) == NULL)
 894       {
 895         cupsFileClose(fp);
 896         return (a);
 897       }
 898
 899       if (m->str)
 900       {
 901        /*
 902         * Copy the new portion to the end of the msgstr string - safe
 903         * to use strcpy because the buffer is allocated to the correct
 904         * size...
 905         */
 906
 907         m->str = temp;
 908
 909         strcpy(m->str + length, ptr);
 910       }
 911       else
 912       {
 913        /*
 914         * Copy the new portion to the end of the msgid string - safe
 915         * to use strcpy because the buffer is allocated to the correct
 916         * size...
 917         */
 918
 919         m->id = temp;
 920
 921         strcpy(m->id + length, ptr);
 922       }
 923     }
 924     else if (!strncmp(s, "msgstr", 6) && m)
 925     {
 926      /*
 927       * Set the string...
 928       */
 929
 930       m->str = strdup(ptr);
 931     }
 932   }
 933
 934  /*
 935   * Add the last message string to the array as needed...
 936   */
 937
 938   if (m)
 939     cupsArrayAdd(a, m);
 940
 941  /*
 942   * Close the message catalog file and return the new array...
 943   */
 944
 945   cupsFileClose(fp);
 946
 947   return (a);
 948 }
 949
 950
 951 /*
 952  * '_cupsMessageLookup()' - Lookup a message string.
 953  */
 954
 955 const char *                            /* O - Localized message */
 956 _cupsMessageLookup(cups_array_t *a,     /* I - Message array */
 957                    const char   *m)     /* I - Message */
 958 {
 959   _cups_message_t       key,            /* Search key */
 960                         *match;         /* Matching message */
 961
 962
 963  /*
 964   * Lookup the message string; if it doesn't exist in the catalog,
 965   * then return the message that was passed to us...
 966   */
 967
 968   key.id = (char *)m;
 969   match  = (_cups_message_t *)cupsArrayFind(a, &key);
 970
 971   if (match && match->str)
 972     return (match->str);
 973   else
 974     return (m);
 975 }
 976
 977
 978 #ifdef __APPLE__
 979 /*
 980  * Code & data to translate OSX's language names to their ISO 639-1 locale.
 981  *
 982  * The first version uses the new CoreFoundation API added in 10.3 (Panther),
 983  * the second is for 10.2 (Jaguar).
 984  */
 985
 986 #  ifdef HAVE_CF_LOCALE_ID
 987
 988 typedef struct
 989 {
 990   const char * const name;              /* Language name */
 991   const char * const locale;            /* Locale name */
 992 } _apple_name_locale_t;
 993
 994 static const _apple_name_locale_t apple_name_locale[] =
 995 {
 996   { "en"        , "en_US" },
 997   { "no"        , "nb"    },
 998   { "zh-Hans"   , "zh_CN" },
 999   { "zh-Hant"   , "zh_TW" }
1000 };
1001
1002 /*
1003  * 'appleLangDefault()' - Get the default locale string.
1004  */
1005
1006 static const char *                     /* O - Locale string */
1007 appleLangDefault(void)
1008 {
1009   int                   i;              /* Looping var */
1010   CFPropertyListRef     localizationList;
1011                                         /* List of localization data */
1012   CFStringRef           languageName;   /* Current name */
1013   CFStringRef           localeName;     /* Canonical from of name */
1014   char                  *lang;          /* LANG environment variable */
1015   _cups_globals_t       *cg = _cupsGlobals();
1016                                         /* Pointer to library globals */
1017
1018
1019  /*
1020   * Only do the lookup and translation the first time.
1021   */
1022
1023   if (!cg->language[0])
1024   {
1025     if ((lang = getenv("LANG")))
1026       strlcpy(cg->language, lang, sizeof(cg->language));
1027     else
1028     {
1029       localizationList =
1030           CFPreferencesCopyAppValue(CFSTR("AppleLanguages"),
1031                                     kCFPreferencesCurrentApplication);
1032
1033       if (localizationList != NULL)
1034       {
1035         if (CFGetTypeID(localizationList) == CFArrayGetTypeID() &&
1036             CFArrayGetCount(localizationList) > 0)
1037         {
1038           languageName = CFArrayGetValueAtIndex(localizationList, 0);
1039
1040           if (languageName != NULL &&
1041               CFGetTypeID(languageName) == CFStringGetTypeID())
1042           {
1043             localeName = CFLocaleCreateCanonicalLocaleIdentifierFromString(
1044                              kCFAllocatorDefault, languageName);
1045
1046             if (localeName != NULL)
1047             {
1048               CFStringGetCString(localeName, cg->language, sizeof(cg->language),
1049                                  kCFStringEncodingASCII);
1050               CFRelease(localeName);
1051
1052              /*
1053               * Map new language identifiers to locales...
1054               */
1055
1056               for (i = 0;
1057                    i < sizeof(apple_name_locale) / sizeof(apple_name_locale[0]);
1058                    i++)
1059               {
1060                 if (!strcmp(cg->language, apple_name_locale[i].name))
1061                 {
1062                   strlcpy(cg->language, apple_name_locale[i].locale,
1063                           sizeof(cg->language));
1064                   break;
1065                 }
1066               }
1067
1068              /*
1069               * Convert language subtag into region subtag...
1070               */
1071
1072               if (cg->language[2] == '-')
1073                 cg->language[2] = '_';
1074
1075               if (strchr(cg->language, '.') == NULL)
1076                 strlcat(cg->language, ".UTF-8", sizeof(cg->language));
1077             }
1078           }
1079         }
1080
1081         CFRelease(localizationList);
1082       }
1083     }
1084
1085    /*
1086     * If we didn't find the language, default to en_US...
1087     */
1088
1089     if (!cg->language[0])
1090       strlcpy(cg->language, "en_US.UTF-8", sizeof(cg->language));
1091   }
1092
1093  /*
1094   * Return the cached locale...
1095   */
1096
1097   return (cg->language);
1098 }
1099 #  else
1100 /*
1101  * Code & data to translate OSX 10.2's language names to their ISO 639-1
1102  * locale.
1103  */
1104
1105 typedef struct
1106 {
1107   const char * const name;              /* Language name */
1108   const char * const locale;            /* Locale name */
1109 } _apple_name_locale_t;
1110
1111 static const _apple_name_locale_t apple_name_locale[] =
1112 {
1113   { "English"     , "en_US.UTF-8" },    { "French"     , "fr.UTF-8" },
1114   { "German"      , "de.UTF-8" },       { "Italian"    , "it.UTF-8" },
1115   { "Dutch"       , "nl.UTF-8" },       { "Swedish"    , "sv.UTF-8" },
1116   { "Spanish"     , "es.UTF-8" },       { "Danish"     , "da.UTF-8" },
1117   { "Portuguese"  , "pt.UTF-8" },       { "Norwegian"  , "no.UTF-8" },
1118   { "Hebrew"      , "he.UTF-8" },       { "Japanese"   , "ja.UTF-8" },
1119   { "Arabic"      , "ar.UTF-8" },       { "Finnish"    , "fi.UTF-8" },
1120   { "Greek"       , "el.UTF-8" },       { "Icelandic"  , "is.UTF-8" },
1121   { "Maltese"     , "mt.UTF-8" },       { "Turkish"    , "tr.UTF-8" },
1122   { "Croatian"    , "hr.UTF-8" },       { "Chinese"    , "zh.UTF-8" },
1123   { "Urdu"        , "ur.UTF-8" },       { "Hindi"      , "hi.UTF-8" },
1124   { "Thai"        , "th.UTF-8" },       { "Korean"     , "ko.UTF-8" },
1125   { "Lithuanian"  , "lt.UTF-8" },       { "Polish"     , "pl.UTF-8" },
1126   { "Hungarian"   , "hu.UTF-8" },       { "Estonian"   , "et.UTF-8" },
1127   { "Latvian"     , "lv.UTF-8" },       { "Sami"       , "se.UTF-8" },
1128   { "Faroese"     , "fo.UTF-8" },       { "Farsi"      , "fa.UTF-8" },
1129   { "Russian"     , "ru.UTF-8" },       { "Chinese"    , "zh.UTF-8" },
1130   { "Dutch"       , "nl.UTF-8" },       { "Irish"      , "ga.UTF-8" },
1131   { "Albanian"    , "sq.UTF-8" },       { "Romanian"   , "ro.UTF-8" },
1132   { "Czech"       , "cs.UTF-8" },       { "Slovak"     , "sk.UTF-8" },
1133   { "Slovenian"   , "sl.UTF-8" },       { "Yiddish"    , "yi.UTF-8" },
1134   { "Serbian"     , "sr.UTF-8" },       { "Macedonian" , "mk.UTF-8" },
1135   { "Bulgarian"   , "bg.UTF-8" },       { "Ukrainian"  , "uk.UTF-8" },
1136   { "Byelorussian", "be.UTF-8" },       { "Uzbek"      , "uz.UTF-8" },
1137   { "Kazakh"      , "kk.UTF-8" },       { "Azerbaijani", "az.UTF-8" },
1138   { "Azerbaijani" , "az.UTF-8" },       { "Armenian"   , "hy.UTF-8" },
1139   { "Georgian"    , "ka.UTF-8" },       { "Moldavian"  , "mo.UTF-8" },
1140   { "Kirghiz"     , "ky.UTF-8" },       { "Tajiki"     , "tg.UTF-8" },
1141   { "Turkmen"     , "tk.UTF-8" },       { "Mongolian"  , "mn.UTF-8" },
1142   { "Mongolian"   , "mn.UTF-8" },       { "Pashto"     , "ps.UTF-8" },
1143   { "Kurdish"     , "ku.UTF-8" },       { "Kashmiri"   , "ks.UTF-8" },
1144   { "Sindhi"      , "sd.UTF-8" },       { "Tibetan"    , "bo.UTF-8" },
1145   { "Nepali"      , "ne.UTF-8" },       { "Sanskrit"   , "sa.UTF-8" },
1146   { "Marathi"     , "mr.UTF-8" },       { "Bengali"    , "bn.UTF-8" },
1147   { "Assamese"    , "as.UTF-8" },       { "Gujarati"   , "gu.UTF-8" },
1148   { "Punjabi"     , "pa.UTF-8" },       { "Oriya"      , "or.UTF-8" },
1149   { "Malayalam"   , "ml.UTF-8" },       { "Kannada"    , "kn.UTF-8" },
1150   { "Tamil"       , "ta.UTF-8" },       { "Telugu"     , "te.UTF-8" },
1151   { "Sinhalese"   , "si.UTF-8" },       { "Burmese"    , "my.UTF-8" },
1152   { "Khmer"       , "km.UTF-8" },       { "Lao"        , "lo.UTF-8" },
1153   { "Vietnamese"  , "vi.UTF-8" },       { "Indonesian" , "id.UTF-8" },
1154   { "Tagalog"     , "tl.UTF-8" },       { "Malay"      , "ms.UTF-8" },
1155   { "Malay"       , "ms.UTF-8" },       { "Amharic"    , "am.UTF-8" },
1156   { "Tigrinya"    , "ti.UTF-8" },       { "Oromo"      , "om.UTF-8" },
1157   { "Somali"      , "so.UTF-8" },       { "Swahili"    , "sw.UTF-8" },
1158   { "Kinyarwanda" , "rw.UTF-8" },       { "Rundi"      , "rn.UTF-8" },
1159   { "Nyanja"      , "" },               { "Malagasy"   , "mg.UTF-8" },
1160   { "Esperanto"   , "eo.UTF-8" },       { "Welsh"      , "cy.UTF-8" },
1161   { "Basque"      , "eu.UTF-8" },       { "Catalan"    , "ca.UTF-8" },
1162   { "Latin"       , "la.UTF-8" },       { "Quechua"    , "qu.UTF-8" },
1163   { "Guarani"     , "gn.UTF-8" },       { "Aymara"     , "ay.UTF-8" },
1164   { "Tatar"       , "tt.UTF-8" },       { "Uighur"     , "ug.UTF-8" },
1165   { "Dzongkha"    , "dz.UTF-8" },       { "Javanese"   , "jv.UTF-8" },
1166   { "Sundanese"   , "su.UTF-8" },       { "Galician"   , "gl.UTF-8" },
1167   { "Afrikaans"   , "af.UTF-8" },       { "Breton"     , "br.UTF-8" },
1168   { "Inuktitut"   , "iu.UTF-8" },       { "Scottish"   , "gd.UTF-8" },
1169   { "Manx"        , "gv.UTF-8" },       { "Irish"      , "ga.UTF-8" },
1170   { "Tongan"      , "to.UTF-8" },       { "Greek"      , "el.UTF-8" },
1171   { "Greenlandic" , "kl.UTF-8" },       { "Azerbaijani", "az.UTF-8" }
1172 };
1173
1174
1175 /*
1176  * 'appleLangDefault()' - Get the default locale string.
1177  */
1178
1179 static const char *                     /* O - Locale string */
1180 appleLangDefault(void)
1181 {
1182   int                   i;              /* Looping var */
1183   CFPropertyListRef     localizationList;
1184                                         /* List of localization data */
1185   CFStringRef           localizationName;
1186                                         /* Current name */
1187   char                  buff[256];      /* Temporary buffer */
1188   _cups_globals_t       *cg = _cupsGlobals();
1189                                         /* Pointer to library globals */
1190   char                  *lang;          /* LANG environment variable */
1191
1192
1193  /*
1194   * Only do the lookup and translation the first time.
1195   */
1196
1197   if (!cg->language[0])
1198   {
1199     if ((lang = getenv("LANG")))
1200       strlcpy(cg->language, lang, sizeof(cg->language));
1201     else
1202     {
1203       localizationList =
1204           CFPreferencesCopyAppValue(CFSTR("AppleLanguages"),
1205                                     kCFPreferencesCurrentApplication);
1206
1207       if (localizationList != NULL)
1208       {
1209         if (CFGetTypeID(localizationList) == CFArrayGetTypeID() &&
1210             CFArrayGetCount(localizationList) > 0)
1211         {
1212           localizationName = CFArrayGetValueAtIndex(localizationList, 0);
1213
1214           if (localizationName != NULL &&
1215               CFGetTypeID(localizationName) == CFStringGetTypeID())
1216           {
1217             CFIndex length = CFStringGetLength(localizationName);
1218
1219             if (length <= sizeof(buff) &&
1220                 CFStringGetCString(localizationName, buff, sizeof(buff),
1221                                    kCFStringEncodingASCII))
1222             {
1223               buff[sizeof(buff) - 1] = '\0';
1224
1225               for (i = 0;
1226                    i < sizeof(apple_name_locale) / sizeof(apple_name_locale[0]);
1227                    i++)
1228               {
1229                 if (!strcasecmp(buff, apple_name_locale[i].name))
1230                 {
1231                   strlcpy(cg->language, apple_name_locale[i].locale,
1232                           sizeof(cg->language));
1233                   break;
1234                 }
1235               }
1236             }
1237           }
1238         }
1239
1240         CFRelease(localizationList);
1241       }
1242     }
1243
1244    /*
1245     * If we didn't find the language, default to en_US...
1246     */
1247
1248     if (!cg->language[0])
1249       strlcpy(cg->language, apple_name_locale[0].locale, sizeof(cg->language));
1250   }
1251
1252  /*
1253   * Return the cached locale...
1254   */
1255
1256   return (cg->language);
1257 }
1258 #  endif /* HAVE_CF_LOCALE_ID */
1259 #endif /* __APPLE__ */
1260
1261
1262 /*
1263  * 'cups_cache_lookup()' - Lookup a language in the cache...
1264  */
1265
1266 static cups_lang_t *                    /* O - Language data or NULL */
1267 cups_cache_lookup(const char      *name,/* I - Name of locale */
1268                   cups_encoding_t encoding)
1269                                         /* I - Encoding of locale */
1270 {
1271   cups_lang_t   *lang;                  /* Current language */
1272
1273
1274   DEBUG_printf(("cups_cache_lookup(name=\"%s\", encoding=%d(%s))\n", name,
1275                 encoding, encoding == CUPS_AUTO_ENCODING ? "auto" :
1276                               lang_encodings[encoding]));
1277
1278  /*
1279   * Loop through the cache and return a match if found...
1280   */
1281
1282   for (lang = lang_cache; lang != NULL; lang = lang->next)
1283   {
1284     DEBUG_printf(("cups_cache_lookup: lang=%p, language=\"%s\", encoding=%d(%s)\n",
1285                   lang, lang->language, lang->encoding,
1286                   lang_encodings[lang->encoding]));
1287
1288     if (!strcmp(lang->language, name) &&
1289         (encoding == CUPS_AUTO_ENCODING || encoding == lang->encoding))
1290     {
1291       lang->used ++;
1292
1293       DEBUG_puts("cups_cache_lookup: returning match!");
1294
1295       return (lang);
1296     }
1297   }
1298
1299   DEBUG_puts("cups_cache_lookup: returning NULL!");
1300
1301   return (NULL);
1302 }
1303
1304
1305 /*
1306  * 'cups_message_compare()' - Compare two messages.
1307  */
1308
1309 static int                              /* O - Result of comparison */
1310 cups_message_compare(
1311     _cups_message_t *m1,                /* I - First message */
1312     _cups_message_t *m2)                /* I - Second message */
1313 {
1314   return (strcmp(m1->id, m2->id));
1315 }
1316
1317
1318 /*
1319  * 'cups_unquote()' - Unquote characters in strings...
1320  */
1321
1322 static void
1323 cups_unquote(char       *d,             /* O - Unquoted string */
1324              const char *s)             /* I - Original string */
1325 {
1326   while (*s)
1327   {
1328     if (*s == '\\')
1329     {
1330       s ++;
1331       if (isdigit(*s))
1332       {
1333         *d = 0;
1334
1335         while (isdigit(*s))
1336         {
1337           *d = *d * 8 + *s - '0';
1338           s ++;
1339         }
1340
1341         d ++;
1342       }
1343       else
1344       {
1345         if (*s == 'n')
1346           *d ++ = '\n';
1347         else if (*s == 'r')
1348           *d ++ = '\r';
1349         else if (*s == 't')
1350           *d ++ = '\t';
1351         else
1352           *d++ = *s;
1353
1354         s ++;
1355       }
1356     }
1357     else
1358       *d++ = *s++;
1359   }
1360
1361   *d = '\0';
1362 }
1363
1364
1365 /*
1366  * End of "$Id: language.c 6489 2007-04-30 17:55:15Z mike $".
1367  */