cups/language.c

   1 /*
   2  * "$Id: language.c 5753 2006-07-18 19:53:24Z mike $"
   3  *
   4  *   I18N/language support for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 1997-2006 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       else
 410       {
 411        /*
 412         * Default to UTF-8...
 413         */
 414
 415         strcpy(charset, "UTF8");
 416       }
 417
 418      /*
 419       * Get the locale for messages from the LC_MESSAGES locale setting...
 420       */
 421
 422       if ((ptr = getenv("LC_MESSAGES")) == NULL)
 423         if ((ptr = getenv("LC_ALL")) == NULL)
 424           if ((ptr = getenv("LANG")) == NULL)
 425             ptr = "en_US";
 426     }
 427
 428     if (ptr)
 429     {
 430       strlcpy(locale, ptr, sizeof(locale));
 431       language = locale;
 432
 433       DEBUG_printf(("cupsLangGet: new language value is \"%s\"\n",
 434                     language ? language : "(null)"));
 435     }
 436   }
 437 #endif /* __APPLE__ */
 438
 439  /*
 440   * If "language" is NULL at this point, then chances are we are using
 441   * a language that is not installed for the base OS.
 442   */
 443
 444   if (!language)
 445   {
 446    /*
 447     * Switch to the POSIX ("C") locale...
 448     */
 449
 450     language = "C";
 451   }
 452
 453 #ifdef CODESET
 454  /*
 455   * On systems that support the nl_langinfo(CODESET) call, use
 456   * this value as the character set...
 457   */
 458
 459   if (!charset[0] && (csptr = nl_langinfo(CODESET)) != NULL)
 460   {
 461    /*
 462     * Copy all of the letters and numbers in the CODESET string...
 463     */
 464
 465     for (ptr = charset; *csptr; csptr ++)
 466       if (isalnum(*csptr & 255) && ptr < (charset + sizeof(charset) - 1))
 467         *ptr++ = *csptr;
 468
 469     *ptr = '\0';
 470
 471     DEBUG_printf(("cupsLangGet: charset set to \"%s\" via nl_langinfo(CODESET)...\n",
 472                   charset));
 473   }
 474 #endif /* CODESET */
 475
 476  /*
 477   * Parse the language string passed in to a locale string. "C" is the
 478   * standard POSIX locale and is copied unchanged.  Otherwise the
 479   * language string is converted from ll-cc[.charset] (language-country)
 480   * to ll_CC[.CHARSET] to match the file naming convention used by all
 481   * POSIX-compliant operating systems.  Invalid language names are mapped
 482   * to the POSIX locale.
 483   */
 484
 485   country[0] = '\0';
 486
 487   if (language == NULL || !language[0] ||
 488       !strcmp(language, "POSIX"))
 489     strcpy(langname, "C");
 490   else
 491   {
 492    /*
 493     * Copy the parts of the locale string over safely...
 494     */
 495
 496     for (ptr = langname; *language; language ++)
 497       if (*language == '_' || *language == '-' || *language == '.')
 498         break;
 499       else if (ptr < (langname + sizeof(langname) - 1))
 500         *ptr++ = tolower(*language & 255);
 501
 502     *ptr = '\0';
 503
 504     if (*language == '_' || *language == '-')
 505     {
 506      /*
 507       * Copy the country code...
 508       */
 509
 510       for (language ++, ptr = country; *language; language ++)
 511         if (*language == '.')
 512           break;
 513         else if (ptr < (country + sizeof(country) - 1))
 514           *ptr++ = toupper(*language & 255);
 515
 516       *ptr = '\0';
 517     }
 518
 519     if (*language == '.' && !charset[0])
 520     {
 521      /*
 522       * Copy the encoding...
 523       */
 524
 525       for (language ++, ptr = charset; *language; language ++)
 526         if (isalnum(*language & 255) && ptr < (charset + sizeof(charset) - 1))
 527           *ptr++ = toupper(*language & 255);
 528
 529       *ptr = '\0';
 530     }
 531
 532    /*
 533     * Force a POSIX locale for an invalid language name...
 534     */
 535
 536     if (strlen(langname) != 2)
 537     {
 538       strcpy(langname, "C");
 539       country[0] = '\0';
 540       charset[0] = '\0';
 541     }
 542   }
 543
 544   DEBUG_printf(("cupsLangGet: langname=\"%s\", country=\"%s\", charset=\"%s\"\n",
 545                 langname, country, charset));
 546
 547  /*
 548   * Figure out the desired encoding...
 549   */
 550
 551   encoding = CUPS_AUTO_ENCODING;
 552
 553   if (charset[0])
 554   {
 555     for (i = 0;
 556          i < (int)(sizeof(locale_encodings) / sizeof(locale_encodings[0]));
 557          i ++)
 558       if (!strcasecmp(charset, locale_encodings[i]))
 559       {
 560         encoding = (cups_encoding_t)i;
 561         break;
 562       }
 563
 564     if (encoding == CUPS_AUTO_ENCODING)
 565     {
 566      /*
 567       * Map alternate names for various character sets...
 568       */
 569
 570       if (!strcasecmp(charset, "iso-2022-jp") ||
 571           !strcasecmp(charset, "sjis"))
 572         encoding = CUPS_WINDOWS_932;
 573       else if (!strcasecmp(charset, "iso-2022-cn"))
 574         encoding = CUPS_WINDOWS_936;
 575       else if (!strcasecmp(charset, "iso-2022-kr"))
 576         encoding = CUPS_WINDOWS_949;
 577       else if (!strcasecmp(charset, "big5"))
 578         encoding = CUPS_WINDOWS_950;
 579     }
 580   }
 581
 582   DEBUG_printf(("cupsLangGet: encoding=%d(%s)\n", encoding,
 583                 encoding == CUPS_AUTO_ENCODING ? "auto" :
 584                     lang_encodings[encoding]));
 585
 586  /*
 587   * See if we already have this language/country loaded...
 588   */
 589
 590   if (country[0])
 591   {
 592     snprintf(real, sizeof(real), "%s_%s", langname, country);
 593
 594     snprintf(filename, sizeof(filename), "%s/%s/cups_%s.po", cg->localedir,
 595              real, real);
 596   }
 597   else
 598   {
 599     strcpy(real, langname);
 600     filename[0] = '\0';                 /* anti-compiler-warning-code */
 601   }
 602
 603 #ifdef HAVE_PTHREAD_H
 604   pthread_mutex_lock(&lang_mutex);
 605 #endif /* HAVE_PTHREAD_H */
 606
 607   if ((lang = cups_cache_lookup(langname, encoding)) != NULL)
 608   {
 609 #ifdef HAVE_PTHREAD_H
 610     pthread_mutex_unlock(&lang_mutex);
 611 #endif /* HAVE_PTHREAD_H */
 612
 613     return (lang);
 614   }
 615
 616   if (!country[0] || access(filename, 0))
 617   {
 618    /*
 619     * Country localization not available, look for generic localization...
 620     */
 621
 622     snprintf(filename, sizeof(filename), "%s/%s/cups_%s.po", cg->localedir,
 623              langname, langname);
 624
 625     if (access(filename, 0))
 626     {
 627      /*
 628       * No generic localization, so use POSIX...
 629       */
 630
 631       DEBUG_printf(("access(\"%s\", 0): %s\n", filename, strerror(errno)));
 632
 633       snprintf(filename, sizeof(filename), "%s/C/cups_C.po", cg->localedir);
 634     }
 635   }
 636
 637  /*
 638   * See if there is a free language available; if so, use that
 639   * record...
 640   */
 641
 642   for (lang = lang_cache; lang != NULL; lang = lang->next)
 643     if (lang->used == 0)
 644       break;
 645
 646   if (lang == NULL)
 647   {
 648    /*
 649     * Allocate memory for the language and add it to the cache.
 650     */
 651
 652     if ((lang = calloc(sizeof(cups_lang_t), 1)) == NULL)
 653     {
 654 #ifdef HAVE_PTHREAD_H
 655       pthread_mutex_unlock(&lang_mutex);
 656 #endif /* HAVE_PTHREAD_H */
 657
 658       return (NULL);
 659     }
 660
 661     lang->next = lang_cache;
 662     lang_cache = lang;
 663   }
 664   else
 665   {
 666    /*
 667     * Free all old strings as needed...
 668     */
 669
 670     _cupsMessageFree(lang->strings);
 671   }
 672
 673  /*
 674   * Then assign the language and encoding fields...
 675   */
 676
 677   lang->used ++;
 678   strlcpy(lang->language, real, sizeof(lang->language));
 679
 680   if (encoding != CUPS_AUTO_ENCODING)
 681     lang->encoding = encoding;
 682   else
 683     lang->encoding = CUPS_UTF8;
 684
 685  /*
 686   * Read the strings from the file...
 687   */
 688
 689   lang->strings = _cupsMessageLoad(filename);
 690
 691  /*
 692   * Return...
 693   */
 694
 695 #ifdef HAVE_PTHREAD_H
 696   pthread_mutex_unlock(&lang_mutex);
 697 #endif /* HAVE_PTHREAD_H */
 698
 699   return (lang);
 700 }
 701
 702
 703 /*
 704  * '_cupsLangString()' - Get a message string.
 705  *
 706  * The returned string is UTF-8 encoded; use cupsUTF8ToCharset() to
 707  * convert the string to the language encoding.
 708  */
 709
 710 const char *                            /* O - Localized message */
 711 _cupsLangString(cups_lang_t *lang,      /* I - Language */
 712                 const char  *message)   /* I - Message */
 713 {
 714  /*
 715   * Range check input...
 716   */
 717
 718   if (!lang || !message)
 719     return (message);
 720
 721 #ifdef HAVE_PTHREAD_H
 722   {
 723     const char *s;                      /* Localized message */
 724
 725     pthread_mutex_lock(&lang_mutex);
 726
 727     s = _cupsMessageLookup(lang->strings, message);
 728
 729     pthread_mutex_unlock(&lang_mutex);
 730
 731     return (s);
 732   }
 733 #else
 734   return (_cupsMessageLookup(lang->strings, message));
 735 #endif /* HAVE_PTHREAD_H */
 736 }
 737
 738
 739 /*
 740  * '_cupsMessageFree()' - Free a messages array.
 741  */
 742
 743 void
 744 _cupsMessageFree(cups_array_t *a)       /* I - Message array */
 745 {
 746   _cups_message_t       *m;             /* Current message */
 747
 748
 749   for (m = (_cups_message_t *)cupsArrayFirst(a);
 750        m;
 751        m = (_cups_message_t *)cupsArrayNext(a))
 752   {
 753    /*
 754     * Remove the message from the array, then free the message and strings.
 755     */
 756
 757     cupsArrayRemove(a, m);
 758
 759     if (m->id)
 760       free(m->id);
 761
 762     if (m->str)
 763       free(m->str);
 764
 765     free(m);
 766   }
 767
 768  /*
 769   * Free the array...
 770   */
 771
 772   cupsArrayDelete(a);
 773 }
 774
 775
 776 /*
 777  * '_cupsMessageLoad()' - Load a .po file into a messages array.
 778  */
 779
 780 cups_array_t *                          /* O - New message array */
 781 _cupsMessageLoad(const char *filename)  /* I - Message catalog to load */
 782 {
 783   cups_file_t           *fp;            /* Message file */
 784   cups_array_t          *a;             /* Message array */
 785   _cups_message_t       *m;             /* Current message */
 786   char                  s[4096],        /* String buffer */
 787                         *ptr,           /* Pointer into buffer */
 788                         *temp;          /* New string */
 789   int                   length;         /* Length of combined strings */
 790
 791
 792   DEBUG_printf(("_cupsMessageLoad(filename=\"%s\")\n", filename));
 793
 794  /*
 795   * Create an array to hold the messages...
 796   */
 797
 798   if ((a = cupsArrayNew((cups_array_func_t)cups_message_compare, NULL)) == NULL)
 799     return (NULL);
 800
 801  /*
 802   * Open the message catalog file...
 803   */
 804
 805   if ((fp = cupsFileOpen(filename, "r")) == NULL)
 806     return (a);
 807
 808  /*
 809   * Read messages from the catalog file until EOF...
 810   *
 811   * The format is the GNU gettext .po format, which is fairly simple:
 812   *
 813   *     msgid "some text"
 814   *     msgstr "localized text"
 815   *
 816   * The ID and localized text can span multiple lines using the form:
 817   *
 818   *     msgid ""
 819   *     "some long text"
 820   *     msgstr ""
 821   *     "localized text spanning "
 822   *     "multiple lines"
 823   */
 824
 825   m = NULL;
 826
 827   while (cupsFileGets(fp, s, sizeof(s)) != NULL)
 828   {
 829    /*
 830     * Skip blank and comment lines...
 831     */
 832
 833     if (s[0] == '#' || !s[0])
 834       continue;
 835
 836    /*
 837     * Strip the trailing quote...
 838     */
 839
 840     if ((ptr = strrchr(s, '\"')) == NULL)
 841       continue;
 842
 843     *ptr = '\0';
 844
 845    /*
 846     * Find start of value...
 847     */
 848
 849     if ((ptr = strchr(s, '\"')) == NULL)
 850       continue;
 851
 852     ptr ++;
 853
 854    /*
 855     * Unquote the text...
 856     */
 857
 858     cups_unquote(ptr, ptr);
 859
 860    /*
 861     * Create or add to a message...
 862     */
 863
 864     if (!strncmp(s, "msgid", 5))
 865     {
 866      /*
 867       * Add previous message as needed...
 868       */
 869
 870       if (m)
 871         cupsArrayAdd(a, m);
 872
 873      /*
 874       * Create a new message with the given msgid string...
 875       */
 876
 877       if ((m = (_cups_message_t *)calloc(1, sizeof(_cups_message_t))) == NULL)
 878       {
 879         cupsFileClose(fp);
 880         return (a);
 881       }
 882
 883       m->id = strdup(ptr);
 884     }
 885     else if (s[0] == '\"' && m)
 886     {
 887      /*
 888       * Append to current string...
 889       */
 890
 891       length = strlen(m->str ? m->str : m->id);
 892
 893       if ((temp = realloc(m->str ? m->str : m->id,
 894                           length + strlen(ptr) + 1)) == NULL)
 895       {
 896         cupsFileClose(fp);
 897         return (a);
 898       }
 899
 900       if (m->str)
 901       {
 902        /*
 903         * Copy the new portion to the end of the msgstr string - safe
 904         * to use strcpy because the buffer is allocated to the correct
 905         * size...
 906         */
 907
 908         m->str = temp;
 909
 910         strcpy(m->str + length, ptr);
 911       }
 912       else
 913       {
 914        /*
 915         * Copy the new portion to the end of the msgid string - safe
 916         * to use strcpy because the buffer is allocated to the correct
 917         * size...
 918         */
 919
 920         m->id = temp;
 921
 922         strcpy(m->id + length, ptr);
 923       }
 924     }
 925     else if (!strncmp(s, "msgstr", 6) && m)
 926     {
 927      /*
 928       * Set the string...
 929       */
 930
 931       m->str = strdup(ptr);
 932     }
 933   }
 934
 935  /*
 936   * Add the last message string to the array as needed...
 937   */
 938
 939   if (m)
 940     cupsArrayAdd(a, m);
 941
 942  /*
 943   * Close the message catalog file and return the new array...
 944   */
 945
 946   cupsFileClose(fp);
 947
 948   return (a);
 949 }
 950
 951
 952 /*
 953  * '_cupsMessageLookup()' - Lookup a message string.
 954  */
 955
 956 const char *                            /* O - Localized message */
 957 _cupsMessageLookup(cups_array_t *a,     /* I - Message array */
 958                    const char   *m)     /* I - Message */
 959 {
 960   _cups_message_t       key,            /* Search key */
 961                         *match;         /* Matching message */
 962
 963
 964  /*
 965   * Lookup the message string; if it doesn't exist in the catalog,
 966   * then return the message that was passed to us...
 967   */
 968
 969   key.id = (char *)m;
 970   match  = (_cups_message_t *)cupsArrayFind(a, &key);
 971
 972   if (match && match->str)
 973     return (match->str);
 974   else
 975     return (m);
 976 }
 977
 978
 979 #ifdef __APPLE__
 980 /*
 981  * Code & data to translate OSX's language names to their ISO 639-1 locale.
 982  *
 983  * The first version uses the new CoreFoundation API added in 10.3 (Panther),
 984  * the second is for 10.2 (Jaguar).
 985  */
 986
 987 #  ifdef HAVE_CF_LOCALE_ID
 988 /*
 989  * 'appleLangDefault()' - Get the default locale string.
 990  */
 991
 992 static const char *                     /* O - Locale string */
 993 appleLangDefault(void)
 994 {
 995   CFPropertyListRef     localizationList;
 996                                         /* List of localization data */
 997   CFStringRef           languageName;   /* Current name */
 998   CFStringRef           localeName;     /* Canonical from of name */
 999   _cups_globals_t       *cg = _cupsGlobals();
1000                                         /* Pointer to library globals */
1001
1002
1003  /*
1004   * Only do the lookup and translation the first time.
1005   */
1006
1007   if (!cg->language[0])
1008   {
1009     localizationList =
1010         CFPreferencesCopyAppValue(CFSTR("AppleLanguages"),
1011                                   kCFPreferencesCurrentApplication);
1012
1013     if (localizationList != NULL)
1014     {
1015       if (CFGetTypeID(localizationList) == CFArrayGetTypeID() &&
1016           CFArrayGetCount(localizationList) > 0)
1017       {
1018         languageName = CFArrayGetValueAtIndex(localizationList, 0);
1019
1020         if (languageName != NULL &&
1021             CFGetTypeID(languageName) == CFStringGetTypeID())
1022         {
1023           localeName = CFLocaleCreateCanonicalLocaleIdentifierFromString(
1024                            kCFAllocatorDefault, languageName);
1025
1026           if (localeName != NULL)
1027           {
1028             CFStringGetCString(localeName, cg->language, sizeof(cg->language),
1029                                kCFStringEncodingASCII);
1030             CFRelease(localeName);
1031
1032             if (!strcmp(cg->language, "en"))
1033               strlcpy(cg->language, "en_US.UTF-8", sizeof(cg->language));
1034             else if (strchr(cg->language, '.') == NULL)
1035               strlcat(cg->language, ".UTF-8", sizeof(cg->language));
1036           }
1037         }
1038       }
1039
1040       CFRelease(localizationList);
1041     }
1042
1043    /*
1044     * If we didn't find the language, default to en_US...
1045     */
1046
1047     if (!cg->language[0])
1048       strlcpy(cg->language, "en_US.UTF-8", sizeof(cg->language));
1049   }
1050
1051  /*
1052   * Return the cached locale...
1053   */
1054
1055   return (cg->language);
1056 }
1057 #  else
1058 /*
1059  * Code & data to translate OSX 10.2's language names to their ISO 639-1
1060  * locale.
1061  */
1062
1063 typedef struct
1064 {
1065   const char * const name;              /* Language name */
1066   const char * const locale;            /* Locale name */
1067 } _apple_name_locale_t;
1068
1069 static const _apple_name_locale_t apple_name_locale[] =
1070 {
1071   { "English"     , "en_US.UTF-8" },    { "French"     , "fr.UTF-8" },
1072   { "German"      , "de.UTF-8" },       { "Italian"    , "it.UTF-8" },
1073   { "Dutch"       , "nl.UTF-8" },       { "Swedish"    , "sv.UTF-8" },
1074   { "Spanish"     , "es.UTF-8" },       { "Danish"     , "da.UTF-8" },
1075   { "Portuguese"  , "pt.UTF-8" },       { "Norwegian"  , "no.UTF-8" },
1076   { "Hebrew"      , "he.UTF-8" },       { "Japanese"   , "ja.UTF-8" },
1077   { "Arabic"      , "ar.UTF-8" },       { "Finnish"    , "fi.UTF-8" },
1078   { "Greek"       , "el.UTF-8" },       { "Icelandic"  , "is.UTF-8" },
1079   { "Maltese"     , "mt.UTF-8" },       { "Turkish"    , "tr.UTF-8" },
1080   { "Croatian"    , "hr.UTF-8" },       { "Chinese"    , "zh.UTF-8" },
1081   { "Urdu"        , "ur.UTF-8" },       { "Hindi"      , "hi.UTF-8" },
1082   { "Thai"        , "th.UTF-8" },       { "Korean"     , "ko.UTF-8" },
1083   { "Lithuanian"  , "lt.UTF-8" },       { "Polish"     , "pl.UTF-8" },
1084   { "Hungarian"   , "hu.UTF-8" },       { "Estonian"   , "et.UTF-8" },
1085   { "Latvian"     , "lv.UTF-8" },       { "Sami"       , "se.UTF-8" },
1086   { "Faroese"     , "fo.UTF-8" },       { "Farsi"      , "fa.UTF-8" },
1087   { "Russian"     , "ru.UTF-8" },       { "Chinese"    , "zh.UTF-8" },
1088   { "Dutch"       , "nl.UTF-8" },       { "Irish"      , "ga.UTF-8" },
1089   { "Albanian"    , "sq.UTF-8" },       { "Romanian"   , "ro.UTF-8" },
1090   { "Czech"       , "cs.UTF-8" },       { "Slovak"     , "sk.UTF-8" },
1091   { "Slovenian"   , "sl.UTF-8" },       { "Yiddish"    , "yi.UTF-8" },
1092   { "Serbian"     , "sr.UTF-8" },       { "Macedonian" , "mk.UTF-8" },
1093   { "Bulgarian"   , "bg.UTF-8" },       { "Ukrainian"  , "uk.UTF-8" },
1094   { "Byelorussian", "be.UTF-8" },       { "Uzbek"      , "uz.UTF-8" },
1095   { "Kazakh"      , "kk.UTF-8" },       { "Azerbaijani", "az.UTF-8" },
1096   { "Azerbaijani" , "az.UTF-8" },       { "Armenian"   , "hy.UTF-8" },
1097   { "Georgian"    , "ka.UTF-8" },       { "Moldavian"  , "mo.UTF-8" },
1098   { "Kirghiz"     , "ky.UTF-8" },       { "Tajiki"     , "tg.UTF-8" },
1099   { "Turkmen"     , "tk.UTF-8" },       { "Mongolian"  , "mn.UTF-8" },
1100   { "Mongolian"   , "mn.UTF-8" },       { "Pashto"     , "ps.UTF-8" },
1101   { "Kurdish"     , "ku.UTF-8" },       { "Kashmiri"   , "ks.UTF-8" },
1102   { "Sindhi"      , "sd.UTF-8" },       { "Tibetan"    , "bo.UTF-8" },
1103   { "Nepali"      , "ne.UTF-8" },       { "Sanskrit"   , "sa.UTF-8" },
1104   { "Marathi"     , "mr.UTF-8" },       { "Bengali"    , "bn.UTF-8" },
1105   { "Assamese"    , "as.UTF-8" },       { "Gujarati"   , "gu.UTF-8" },
1106   { "Punjabi"     , "pa.UTF-8" },       { "Oriya"      , "or.UTF-8" },
1107   { "Malayalam"   , "ml.UTF-8" },       { "Kannada"    , "kn.UTF-8" },
1108   { "Tamil"       , "ta.UTF-8" },       { "Telugu"     , "te.UTF-8" },
1109   { "Sinhalese"   , "si.UTF-8" },       { "Burmese"    , "my.UTF-8" },
1110   { "Khmer"       , "km.UTF-8" },       { "Lao"        , "lo.UTF-8" },
1111   { "Vietnamese"  , "vi.UTF-8" },       { "Indonesian" , "id.UTF-8" },
1112   { "Tagalog"     , "tl.UTF-8" },       { "Malay"      , "ms.UTF-8" },
1113   { "Malay"       , "ms.UTF-8" },       { "Amharic"    , "am.UTF-8" },
1114   { "Tigrinya"    , "ti.UTF-8" },       { "Oromo"      , "om.UTF-8" },
1115   { "Somali"      , "so.UTF-8" },       { "Swahili"    , "sw.UTF-8" },
1116   { "Kinyarwanda" , "rw.UTF-8" },       { "Rundi"      , "rn.UTF-8" },
1117   { "Nyanja"      , "" },               { "Malagasy"   , "mg.UTF-8" },
1118   { "Esperanto"   , "eo.UTF-8" },       { "Welsh"      , "cy.UTF-8" },
1119   { "Basque"      , "eu.UTF-8" },       { "Catalan"    , "ca.UTF-8" },
1120   { "Latin"       , "la.UTF-8" },       { "Quechua"    , "qu.UTF-8" },
1121   { "Guarani"     , "gn.UTF-8" },       { "Aymara"     , "ay.UTF-8" },
1122   { "Tatar"       , "tt.UTF-8" },       { "Uighur"     , "ug.UTF-8" },
1123   { "Dzongkha"    , "dz.UTF-8" },       { "Javanese"   , "jv.UTF-8" },
1124   { "Sundanese"   , "su.UTF-8" },       { "Galician"   , "gl.UTF-8" },
1125   { "Afrikaans"   , "af.UTF-8" },       { "Breton"     , "br.UTF-8" },
1126   { "Inuktitut"   , "iu.UTF-8" },       { "Scottish"   , "gd.UTF-8" },
1127   { "Manx"        , "gv.UTF-8" },       { "Irish"      , "ga.UTF-8" },
1128   { "Tongan"      , "to.UTF-8" },       { "Greek"      , "el.UTF-8" },
1129   { "Greenlandic" , "kl.UTF-8" },       { "Azerbaijani", "az.UTF-8" }
1130 };
1131
1132
1133 /*
1134  * 'appleLangDefault()' - Get the default locale string.
1135  */
1136
1137 static const char *                     /* O - Locale string */
1138 appleLangDefault(void)
1139 {
1140   int                   i;              /* Looping var */
1141   CFPropertyListRef     localizationList;
1142                                         /* List of localization data */
1143   CFStringRef           localizationName;
1144                                         /* Current name */
1145   char                  buff[256];      /* Temporary buffer */
1146   _cups_globals_t       *cg = _cupsGlobals();
1147                                         /* Pointer to library globals */
1148
1149
1150  /*
1151   * Only do the lookup and translation the first time.
1152   */
1153
1154   if (cg->language == NULL)
1155   {
1156     localizationList =
1157         CFPreferencesCopyAppValue(CFSTR("AppleLanguages"),
1158                                   kCFPreferencesCurrentApplication);
1159
1160     if (localizationList != NULL)
1161     {
1162       if (CFGetTypeID(localizationList) == CFArrayGetTypeID() &&
1163           CFArrayGetCount(localizationList) > 0)
1164       {
1165         localizationName = CFArrayGetValueAtIndex(localizationList, 0);
1166
1167         if (localizationName != NULL &&
1168             CFGetTypeID(localizationName) == CFStringGetTypeID())
1169         {
1170           CFIndex length = CFStringGetLength(localizationName);
1171
1172           if (length <= sizeof(buff) &&
1173               CFStringGetCString(localizationName, buff, sizeof(buff),
1174                                  kCFStringEncodingASCII))
1175           {
1176             buff[sizeof(buff) - 1] = '\0';
1177
1178             for (i = 0;
1179                  i < sizeof(apple_name_locale) / sizeof(apple_name_locale[0]);
1180                  i++)
1181             {
1182               if (!strcasecmp(buff, apple_name_locale[i].name))
1183               {
1184                 cg->language = apple_name_locale[i].locale;
1185                 break;
1186               }
1187             }
1188           }
1189         }
1190       }
1191
1192       CFRelease(localizationList);
1193     }
1194
1195    /*
1196     * If we didn't find the language, default to en_US...
1197     */
1198
1199     if (cg->language == NULL)
1200       cg->language = apple_name_locale[0].locale;
1201   }
1202
1203  /*
1204   * Return the cached locale...
1205   */
1206
1207   return (cg->language);
1208 }
1209 #  endif /* HAVE_CF_LOCALE_ID */
1210 #endif /* __APPLE__ */
1211
1212
1213 /*
1214  * 'cups_cache_lookup()' - Lookup a language in the cache...
1215  */
1216
1217 static cups_lang_t *                    /* O - Language data or NULL */
1218 cups_cache_lookup(const char      *name,/* I - Name of locale */
1219                   cups_encoding_t encoding)
1220                                         /* I - Encoding of locale */
1221 {
1222   cups_lang_t   *lang;                  /* Current language */
1223
1224
1225   DEBUG_printf(("cups_cache_lookup(name=\"%s\", encoding=%d(%s))\n", name,
1226                 encoding, encoding == CUPS_AUTO_ENCODING ? "auto" :
1227                               lang_encodings[encoding]));
1228
1229  /*
1230   * Loop through the cache and return a match if found...
1231   */
1232
1233   for (lang = lang_cache; lang != NULL; lang = lang->next)
1234   {
1235     DEBUG_printf(("cups_cache_lookup: lang=%p, language=\"%s\", encoding=%d(%s)\n",
1236                   lang, lang->language, lang->encoding,
1237                   lang_encodings[lang->encoding]));
1238
1239     if (!strcmp(lang->language, name) &&
1240         (encoding == CUPS_AUTO_ENCODING || encoding == lang->encoding))
1241     {
1242       lang->used ++;
1243
1244       DEBUG_puts("cups_cache_lookup: returning match!");
1245
1246       return (lang);
1247     }
1248   }
1249
1250   DEBUG_puts("cups_cache_lookup: returning NULL!");
1251
1252   return (NULL);
1253 }
1254
1255
1256 /*
1257  * 'cups_message_compare()' - Compare two messages.
1258  */
1259
1260 static int                              /* O - Result of comparison */
1261 cups_message_compare(
1262     _cups_message_t *m1,                /* I - First message */
1263     _cups_message_t *m2)                /* I - Second message */
1264 {
1265   return (strcmp(m1->id, m2->id));
1266 }
1267
1268
1269 /*
1270  * 'cups_unquote()' - Unquote characters in strings...
1271  */
1272
1273 static void
1274 cups_unquote(char       *d,             /* O - Unquoted string */
1275              const char *s)             /* I - Original string */
1276 {
1277   while (*s)
1278   {
1279     if (*s == '\\')
1280     {
1281       s ++;
1282       if (isdigit(*s))
1283       {
1284         *d = 0;
1285
1286         while (isdigit(*s))
1287         {
1288           *d = *d * 8 + *s - '0';
1289           s ++;
1290         }
1291       }
1292       else
1293       {
1294         if (*s == 'n')
1295           *d ++ = '\n';
1296         else if (*s == 'r')
1297           *d ++ = '\r';
1298         else if (*s == 't')
1299           *d ++ = '\t';
1300         else
1301           *d++ = *s;
1302
1303         s ++;
1304       }
1305     }
1306     else
1307       *d++ = *s++;
1308   }
1309
1310   *d = '\0';
1311 }
1312
1313
1314 /*
1315  * End of "$Id: language.c 5753 2006-07-18 19:53:24Z mike $".
1316  */