OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [intl/] [dcigettext.c] - Blame information for rev 301

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* Implementation of the internal dcigettext function.
2
   Copyright (C) 1995-1999, 2000-2003 Free Software Foundation, Inc.
3
 
4
   This program is free software; you can redistribute it and/or modify it
5
   under the terms of the GNU Library General Public License as published
6
   by the Free Software Foundation; either version 2, or (at your option)
7
   any later version.
8
 
9
   This program is distributed in the hope that it will be useful,
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
   Library General Public License for more details.
13
 
14
   You should have received a copy of the GNU Library General Public
15
   License along with this program; if not, write to the Free Software
16
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
17
   USA.  */
18
 
19
/* Tell glibc's <string.h> to provide a prototype for mempcpy().
20
   This must come before <config.h> because <config.h> may include
21
   <features.h>, and once <features.h> has been included, it's too late.  */
22
#ifndef _GNU_SOURCE
23
# define _GNU_SOURCE    1
24
#endif
25
 
26
#ifdef HAVE_CONFIG_H
27
# include <config.h>
28
#endif
29
 
30
#include <sys/types.h>
31
 
32
#ifdef __GNUC__
33
# define alloca __builtin_alloca
34
# define HAVE_ALLOCA 1
35
#else
36
# ifdef _MSC_VER
37
#  include <malloc.h>
38
#  define alloca _alloca
39
# else
40
#  if defined HAVE_ALLOCA_H || defined _LIBC
41
#   include <alloca.h>
42
#  else
43
#   ifdef _AIX
44
 #pragma alloca
45
#   else
46
#    ifndef alloca
47
char *alloca ();
48
#    endif
49
#   endif
50
#  endif
51
# endif
52
#endif
53
 
54
#include <errno.h>
55
#ifndef errno
56
extern int errno;
57
#endif
58
#ifndef __set_errno
59
# define __set_errno(val) errno = (val)
60
#endif
61
 
62
#include <stddef.h>
63
#include <stdlib.h>
64
#include <string.h>
65
 
66
#if defined HAVE_UNISTD_H || defined _LIBC
67
# include <unistd.h>
68
#endif
69
 
70
#include <locale.h>
71
 
72
#ifdef _LIBC
73
  /* Guess whether integer division by zero raises signal SIGFPE.
74
     Set to 1 only if you know for sure.  In case of doubt, set to 0.  */
75
# if defined __alpha__ || defined __arm__ || defined __i386__ \
76
     || defined __m68k__ || defined __s390__
77
#  define INTDIV0_RAISES_SIGFPE 1
78
# else
79
#  define INTDIV0_RAISES_SIGFPE 0
80
# endif
81
#endif
82
#if !INTDIV0_RAISES_SIGFPE
83
# include <signal.h>
84
#endif
85
 
86
#if defined HAVE_SYS_PARAM_H || defined _LIBC
87
# include <sys/param.h>
88
#endif
89
 
90
#include "gettextP.h"
91
#include "plural-exp.h"
92
#ifdef _LIBC
93
# include <libintl.h>
94
#else
95
# include "libgnuintl.h"
96
#endif
97
#include "hash-string.h"
98
 
99
/* Thread safetyness.  */
100
#ifdef _LIBC
101
# include <bits/libc-lock.h>
102
#else
103
/* Provide dummy implementation if this is outside glibc.  */
104
# define __libc_lock_define_initialized(CLASS, NAME)
105
# define __libc_lock_lock(NAME)
106
# define __libc_lock_unlock(NAME)
107
# define __libc_rwlock_define_initialized(CLASS, NAME)
108
# define __libc_rwlock_rdlock(NAME)
109
# define __libc_rwlock_unlock(NAME)
110
#endif
111
 
112
/* Alignment of types.  */
113
#if defined __GNUC__ && __GNUC__ >= 2
114
# define alignof(TYPE) __alignof__ (TYPE)
115
#else
116
# define alignof(TYPE) \
117
    ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
118
#endif
119
 
120
/* The internal variables in the standalone libintl.a must have different
121
   names than the internal variables in GNU libc, otherwise programs
122
   using libintl.a cannot be linked statically.  */
123
#if !defined _LIBC
124
# define _nl_default_default_domain libintl_nl_default_default_domain
125
# define _nl_current_default_domain libintl_nl_current_default_domain
126
# define _nl_default_dirname libintl_nl_default_dirname
127
# define _nl_domain_bindings libintl_nl_domain_bindings
128
#endif
129
 
130
/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
131
#ifndef offsetof
132
# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
133
#endif
134
 
135
/* @@ end of prolog @@ */
136
 
137
#ifdef _LIBC
138
/* Rename the non ANSI C functions.  This is required by the standard
139
   because some ANSI C functions will require linking with this object
140
   file and the name space must not be polluted.  */
141
# define getcwd __getcwd
142
# ifndef stpcpy
143
#  define stpcpy __stpcpy
144
# endif
145
# define tfind __tfind
146
#else
147
# if !defined HAVE_GETCWD
148
char *getwd ();
149
#  define getcwd(buf, max) getwd (buf)
150
# else
151
char *getcwd ();
152
# endif
153
# ifndef HAVE_STPCPY
154
static char *stpcpy PARAMS ((char *dest, const char *src));
155
# endif
156
# ifndef HAVE_MEMPCPY
157
static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
158
# endif
159
#endif
160
 
161
/* Amount to increase buffer size by in each try.  */
162
#define PATH_INCR 32
163
 
164
/* The following is from pathmax.h.  */
165
/* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
166
   PATH_MAX but might cause redefinition warnings when sys/param.h is
167
   later included (as on MORE/BSD 4.3).  */
168
#if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
169
# include <limits.h>
170
#endif
171
 
172
#ifndef _POSIX_PATH_MAX
173
# define _POSIX_PATH_MAX 255
174
#endif
175
 
176
#if !defined PATH_MAX && defined _PC_PATH_MAX
177
# define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
178
#endif
179
 
180
/* Don't include sys/param.h if it already has been.  */
181
#if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
182
# include <sys/param.h>
183
#endif
184
 
185
#if !defined PATH_MAX && defined MAXPATHLEN
186
# define PATH_MAX MAXPATHLEN
187
#endif
188
 
189
#ifndef PATH_MAX
190
# define PATH_MAX _POSIX_PATH_MAX
191
#endif
192
 
193
/* Pathname support.
194
   ISSLASH(C)           tests whether C is a directory separator character.
195
   IS_ABSOLUTE_PATH(P)  tests whether P is an absolute path.  If it is not,
196
                        it may be concatenated to a directory pathname.
197
   IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
198
 */
199
#if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
200
  /* Win32, OS/2, DOS */
201
# define ISSLASH(C) ((C) == '/' || (C) == '\\')
202
# define HAS_DEVICE(P) \
203
    ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
204
     && (P)[1] == ':')
205
# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
206
# define IS_PATH_WITH_DIR(P) \
207
    (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
208
#else
209
  /* Unix */
210
# define ISSLASH(C) ((C) == '/')
211
# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
212
# define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
213
#endif
214
 
215
/* This is the type used for the search tree where known translations
216
   are stored.  */
217
struct known_translation_t
218
{
219
  /* Domain in which to search.  */
220
  char *domainname;
221
 
222
  /* The category.  */
223
  int category;
224
 
225
  /* State of the catalog counter at the point the string was found.  */
226
  int counter;
227
 
228
  /* Catalog where the string was found.  */
229
  struct loaded_l10nfile *domain;
230
 
231
  /* And finally the translation.  */
232
  const char *translation;
233
  size_t translation_length;
234
 
235
  /* Pointer to the string in question.  */
236
  char msgid[ZERO];
237
};
238
 
239
/* Root of the search tree with known translations.  We can use this
240
   only if the system provides the `tsearch' function family.  */
241
#if defined HAVE_TSEARCH || defined _LIBC
242
# include <search.h>
243
 
244
static void *root;
245
 
246
# ifdef _LIBC
247
#  define tsearch __tsearch
248
# endif
249
 
250
/* Function to compare two entries in the table of known translations.  */
251
static int transcmp PARAMS ((const void *p1, const void *p2));
252
static int
253
transcmp (p1, p2)
254
     const void *p1;
255
     const void *p2;
256
{
257
  const struct known_translation_t *s1;
258
  const struct known_translation_t *s2;
259
  int result;
260
 
261
  s1 = (const struct known_translation_t *) p1;
262
  s2 = (const struct known_translation_t *) p2;
263
 
264
  result = strcmp (s1->msgid, s2->msgid);
265
  if (result == 0)
266
    {
267
      result = strcmp (s1->domainname, s2->domainname);
268
      if (result == 0)
269
        /* We compare the category last (though this is the cheapest
270
           operation) since it is hopefully always the same (namely
271
           LC_MESSAGES).  */
272
        result = s1->category - s2->category;
273
    }
274
 
275
  return result;
276
}
277
#endif
278
 
279
#ifndef INTVARDEF
280
# define INTVARDEF(name)
281
#endif
282
#ifndef INTUSE
283
# define INTUSE(name) name
284
#endif
285
 
286
/* Name of the default domain used for gettext(3) prior any call to
287
   textdomain(3).  The default value for this is "messages".  */
288
const char _nl_default_default_domain[] attribute_hidden = "messages";
289
 
290
/* Value used as the default domain for gettext(3).  */
291
const char *_nl_current_default_domain attribute_hidden
292
     = _nl_default_default_domain;
293
 
294
/* Contains the default location of the message catalogs.  */
295
#if defined __EMX__
296
extern const char _nl_default_dirname[];
297
#else
298
const char _nl_default_dirname[] = LOCALEDIR;
299
INTVARDEF (_nl_default_dirname)
300
#endif
301
 
302
/* List with bindings of specific domains created by bindtextdomain()
303
   calls.  */
304
struct binding *_nl_domain_bindings;
305
 
306
/* Prototypes for local functions.  */
307
static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
308
                                    unsigned long int n,
309
                                    const char *translation,
310
                                    size_t translation_len))
311
     internal_function;
312
static const char *guess_category_value PARAMS ((int category,
313
                                                 const char *categoryname))
314
     internal_function;
315
#ifdef _LIBC
316
# include "../locale/localeinfo.h"
317
# define category_to_name(category)     _nl_category_names[category]
318
#else
319
static const char *category_to_name PARAMS ((int category)) internal_function;
320
#endif
321
 
322
 
323
/* For those loosing systems which don't have `alloca' we have to add
324
   some additional code emulating it.  */
325
#ifdef HAVE_ALLOCA
326
/* Nothing has to be done.  */
327
# define freea(p) /* nothing */
328
# define ADD_BLOCK(list, address) /* nothing */
329
# define FREE_BLOCKS(list) /* nothing */
330
#else
331
struct block_list
332
{
333
  void *address;
334
  struct block_list *next;
335
};
336
# define ADD_BLOCK(list, addr)                                                \
337
  do {                                                                        \
338
    struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
339
    /* If we cannot get a free block we cannot add the new element to         \
340
       the list.  */                                                          \
341
    if (newp != NULL) {                                                       \
342
      newp->address = (addr);                                                 \
343
      newp->next = (list);                                                    \
344
      (list) = newp;                                                          \
345
    }                                                                         \
346
  } while (0)
347
# define FREE_BLOCKS(list)                                                    \
348
  do {                                                                        \
349
    while (list != NULL) {                                                    \
350
      struct block_list *old = list;                                          \
351
      list = list->next;                                                      \
352
      free (old->address);                                                    \
353
      free (old);                                                             \
354
    }                                                                         \
355
  } while (0)
356
# undef alloca
357
# define alloca(size) (malloc (size))
358
# define freea(p) free (p)
359
#endif  /* have alloca */
360
 
361
 
362
#ifdef _LIBC
363
/* List of blocks allocated for translations.  */
364
typedef struct transmem_list
365
{
366
  struct transmem_list *next;
367
  char data[ZERO];
368
} transmem_block_t;
369
static struct transmem_list *transmem_list;
370
#else
371
typedef unsigned char transmem_block_t;
372
#endif
373
 
374
 
375
/* Names for the libintl functions are a problem.  They must not clash
376
   with existing names and they should follow ANSI C.  But this source
377
   code is also used in GNU C Library where the names have a __
378
   prefix.  So we have to make a difference here.  */
379
#ifdef _LIBC
380
# define DCIGETTEXT __dcigettext
381
#else
382
# define DCIGETTEXT libintl_dcigettext
383
#endif
384
 
385
/* Lock variable to protect the global data in the gettext implementation.  */
386
#ifdef _LIBC
387
__libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
388
#endif
389
 
390
/* Checking whether the binaries runs SUID must be done and glibc provides
391
   easier methods therefore we make a difference here.  */
392
#ifdef _LIBC
393
# define ENABLE_SECURE __libc_enable_secure
394
# define DETERMINE_SECURE
395
#else
396
# ifndef HAVE_GETUID
397
#  define getuid() 0
398
# endif
399
# ifndef HAVE_GETGID
400
#  define getgid() 0
401
# endif
402
# ifndef HAVE_GETEUID
403
#  define geteuid() getuid()
404
# endif
405
# ifndef HAVE_GETEGID
406
#  define getegid() getgid()
407
# endif
408
static int enable_secure;
409
# define ENABLE_SECURE (enable_secure == 1)
410
# define DETERMINE_SECURE \
411
  if (enable_secure == 0)                                                      \
412
    {                                                                         \
413
      if (getuid () != geteuid () || getgid () != getegid ())                 \
414
        enable_secure = 1;                                                    \
415
      else                                                                    \
416
        enable_secure = -1;                                                   \
417
    }
418
#endif
419
 
420
/* Get the function to evaluate the plural expression.  */
421
#include "eval-plural.h"
422
 
423
/* Look up MSGID in the DOMAINNAME message catalog for the current
424
   CATEGORY locale and, if PLURAL is nonzero, search over string
425
   depending on the plural form determined by N.  */
426
char *
427
DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
428
     const char *domainname;
429
     const char *msgid1;
430
     const char *msgid2;
431
     int plural;
432
     unsigned long int n;
433
     int category;
434
{
435
#ifndef HAVE_ALLOCA
436
  struct block_list *block_list = NULL;
437
#endif
438
  struct loaded_l10nfile *domain;
439
  struct binding *binding;
440
  const char *categoryname;
441
  const char *categoryvalue;
442
  char *dirname, *xdomainname;
443
  char *single_locale;
444
  char *retval;
445
  size_t retlen;
446
  int saved_errno;
447
#if defined HAVE_TSEARCH || defined _LIBC
448
  struct known_translation_t *search;
449
  struct known_translation_t **foundp = NULL;
450
  size_t msgid_len;
451
#endif
452
  size_t domainname_len;
453
 
454
  /* If no real MSGID is given return NULL.  */
455
  if (msgid1 == NULL)
456
    return NULL;
457
 
458
#ifdef _LIBC
459
  if (category < 0 || category >= __LC_LAST || category == LC_ALL)
460
    /* Bogus.  */
461
    return (plural == 0
462
            ? (char *) msgid1
463
            /* Use the Germanic plural rule.  */
464
            : n == 1 ? (char *) msgid1 : (char *) msgid2);
465
#endif
466
 
467
  __libc_rwlock_rdlock (_nl_state_lock);
468
 
469
  /* If DOMAINNAME is NULL, we are interested in the default domain.  If
470
     CATEGORY is not LC_MESSAGES this might not make much sense but the
471
     definition left this undefined.  */
472
  if (domainname == NULL)
473
    domainname = _nl_current_default_domain;
474
 
475
  /* OS/2 specific: backward compatibility with older libintl versions  */
476
#ifdef LC_MESSAGES_COMPAT
477
  if (category == LC_MESSAGES_COMPAT)
478
    category = LC_MESSAGES;
479
#endif
480
 
481
#if defined HAVE_TSEARCH || defined _LIBC
482
  msgid_len = strlen (msgid1) + 1;
483
 
484
  /* Try to find the translation among those which we found at
485
     some time.  */
486
  search = (struct known_translation_t *)
487
           alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
488
  memcpy (search->msgid, msgid1, msgid_len);
489
  search->domainname = (char *) domainname;
490
  search->category = category;
491
 
492
  foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
493
  freea (search);
494
  if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
495
    {
496
      /* Now deal with plural.  */
497
      if (plural)
498
        retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
499
                                (*foundp)->translation_length);
500
      else
501
        retval = (char *) (*foundp)->translation;
502
 
503
      __libc_rwlock_unlock (_nl_state_lock);
504
      return retval;
505
    }
506
#endif
507
 
508
  /* Preserve the `errno' value.  */
509
  saved_errno = errno;
510
 
511
  /* See whether this is a SUID binary or not.  */
512
  DETERMINE_SECURE;
513
 
514
  /* First find matching binding.  */
515
  for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
516
    {
517
      int compare = strcmp (domainname, binding->domainname);
518
      if (compare == 0)
519
        /* We found it!  */
520
        break;
521
      if (compare < 0)
522
        {
523
          /* It is not in the list.  */
524
          binding = NULL;
525
          break;
526
        }
527
    }
528
 
529
  if (binding == NULL)
530
    dirname = (char *) INTUSE(_nl_default_dirname);
531
  else if (IS_ABSOLUTE_PATH (binding->dirname))
532
    dirname = binding->dirname;
533
  else
534
    {
535
      /* We have a relative path.  Make it absolute now.  */
536
      size_t dirname_len = strlen (binding->dirname) + 1;
537
      size_t path_max;
538
      char *ret;
539
 
540
      path_max = (unsigned int) PATH_MAX;
541
      path_max += 2;            /* The getcwd docs say to do this.  */
542
 
543
      for (;;)
544
        {
545
          dirname = (char *) alloca (path_max + dirname_len);
546
          ADD_BLOCK (block_list, dirname);
547
 
548
          __set_errno (0);
549
          ret = getcwd (dirname, path_max);
550
          if (ret != NULL || errno != ERANGE)
551
            break;
552
 
553
          path_max += path_max / 2;
554
          path_max += PATH_INCR;
555
        }
556
 
557
      if (ret == NULL)
558
        /* We cannot get the current working directory.  Don't signal an
559
           error but simply return the default string.  */
560
        goto return_untranslated;
561
 
562
      stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
563
    }
564
 
565
  /* Now determine the symbolic name of CATEGORY and its value.  */
566
  categoryname = category_to_name (category);
567
  categoryvalue = guess_category_value (category, categoryname);
568
 
569
  domainname_len = strlen (domainname);
570
  xdomainname = (char *) alloca (strlen (categoryname)
571
                                 + domainname_len + 5);
572
  ADD_BLOCK (block_list, xdomainname);
573
 
574
  stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
575
                  domainname, domainname_len),
576
          ".mo");
577
 
578
  /* Creating working area.  */
579
  single_locale = (char *) alloca (strlen (categoryvalue) + 1);
580
  ADD_BLOCK (block_list, single_locale);
581
 
582
 
583
  /* Search for the given string.  This is a loop because we perhaps
584
     got an ordered list of languages to consider for the translation.  */
585
  while (1)
586
    {
587
      /* Make CATEGORYVALUE point to the next element of the list.  */
588
      while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
589
        ++categoryvalue;
590
      if (categoryvalue[0] == '\0')
591
        {
592
          /* The whole contents of CATEGORYVALUE has been searched but
593
             no valid entry has been found.  We solve this situation
594
             by implicitly appending a "C" entry, i.e. no translation
595
             will take place.  */
596
          single_locale[0] = 'C';
597
          single_locale[1] = '\0';
598
        }
599
      else
600
        {
601
          char *cp = single_locale;
602
          while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
603
            *cp++ = *categoryvalue++;
604
          *cp = '\0';
605
 
606
          /* When this is a SUID binary we must not allow accessing files
607
             outside the dedicated directories.  */
608
          if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
609
            /* Ingore this entry.  */
610
            continue;
611
        }
612
 
613
      /* If the current locale value is C (or POSIX) we don't load a
614
         domain.  Return the MSGID.  */
615
      if (strcmp (single_locale, "C") == 0
616
          || strcmp (single_locale, "POSIX") == 0)
617
        break;
618
 
619
      /* Find structure describing the message catalog matching the
620
         DOMAINNAME and CATEGORY.  */
621
      domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
622
 
623
      if (domain != NULL)
624
        {
625
          retval = _nl_find_msg (domain, binding, msgid1, &retlen);
626
 
627
          if (retval == NULL)
628
            {
629
              int cnt;
630
 
631
              for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
632
                {
633
                  retval = _nl_find_msg (domain->successor[cnt], binding,
634
                                         msgid1, &retlen);
635
 
636
                  if (retval != NULL)
637
                    {
638
                      domain = domain->successor[cnt];
639
                      break;
640
                    }
641
                }
642
            }
643
 
644
          if (retval != NULL)
645
            {
646
              /* Found the translation of MSGID1 in domain DOMAIN:
647
                 starting at RETVAL, RETLEN bytes.  */
648
              FREE_BLOCKS (block_list);
649
#if defined HAVE_TSEARCH || defined _LIBC
650
              if (foundp == NULL)
651
                {
652
                  /* Create a new entry and add it to the search tree.  */
653
                  struct known_translation_t *newp;
654
 
655
                  newp = (struct known_translation_t *)
656
                    malloc (offsetof (struct known_translation_t, msgid)
657
                            + msgid_len + domainname_len + 1);
658
                  if (newp != NULL)
659
                    {
660
                      newp->domainname =
661
                        mempcpy (newp->msgid, msgid1, msgid_len);
662
                      memcpy (newp->domainname, domainname, domainname_len + 1);
663
                      newp->category = category;
664
                      newp->counter = _nl_msg_cat_cntr;
665
                      newp->domain = domain;
666
                      newp->translation = retval;
667
                      newp->translation_length = retlen;
668
 
669
                      /* Insert the entry in the search tree.  */
670
                      foundp = (struct known_translation_t **)
671
                        tsearch (newp, &root, transcmp);
672
                      if (foundp == NULL
673
                          || __builtin_expect (*foundp != newp, 0))
674
                        /* The insert failed.  */
675
                        free (newp);
676
                    }
677
                }
678
              else
679
                {
680
                  /* We can update the existing entry.  */
681
                  (*foundp)->counter = _nl_msg_cat_cntr;
682
                  (*foundp)->domain = domain;
683
                  (*foundp)->translation = retval;
684
                  (*foundp)->translation_length = retlen;
685
                }
686
#endif
687
              __set_errno (saved_errno);
688
 
689
              /* Now deal with plural.  */
690
              if (plural)
691
                retval = plural_lookup (domain, n, retval, retlen);
692
 
693
              __libc_rwlock_unlock (_nl_state_lock);
694
              return retval;
695
            }
696
        }
697
    }
698
 
699
 return_untranslated:
700
  /* Return the untranslated MSGID.  */
701
  FREE_BLOCKS (block_list);
702
  __libc_rwlock_unlock (_nl_state_lock);
703
#ifndef _LIBC
704
  if (!ENABLE_SECURE)
705
    {
706
      extern void _nl_log_untranslated PARAMS ((const char *logfilename,
707
                                                const char *domainname,
708
                                                const char *msgid1,
709
                                                const char *msgid2,
710
                                                int plural));
711
      const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
712
 
713
      if (logfilename != NULL && logfilename[0] != '\0')
714
        _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
715
    }
716
#endif
717
  __set_errno (saved_errno);
718
  return (plural == 0
719
          ? (char *) msgid1
720
          /* Use the Germanic plural rule.  */
721
          : n == 1 ? (char *) msgid1 : (char *) msgid2);
722
}
723
 
724
 
725
char *
726
internal_function
727
_nl_find_msg (domain_file, domainbinding, msgid, lengthp)
728
     struct loaded_l10nfile *domain_file;
729
     struct binding *domainbinding;
730
     const char *msgid;
731
     size_t *lengthp;
732
{
733
  struct loaded_domain *domain;
734
  nls_uint32 nstrings;
735
  size_t act;
736
  char *result;
737
  size_t resultlen;
738
 
739
  if (domain_file->decided == 0)
740
    _nl_load_domain (domain_file, domainbinding);
741
 
742
  if (domain_file->data == NULL)
743
    return NULL;
744
 
745
  domain = (struct loaded_domain *) domain_file->data;
746
 
747
  nstrings = domain->nstrings;
748
 
749
  /* Locate the MSGID and its translation.  */
750
  if (domain->hash_tab != NULL)
751
    {
752
      /* Use the hashing table.  */
753
      nls_uint32 len = strlen (msgid);
754
      nls_uint32 hash_val = hash_string (msgid);
755
      nls_uint32 idx = hash_val % domain->hash_size;
756
      nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
757
 
758
      while (1)
759
        {
760
          nls_uint32 nstr =
761
            W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
762
 
763
          if (nstr == 0)
764
            /* Hash table entry is empty.  */
765
            return NULL;
766
 
767
          nstr--;
768
 
769
          /* Compare msgid with the original string at index nstr.
770
             We compare the lengths with >=, not ==, because plural entries
771
             are represented by strings with an embedded NUL.  */
772
          if (nstr < nstrings
773
              ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
774
                && (strcmp (msgid,
775
                            domain->data + W (domain->must_swap,
776
                                              domain->orig_tab[nstr].offset))
777
                    == 0)
778
              : domain->orig_sysdep_tab[nstr - nstrings].length > len
779
                && (strcmp (msgid,
780
                            domain->orig_sysdep_tab[nstr - nstrings].pointer)
781
                    == 0))
782
            {
783
              act = nstr;
784
              goto found;
785
            }
786
 
787
          if (idx >= domain->hash_size - incr)
788
            idx -= domain->hash_size - incr;
789
          else
790
            idx += incr;
791
        }
792
      /* NOTREACHED */
793
    }
794
  else
795
    {
796
      /* Try the default method:  binary search in the sorted array of
797
         messages.  */
798
      size_t top, bottom;
799
 
800
      bottom = 0;
801
      top = nstrings;
802
      while (bottom < top)
803
        {
804
          int cmp_val;
805
 
806
          act = (bottom + top) / 2;
807
          cmp_val = strcmp (msgid, (domain->data
808
                                    + W (domain->must_swap,
809
                                         domain->orig_tab[act].offset)));
810
          if (cmp_val < 0)
811
            top = act;
812
          else if (cmp_val > 0)
813
            bottom = act + 1;
814
          else
815
            goto found;
816
        }
817
      /* No translation was found.  */
818
      return NULL;
819
    }
820
 
821
 found:
822
  /* The translation was found at index ACT.  If we have to convert the
823
     string to use a different character set, this is the time.  */
824
  if (act < nstrings)
825
    {
826
      result = (char *)
827
        (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
828
      resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
829
    }
830
  else
831
    {
832
      result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
833
      resultlen = domain->trans_sysdep_tab[act - nstrings].length;
834
    }
835
 
836
#if defined _LIBC || HAVE_ICONV
837
  if (domain->codeset_cntr
838
      != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
839
    {
840
      /* The domain's codeset has changed through bind_textdomain_codeset()
841
         since the message catalog was initialized or last accessed.  We
842
         have to reinitialize the converter.  */
843
      _nl_free_domain_conv (domain);
844
      _nl_init_domain_conv (domain_file, domain, domainbinding);
845
    }
846
 
847
  if (
848
# ifdef _LIBC
849
      domain->conv != (__gconv_t) -1
850
# else
851
#  if HAVE_ICONV
852
      domain->conv != (iconv_t) -1
853
#  endif
854
# endif
855
      )
856
    {
857
      /* We are supposed to do a conversion.  First allocate an
858
         appropriate table with the same structure as the table
859
         of translations in the file, where we can put the pointers
860
         to the converted strings in.
861
         There is a slight complication with plural entries.  They
862
         are represented by consecutive NUL terminated strings.  We
863
         handle this case by converting RESULTLEN bytes, including
864
         NULs.  */
865
 
866
      if (domain->conv_tab == NULL
867
          && ((domain->conv_tab =
868
                 (char **) calloc (nstrings + domain->n_sysdep_strings,
869
                                   sizeof (char *)))
870
              == NULL))
871
        /* Mark that we didn't succeed allocating a table.  */
872
        domain->conv_tab = (char **) -1;
873
 
874
      if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
875
        /* Nothing we can do, no more memory.  */
876
        goto converted;
877
 
878
      if (domain->conv_tab[act] == NULL)
879
        {
880
          /* We haven't used this string so far, so it is not
881
             translated yet.  Do this now.  */
882
          /* We use a bit more efficient memory handling.
883
             We allocate always larger blocks which get used over
884
             time.  This is faster than many small allocations.   */
885
          __libc_lock_define_initialized (static, lock)
886
# define INITIAL_BLOCK_SIZE     4080
887
          static unsigned char *freemem;
888
          static size_t freemem_size;
889
 
890
          const unsigned char *inbuf;
891
          unsigned char *outbuf;
892
          int malloc_count;
893
# ifndef _LIBC
894
          transmem_block_t *transmem_list = NULL;
895
# endif
896
 
897
          __libc_lock_lock (lock);
898
 
899
          inbuf = (const unsigned char *) result;
900
          outbuf = freemem + sizeof (size_t);
901
 
902
          malloc_count = 0;
903
          while (1)
904
            {
905
              transmem_block_t *newmem;
906
# ifdef _LIBC
907
              size_t non_reversible;
908
              int res;
909
 
910
              if (freemem_size < sizeof (size_t))
911
                goto resize_freemem;
912
 
913
              res = __gconv (domain->conv,
914
                             &inbuf, inbuf + resultlen,
915
                             &outbuf,
916
                             outbuf + freemem_size - sizeof (size_t),
917
                             &non_reversible);
918
 
919
              if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
920
                break;
921
 
922
              if (res != __GCONV_FULL_OUTPUT)
923
                {
924
                  __libc_lock_unlock (lock);
925
                  goto converted;
926
                }
927
 
928
              inbuf = result;
929
# else
930
#  if HAVE_ICONV
931
              const char *inptr = (const char *) inbuf;
932
              size_t inleft = resultlen;
933
              char *outptr = (char *) outbuf;
934
              size_t outleft;
935
 
936
              if (freemem_size < sizeof (size_t))
937
                goto resize_freemem;
938
 
939
              outleft = freemem_size - sizeof (size_t);
940
              if (iconv (domain->conv,
941
                         (ICONV_CONST char **) &inptr, &inleft,
942
                         &outptr, &outleft)
943
                  != (size_t) (-1))
944
                {
945
                  outbuf = (unsigned char *) outptr;
946
                  break;
947
                }
948
              if (errno != E2BIG)
949
                {
950
                  __libc_lock_unlock (lock);
951
                  goto converted;
952
                }
953
#  endif
954
# endif
955
 
956
            resize_freemem:
957
              /* We must allocate a new buffer or resize the old one.  */
958
              if (malloc_count > 0)
959
                {
960
                  ++malloc_count;
961
                  freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
962
                  newmem = (transmem_block_t *) realloc (transmem_list,
963
                                                         freemem_size);
964
# ifdef _LIBC
965
                  if (newmem != NULL)
966
                    transmem_list = transmem_list->next;
967
                  else
968
                    {
969
                      struct transmem_list *old = transmem_list;
970
 
971
                      transmem_list = transmem_list->next;
972
                      free (old);
973
                    }
974
# endif
975
                }
976
              else
977
                {
978
                  malloc_count = 1;
979
                  freemem_size = INITIAL_BLOCK_SIZE;
980
                  newmem = (transmem_block_t *) malloc (freemem_size);
981
                }
982
              if (__builtin_expect (newmem == NULL, 0))
983
                {
984
                  freemem = NULL;
985
                  freemem_size = 0;
986
                  __libc_lock_unlock (lock);
987
                  goto converted;
988
                }
989
 
990
# ifdef _LIBC
991
              /* Add the block to the list of blocks we have to free
992
                 at some point.  */
993
              newmem->next = transmem_list;
994
              transmem_list = newmem;
995
 
996
              freemem = newmem->data;
997
              freemem_size -= offsetof (struct transmem_list, data);
998
# else
999
              transmem_list = newmem;
1000
              freemem = newmem;
1001
# endif
1002
 
1003
              outbuf = freemem + sizeof (size_t);
1004
            }
1005
 
1006
          /* We have now in our buffer a converted string.  Put this
1007
             into the table of conversions.  */
1008
          *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1009
          domain->conv_tab[act] = (char *) freemem;
1010
          /* Shrink freemem, but keep it aligned.  */
1011
          freemem_size -= outbuf - freemem;
1012
          freemem = outbuf;
1013
          freemem += freemem_size & (alignof (size_t) - 1);
1014
          freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1015
 
1016
          __libc_lock_unlock (lock);
1017
        }
1018
 
1019
      /* Now domain->conv_tab[act] contains the translation of all
1020
         the plural variants.  */
1021
      result = domain->conv_tab[act] + sizeof (size_t);
1022
      resultlen = *(size_t *) domain->conv_tab[act];
1023
    }
1024
 
1025
 converted:
1026
  /* The result string is converted.  */
1027
 
1028
#endif /* _LIBC || HAVE_ICONV */
1029
 
1030
  *lengthp = resultlen;
1031
  return result;
1032
}
1033
 
1034
 
1035
/* Look up a plural variant.  */
1036
static char *
1037
internal_function
1038
plural_lookup (domain, n, translation, translation_len)
1039
     struct loaded_l10nfile *domain;
1040
     unsigned long int n;
1041
     const char *translation;
1042
     size_t translation_len;
1043
{
1044
  struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1045
  unsigned long int index;
1046
  const char *p;
1047
 
1048
  index = plural_eval (domaindata->plural, n);
1049
  if (index >= domaindata->nplurals)
1050
    /* This should never happen.  It means the plural expression and the
1051
       given maximum value do not match.  */
1052
    index = 0;
1053
 
1054
  /* Skip INDEX strings at TRANSLATION.  */
1055
  p = translation;
1056
  while (index-- > 0)
1057
    {
1058
#ifdef _LIBC
1059
      p = __rawmemchr (p, '\0');
1060
#else
1061
      p = strchr (p, '\0');
1062
#endif
1063
      /* And skip over the NUL byte.  */
1064
      p++;
1065
 
1066
      if (p >= translation + translation_len)
1067
        /* This should never happen.  It means the plural expression
1068
           evaluated to a value larger than the number of variants
1069
           available for MSGID1.  */
1070
        return (char *) translation;
1071
    }
1072
  return (char *) p;
1073
}
1074
 
1075
#ifndef _LIBC
1076
/* Return string representation of locale CATEGORY.  */
1077
static const char *
1078
internal_function
1079
category_to_name (category)
1080
     int category;
1081
{
1082
  const char *retval;
1083
 
1084
  switch (category)
1085
  {
1086
#ifdef LC_COLLATE
1087
  case LC_COLLATE:
1088
    retval = "LC_COLLATE";
1089
    break;
1090
#endif
1091
#ifdef LC_CTYPE
1092
  case LC_CTYPE:
1093
    retval = "LC_CTYPE";
1094
    break;
1095
#endif
1096
#ifdef LC_MONETARY
1097
  case LC_MONETARY:
1098
    retval = "LC_MONETARY";
1099
    break;
1100
#endif
1101
#ifdef LC_NUMERIC
1102
  case LC_NUMERIC:
1103
    retval = "LC_NUMERIC";
1104
    break;
1105
#endif
1106
#ifdef LC_TIME
1107
  case LC_TIME:
1108
    retval = "LC_TIME";
1109
    break;
1110
#endif
1111
#ifdef LC_MESSAGES
1112
  case LC_MESSAGES:
1113
    retval = "LC_MESSAGES";
1114
    break;
1115
#endif
1116
#ifdef LC_RESPONSE
1117
  case LC_RESPONSE:
1118
    retval = "LC_RESPONSE";
1119
    break;
1120
#endif
1121
#ifdef LC_ALL
1122
  case LC_ALL:
1123
    /* This might not make sense but is perhaps better than any other
1124
       value.  */
1125
    retval = "LC_ALL";
1126
    break;
1127
#endif
1128
  default:
1129
    /* If you have a better idea for a default value let me know.  */
1130
    retval = "LC_XXX";
1131
  }
1132
 
1133
  return retval;
1134
}
1135
#endif
1136
 
1137
/* Guess value of current locale from value of the environment variables.  */
1138
static const char *
1139
internal_function
1140
guess_category_value (category, categoryname)
1141
     int category;
1142
     const char *categoryname;
1143
{
1144
  const char *language;
1145
  const char *retval;
1146
 
1147
  /* The highest priority value is the `LANGUAGE' environment
1148
     variable.  But we don't use the value if the currently selected
1149
     locale is the C locale.  This is a GNU extension.  */
1150
  language = getenv ("LANGUAGE");
1151
  if (language != NULL && language[0] == '\0')
1152
    language = NULL;
1153
 
1154
  /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1155
     `LC_xxx', and `LANG'.  On some systems this can be done by the
1156
     `setlocale' function itself.  */
1157
#ifdef _LIBC
1158
  retval = __current_locale_name (category);
1159
#else
1160
  retval = _nl_locale_name (category, categoryname);
1161
#endif
1162
 
1163
  /* Ignore LANGUAGE if the locale is set to "C" because
1164
     1. "C" locale usually uses the ASCII encoding, and most international
1165
        messages use non-ASCII characters. These characters get displayed
1166
        as question marks (if using glibc's iconv()) or as invalid 8-bit
1167
        characters (because other iconv()s refuse to convert most non-ASCII
1168
        characters to ASCII). In any case, the output is ugly.
1169
     2. The precise output of some programs in the "C" locale is specified
1170
        by POSIX and should not depend on environment variables like
1171
        "LANGUAGE".  We allow such programs to use gettext().  */
1172
  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
1173
}
1174
 
1175
/* @@ begin of epilog @@ */
1176
 
1177
/* We don't want libintl.a to depend on any other library.  So we
1178
   avoid the non-standard function stpcpy.  In GNU C Library this
1179
   function is available, though.  Also allow the symbol HAVE_STPCPY
1180
   to be defined.  */
1181
#if !_LIBC && !HAVE_STPCPY
1182
static char *
1183
stpcpy (dest, src)
1184
     char *dest;
1185
     const char *src;
1186
{
1187
  while ((*dest++ = *src++) != '\0')
1188
    /* Do nothing. */ ;
1189
  return dest - 1;
1190
}
1191
#endif
1192
 
1193
#if !_LIBC && !HAVE_MEMPCPY
1194
static void *
1195
mempcpy (dest, src, n)
1196
     void *dest;
1197
     const void *src;
1198
     size_t n;
1199
{
1200
  return (void *) ((char *) memcpy (dest, src, n) + n);
1201
}
1202
#endif
1203
 
1204
 
1205
#ifdef _LIBC
1206
/* If we want to free all resources we have to do some work at
1207
   program's end.  */
1208
libc_freeres_fn (free_mem)
1209
{
1210
  void *old;
1211
 
1212
  while (_nl_domain_bindings != NULL)
1213
    {
1214
      struct binding *oldp = _nl_domain_bindings;
1215
      _nl_domain_bindings = _nl_domain_bindings->next;
1216
      if (oldp->dirname != INTUSE(_nl_default_dirname))
1217
        /* Yes, this is a pointer comparison.  */
1218
        free (oldp->dirname);
1219
      free (oldp->codeset);
1220
      free (oldp);
1221
    }
1222
 
1223
  if (_nl_current_default_domain != _nl_default_default_domain)
1224
    /* Yes, again a pointer comparison.  */
1225
    free ((char *) _nl_current_default_domain);
1226
 
1227
  /* Remove the search tree with the known translations.  */
1228
  __tdestroy (root, free);
1229
  root = NULL;
1230
 
1231
  while (transmem_list != NULL)
1232
    {
1233
      old = transmem_list;
1234
      transmem_list = transmem_list->next;
1235
      free (old);
1236
    }
1237
}
1238
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.