util/simple-gettext.c

   1 /* simple-gettext.c  - a simplified version of gettext.
   2  * Copyright (C) 1995, 1996, 1997, 1999,
   3  *               2005 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20  * USA.
  21  */
  22
  23 /* This is a simplified version of gettext written by Ulrich Drepper.
  24  * It is used for the Win32 version of GnuPG beucase all the overhead
  25  * of gettext is not needed and we have to do some special Win32 stuff.
  26  * I decided that this is far easier than to tweak gettext for the special
  27  * cases (I tried it but it is a lot of code).  wk 15.09.99
  28  */
  29
  30 #include <config.h>
  31 #ifdef USE_SIMPLE_GETTEXT
  32 #if !defined (_WIN32) && !defined (__CYGWIN32__)
  33 #error This file can only be used under Windows or Cygwin32
  34 #endif
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <ctype.h>
  40 #include <errno.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include "types.h"
  44 #include "util.h"
  45
  46
  47 /* The magic number of the GNU message catalog format.  */
  48 #define MAGIC         0x950412de
  49 #define MAGIC_SWAPPED 0xde120495
  50
  51 /* Revision number of the currently used .mo (binary) file format.  */
  52 #define MO_REVISION_NUMBER 0
  53
  54
  55 /* Header for binary .mo file format.  */
  56 struct mo_file_header
  57 {
  58   /* The magic number.  */
  59   u32 magic;
  60   /* The revision number of the file format.  */
  61   u32 revision;
  62   /* The number of strings pairs.  */
  63   u32 nstrings;
  64   /* Offset of table with start offsets of original strings.  */
  65   u32 orig_tab_offset;
  66   /* Offset of table with start offsets of translation strings.  */
  67   u32 trans_tab_offset;
  68   /* Size of hashing table.  */
  69   u32 hash_tab_size;
  70   /* Offset of first hashing entry.  */
  71   u32 hash_tab_offset;
  72 };
  73
  74 struct string_desc
  75 {
  76   /* Length of addressed string.  */
  77   u32 length;
  78   /* Offset of string in file.  */
  79   u32 offset;
  80 };
  81
  82
  83 struct overflow_space_s
  84 {
  85   struct overflow_space_s *next;
  86   u32 idx;
  87   char d[1];
  88 };
  89
  90 struct loaded_domain
  91 {
  92   char *data;
  93   int must_swap;
  94   u32 nstrings;
  95   char *mapped;  /* 0 = not yet mapped, 1 = mapped,
  96                     2 = mapped to
  97                     overflow space */
  98   struct overflow_space_s *overflow_space;
  99   struct string_desc *orig_tab;
 100   struct string_desc *trans_tab;
 101   u32 hash_size;
 102   u32 *hash_tab;
 103 };
 104
 105
 106 static struct loaded_domain *the_domain;
 107
 108 static __inline__ u32
 109 do_swap_u32( u32 i )
 110 {
 111   return (i << 24) | ((i & 0xff00) << 8) | ((i >> 8) & 0xff00) | (i >> 24);
 112 }
 113
 114 #define SWAPIT(flag, data) ((flag) ? do_swap_u32(data) : (data) )
 115
 116
 117 /* We assume to have `unsigned long int' value with at least 32 bits.  */
 118 #define HASHWORDBITS 32
 119
 120 /* The so called `hashpjw' function by P.J. Weinberger
 121    [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
 122    1986, 1987 Bell Telephone Laboratories, Inc.]  */
 123
 124 static __inline__ ulong
 125 hash_string( const char *str_param )
 126 {
 127     unsigned long int hval, g;
 128     const char *str = str_param;
 129
 130     hval = 0;
 131     while (*str != '\0')
 132     {
 133         hval <<= 4;
 134         hval += (unsigned long int) *str++;
 135         g = hval & ((unsigned long int) 0xf << (HASHWORDBITS - 4));
 136         if (g != 0)
 137         {
 138           hval ^= g >> (HASHWORDBITS - 8);
 139           hval ^= g;
 140         }
 141     }
 142     return hval;
 143 }
 144
 145
 146 static struct loaded_domain *
 147 load_domain( const char *filename )
 148 {
 149     FILE *fp;
 150     size_t size;
 151     struct stat st;
 152     struct mo_file_header *data = NULL;
 153     struct loaded_domain *domain = NULL;
 154     size_t to_read;
 155     char *read_ptr;
 156
 157     fp = fopen( filename, "rb" );
 158     if( !fp )
 159        return NULL; /* can't open the file */
 160     /* we must know about the size of the file */
 161     if( fstat( fileno(fp ), &st )
 162         || (size = (size_t)st.st_size) != st.st_size
 163         || size < sizeof (struct mo_file_header) ) {
 164         fclose( fp );
 165         return NULL;
 166     }
 167
 168     data = malloc( size );
 169     if( !data ) {
 170         fclose( fp );
 171         return NULL; /* out of memory */
 172     }
 173
 174     to_read = size;
 175     read_ptr = (char *) data;
 176     do {
 177         long int nb = fread( read_ptr, 1, to_read, fp );
 178         if( nb < to_read ) {
 179             fclose (fp);
 180             free(data);
 181             return NULL; /* read error */
 182         }
 183         read_ptr += nb;
 184         to_read -= nb;
 185     } while( to_read > 0 );
 186     fclose (fp);
 187
 188     /* Using the magic number we can test whether it really is a message
 189      * catalog file.  */
 190     if( data->magic != MAGIC && data->magic != MAGIC_SWAPPED ) {
 191         /* The magic number is wrong: not a message catalog file.  */
 192         free( data );
 193         return NULL;
 194     }
 195
 196     domain = calloc( 1, sizeof *domain );
 197     if( !domain )  {
 198         free( data );
 199         return NULL;
 200     }
 201     domain->data = (char *) data;
 202     domain->must_swap = data->magic != MAGIC;
 203
 204     /* Fill in the information about the available tables.  */
 205     switch( SWAPIT(domain->must_swap, data->revision) ) {
 206       case 0:
 207         domain->nstrings = SWAPIT(domain->must_swap, data->nstrings);
 208         domain->orig_tab = (struct string_desc *)
 209           ((char *) data + SWAPIT(domain->must_swap, data->orig_tab_offset));
 210         domain->trans_tab = (struct string_desc *)
 211           ((char *) data + SWAPIT(domain->must_swap, data->trans_tab_offset));
 212         domain->hash_size = SWAPIT(domain->must_swap, data->hash_tab_size);
 213         domain->hash_tab = (u32 *)
 214           ((char *) data + SWAPIT(domain->must_swap, data->hash_tab_offset));
 215       break;
 216
 217       default: /* This is an invalid revision.  */
 218         free( data );
 219         free( domain );
 220         return NULL;
 221     }
 222
 223     /* Allocate an array to keep track of code page mappings. */
 224     domain->mapped = calloc( 1, domain->nstrings );
 225     if( !domain->mapped ) {
 226         free( data );
 227         free( domain );
 228         return NULL;
 229     }
 230
 231     return domain;
 232 }
 233
 234
 235 /****************
 236  * Set the file used for translations. Pass a NULL to disable
 237  * translation.  A new filename may be set at anytime.  If REGKEY is
 238  * not NULL, the function tries to selected the language the registry
 239  * key "Lang" below that key.  WARNING: After changing the filename you
 240  * should not access any data retrieved by gettext().
 241  */
 242 int
 243 set_gettext_file ( const char *filename, const char *regkey )
 244 {
 245     struct loaded_domain *domain = NULL;
 246
 247     if( filename && *filename ) {
 248         if( filename[0] == '/'
 249 #ifdef HAVE_DRIVE_LETTERS
 250             || ( isalpha(filename[0])
 251                  && filename[1] == ':'
 252                  && (filename[2] == '/' || filename[2] == '\\') )
 253 #endif
 254            ) {
 255             /* absolute path - use it as is */
 256             domain = load_domain( filename );
 257         }
 258         else if (regkey) { /* Standard.  */
 259             char *instdir, *langid, *fname;
 260             char *p;
 261
 262             instdir = read_w32_registry_string ("HKEY_LOCAL_MACHINE",
 263                                                 regkey,
 264                                                 "Install Directory");
 265             if (!instdir)
 266                 return -1;
 267             langid = read_w32_registry_string (NULL, /* HKCU then HKLM */
 268                                                regkey,
 269                                                "Lang");
 270             if (!langid) {
 271                 free (instdir);
 272                 return -1;
 273             }
 274             /* Strip stuff after a dot in case the user tried to enter
 275              * the entire locale synatcs as usual for POSIX. */
 276             p = strchr (langid, '.');
 277             if (p)
 278                 *p = 0;
 279
 280             /* Build the key: "<instdir>/<domain>.nls/<langid>.mo" We
 281                use a directory below the installation directory with
 282                the domain included in case the software has been
 283                insalled with other software altogether at the same
 284                place. */
 285             fname = malloc (strlen (instdir) + 1 + strlen (filename) + 5
 286                             + strlen (langid) + 3 + 1);
 287             if (!fname) {
 288                 free (instdir);
 289                 free (langid);
 290                 return -1;
 291             }
 292             strcpy (stpcpy (stpcpy (stpcpy (stpcpy ( stpcpy (fname,
 293                    instdir),"\\"), filename), ".nls\\"), langid), ".mo");
 294             free (instdir);
 295             free (langid);
 296
 297             /* Better make sure that we don't mix forward and
 298                backward slashes.  It seems that some Windoze
 299                versions don't accept this. */
 300             for (p=fname; *p; p++) {
 301                 if (*p == '/')
 302                     *p = '\\';
 303             }
 304             domain = load_domain (fname);
 305             free(fname);
 306         }
 307
 308         if (!domain)
 309             return -1;
 310     }
 311
 312     if( the_domain ) {
 313         struct overflow_space_s *os, *os2;
 314         free( the_domain->data );
 315         free( the_domain->mapped );
 316         for (os=the_domain->overflow_space; os; os = os2) {
 317             os2 = os->next;
 318             free (os);
 319         }
 320         free( the_domain );
 321         the_domain = NULL;
 322     }
 323     the_domain = domain;
 324     return 0;
 325 }
 326
 327
 328 static const char*
 329 get_string( struct loaded_domain *domain, u32 idx )
 330 {
 331   struct overflow_space_s *os;
 332   char *p;
 333
 334   p = domain->data + SWAPIT(domain->must_swap, domain->trans_tab[idx].offset);
 335   if (!domain->mapped[idx])
 336     {
 337       size_t plen, buflen;
 338       char *buf;
 339
 340       domain->mapped[idx] = 1;
 341
 342       plen = strlen (p);
 343       buf = utf8_to_native (p, plen, -1);
 344       buflen = strlen (buf);
 345       if (buflen <= plen)
 346         strcpy (p, buf);
 347       else
 348         {
 349           /* There is not enough space for the translation - store it
 350              in the overflow_space else and mark that in the mapped
 351              array.  Because we expect that this won't happen too
 352              often, we use a simple linked list.  */
 353           os = malloc (sizeof *os + buflen);
 354           if (os)
 355             {
 356               os->idx = idx;
 357               strcpy (os->d, buf);
 358               os->next = domain->overflow_space;
 359               domain->overflow_space = os;
 360               p = os->d;
 361             }
 362           else
 363             p = "ERROR in GETTEXT MALLOC";
 364         }
 365       xfree (buf);
 366     }
 367   else if (domain->mapped[idx] == 2)
 368     { /* We need to get the string from the overflow_space. */
 369       for (os=domain->overflow_space; os; os = os->next)
 370         if (os->idx == idx)
 371           return (const char*)os->d;
 372       p = "ERROR in GETTEXT\n";
 373     }
 374   return (const char*)p;
 375 }
 376
 377
 378
 379 const char *
 380 gettext( const char *msgid )
 381 {
 382     struct loaded_domain *domain;
 383     size_t act = 0;
 384     size_t top, bottom;
 385
 386     if( !(domain = the_domain) )
 387         goto not_found;
 388
 389     /* Locate the MSGID and its translation.  */
 390     if( domain->hash_size > 2 && domain->hash_tab ) {
 391         /* Use the hashing table.  */
 392         u32 len = strlen (msgid);
 393         u32 hash_val = hash_string (msgid);
 394         u32 idx = hash_val % domain->hash_size;
 395         u32 incr = 1 + (hash_val % (domain->hash_size - 2));
 396         u32 nstr = SWAPIT (domain->must_swap, domain->hash_tab[idx]);
 397
 398         if ( !nstr ) /* Hash table entry is empty.  */
 399             goto not_found;
 400
 401         if( SWAPIT(domain->must_swap,
 402                     domain->orig_tab[nstr - 1].length) == len
 403             && !strcmp( msgid,
 404                        domain->data + SWAPIT(domain->must_swap,
 405                                     domain->orig_tab[nstr - 1].offset)) )
 406             return get_string( domain, nstr - 1 );
 407
 408         for(;;) {
 409             if (idx >= domain->hash_size - incr)
 410                 idx -= domain->hash_size - incr;
 411             else
 412                 idx += incr;
 413
 414             nstr = SWAPIT(domain->must_swap, domain->hash_tab[idx]);
 415             if( !nstr )
 416                 goto not_found; /* Hash table entry is empty.  */
 417
 418             if ( SWAPIT(domain->must_swap,
 419                                 domain->orig_tab[nstr - 1].length) == len
 420                  && !strcmp (msgid,
 421                          domain->data + SWAPIT(domain->must_swap,
 422                                            domain->orig_tab[nstr - 1].offset)))
 423                 return get_string( domain, nstr-1 );
 424         }
 425         /* NOTREACHED */
 426     }
 427
 428     /* Now we try the default method:  binary search in the sorted
 429        array of messages.  */
 430     bottom = 0;
 431     top = domain->nstrings;
 432     while( bottom < top ) {
 433         int cmp_val;
 434
 435         act = (bottom + top) / 2;
 436         cmp_val = strcmp(msgid, domain->data
 437                                + SWAPIT(domain->must_swap,
 438                                         domain->orig_tab[act].offset));
 439         if (cmp_val < 0)
 440             top = act;
 441         else if (cmp_val > 0)
 442             bottom = act + 1;
 443         else
 444             return get_string( domain, act );
 445     }
 446
 447   not_found:
 448     return msgid;
 449 }
 450
 451 #if 0
 452        unsigned int cp1, cp2;
 453
 454        cp1 = GetConsoleCP();
 455        cp2 = GetConsoleOutputCP();
 456
 457        log_info("InputCP=%u  OutputCP=%u\n", cp1, cp2 );
 458
 459        if( !SetConsoleOutputCP( 1252 ) )
 460             log_info("SetConsoleOutputCP failed: %s\n", w32_strerror (0));
 461
 462        cp1 = GetConsoleCP();
 463        cp2 = GetConsoleOutputCP();
 464        log_info("InputCP=%u  OutputCP=%u after switch1\n", cp1, cp2 );
 465 #endif
 466
 467 #endif /* USE_SIMPLE_GETTEXT */