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