* stdio-common/printf_fp.c (__printf_fp): Add prototype for nested
[kopensolaris-gnu/glibc.git] / locale / programs / ld-ctype.c
1 /* Copyright (C) 1995-1999, 2000 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Ulrich Drepper <drepper@gnu.org>, 1995.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #include <alloca.h>
25 #include <byteswap.h>
26 #include <endian.h>
27 #include <errno.h>
28 #include <limits.h>
29 #include <obstack.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <wchar.h>
33 #include <wctype.h>
34 #include <sys/uio.h>
35
36 #include "charmap.h"
37 #include "localeinfo.h"
38 #include "langinfo.h"
39 #include "linereader.h"
40 #include "locfile-token.h"
41 #include "locfile.h"
42 #include "localedef.h"
43
44 #include <assert.h>
45
46
47 #ifdef PREDEFINED_CLASSES
48 /* These are the extra bits not in wctype.h since these are not preallocated
49    classes.  */
50 # define _ISwspecial1   (1 << 29)
51 # define _ISwspecial2   (1 << 30)
52 # define _ISwspecial3   (1 << 31)
53 #endif
54
55
56 /* The bit used for representing a special class.  */
57 #define BITPOS(class) ((class) - tok_upper)
58 #define BIT(class) (_ISbit (BITPOS (class)))
59 #define BITw(class) (_ISwbit (BITPOS (class)))
60
61 #define ELEM(ctype, collection, idx, value)                                   \
62   *find_idx (ctype, &ctype->collection idx, &ctype->collection##_max idx,     \
63              &ctype->collection##_act idx, value)
64
65
66 /* To be compatible with former implementations we for now restrict
67    the number of bits for character classes to 16.  When compatibility
68    is not necessary anymore increase the number to 32.  */
69 #define char_class_t uint16_t
70 #define char_class32_t uint32_t
71
72
73 /* Type to describe a transliteration action.  We have a possibly
74    multiple character from-string and a set of multiple character
75    to-strings.  All are 32bit values since this is what is used in
76    the gconv functions.  */
77 struct translit_to_t
78 {
79   uint32_t *str;
80
81   struct translit_to_t *next;
82 };
83
84 struct translit_t
85 {
86   uint32_t *from;
87
88   const char *fname;
89   size_t lineno;
90
91   struct translit_to_t *to;
92
93   struct translit_t *next;
94 };
95
96 struct translit_ignore_t
97 {
98   uint32_t from;
99   uint32_t to;
100   uint32_t step;
101
102   const char *fname;
103   size_t lineno;
104
105   struct translit_ignore_t *next;
106 };
107
108
109 /* Type to describe a transliteration include statement.  */
110 struct translit_include_t
111 {
112   const char *copy_locale;
113   const char *copy_repertoire;
114
115   struct translit_include_t *next;
116 };
117
118
119 /* The real definition of the struct for the LC_CTYPE locale.  */
120 struct locale_ctype_t
121 {
122   uint32_t *charnames;
123   size_t charnames_max;
124   size_t charnames_act;
125   /* An index lookup table, to speedup find_idx.  */
126 #define MAX_CHARNAMES_IDX 0x10000
127   uint32_t *charnames_idx;
128
129   struct repertoire_t *repertoire;
130
131   /* We will allow up to 8 * sizeof (uint32_t) character classes.  */
132 #define MAX_NR_CHARCLASS (8 * sizeof (uint32_t))
133   size_t nr_charclass;
134   const char *classnames[MAX_NR_CHARCLASS];
135   uint32_t last_class_char;
136   uint32_t class256_collection[256];
137   uint32_t *class_collection;
138   size_t class_collection_max;
139   size_t class_collection_act;
140   uint32_t class_done;
141   uint32_t class_offset;
142
143   struct charseq **mbdigits;
144   size_t mbdigits_act;
145   size_t mbdigits_max;
146   uint32_t *wcdigits;
147   size_t wcdigits_act;
148   size_t wcdigits_max;
149
150   struct charseq *mboutdigits[10];
151   uint32_t wcoutdigits[10];
152   size_t outdigits_act;
153
154   /* If the following number ever turns out to be too small simply
155      increase it.  But I doubt it will.  --drepper@gnu */
156 #define MAX_NR_CHARMAP 16
157   const char *mapnames[MAX_NR_CHARMAP];
158   uint32_t *map_collection[MAX_NR_CHARMAP];
159   uint32_t map256_collection[2][256];
160   size_t map_collection_max[MAX_NR_CHARMAP];
161   size_t map_collection_act[MAX_NR_CHARMAP];
162   size_t map_collection_nr;
163   size_t last_map_idx;
164   int tomap_done[MAX_NR_CHARMAP];
165   uint32_t map_offset;
166
167   /* Transliteration information.  */
168   struct translit_include_t *translit_include;
169   struct translit_t *translit;
170   struct translit_ignore_t *translit_ignore;
171   uint32_t ntranslit_ignore;
172
173   uint32_t *default_missing;
174   const char *default_missing_file;
175   size_t default_missing_lineno;
176
177   /* The arrays for the binary representation.  */
178   char_class_t *ctype_b;
179   char_class32_t *ctype32_b;
180   uint32_t **map_b;
181   uint32_t **map32_b;
182   uint32_t **class_b;
183   struct iovec *class_3level;
184   struct iovec *map_3level;
185   uint32_t *class_name_ptr;
186   uint32_t *map_name_ptr;
187   struct iovec width;
188   uint32_t mb_cur_max;
189   const char *codeset_name;
190   uint32_t *translit_from_idx;
191   uint32_t *translit_from_tbl;
192   uint32_t *translit_to_idx;
193   uint32_t *translit_to_tbl;
194   uint32_t translit_idx_size;
195   size_t translit_from_tbl_size;
196   size_t translit_to_tbl_size;
197
198   struct obstack mempool;
199 };
200
201
202 #define obstack_chunk_alloc xmalloc
203 #define obstack_chunk_free free
204
205
206 /* Prototypes for local functions.  */
207 static void ctype_startup (struct linereader *lr, struct localedef_t *locale,
208                            struct charmap_t *charmap,
209                            struct localedef_t *copy_locale,
210                            int ignore_content);
211 static void ctype_class_new (struct linereader *lr,
212                              struct locale_ctype_t *ctype, const char *name);
213 static void ctype_map_new (struct linereader *lr,
214                            struct locale_ctype_t *ctype,
215                            const char *name, struct charmap_t *charmap);
216 static uint32_t *find_idx (struct locale_ctype_t *ctype, uint32_t **table,
217                            size_t *max, size_t *act, unsigned int idx);
218 static void set_class_defaults (struct locale_ctype_t *ctype,
219                                 struct charmap_t *charmap,
220                                 struct repertoire_t *repertoire);
221 static void allocate_arrays (struct locale_ctype_t *ctype,
222                              struct charmap_t *charmap,
223                              struct repertoire_t *repertoire);
224
225
226 static const char *longnames[] =
227 {
228   "zero", "one", "two", "three", "four",
229   "five", "six", "seven", "eight", "nine"
230 };
231 static const char *uninames[] =
232 {
233   "U00000030", "U00000031", "U00000032", "U00000033", "U00000034",
234   "U00000035", "U00000036", "U00000037", "U00000038", "U00000039"
235 };
236 static const unsigned char digits[] = "0123456789";
237
238
239 static void
240 ctype_startup (struct linereader *lr, struct localedef_t *locale,
241                struct charmap_t *charmap, struct localedef_t *copy_locale,
242                int ignore_content)
243 {
244   unsigned int cnt;
245   struct locale_ctype_t *ctype;
246
247   if (!ignore_content && locale->categories[LC_CTYPE].ctype == NULL)
248     {
249       if (copy_locale == NULL)
250         {
251           /* Allocate the needed room.  */
252           locale->categories[LC_CTYPE].ctype = ctype =
253             (struct locale_ctype_t *) xcalloc (1,
254                                                sizeof (struct locale_ctype_t));
255
256           /* We have seen no names yet.  */
257           ctype->charnames_max = charmap->mb_cur_max == 1 ? 256 : 512;
258           ctype->charnames =
259             (unsigned int *) xmalloc (ctype->charnames_max
260                                       * sizeof (unsigned int));
261           for (cnt = 0; cnt < 256; ++cnt)
262             ctype->charnames[cnt] = cnt;
263           ctype->charnames_act = 256;
264           ctype->charnames_idx =
265             (uint32_t *) xmalloc (MAX_CHARNAMES_IDX * sizeof (uint32_t));
266           for (cnt = 0; cnt < MAX_CHARNAMES_IDX; ++cnt)
267             ctype->charnames_idx[cnt] = ~((uint32_t) 0);
268
269           /* Fill character class information.  */
270           ctype->last_class_char = ILLEGAL_CHAR_VALUE;
271           /* The order of the following instructions determines the bit
272              positions!  */
273           ctype_class_new (lr, ctype, "upper");
274           ctype_class_new (lr, ctype, "lower");
275           ctype_class_new (lr, ctype, "alpha");
276           ctype_class_new (lr, ctype, "digit");
277           ctype_class_new (lr, ctype, "xdigit");
278           ctype_class_new (lr, ctype, "space");
279           ctype_class_new (lr, ctype, "print");
280           ctype_class_new (lr, ctype, "graph");
281           ctype_class_new (lr, ctype, "blank");
282           ctype_class_new (lr, ctype, "cntrl");
283           ctype_class_new (lr, ctype, "punct");
284           ctype_class_new (lr, ctype, "alnum");
285 #ifdef PREDEFINED_CLASSES
286           /* The following are extensions from ISO 14652.  */
287           ctype_class_new (lr, ctype, "left_to_right");
288           ctype_class_new (lr, ctype, "right_to_left");
289           ctype_class_new (lr, ctype, "num_terminator");
290           ctype_class_new (lr, ctype, "num_separator");
291           ctype_class_new (lr, ctype, "segment_separator");
292           ctype_class_new (lr, ctype, "block_separator");
293           ctype_class_new (lr, ctype, "direction_control");
294           ctype_class_new (lr, ctype, "sym_swap_layout");
295           ctype_class_new (lr, ctype, "char_shape_selector");
296           ctype_class_new (lr, ctype, "num_shape_selector");
297           ctype_class_new (lr, ctype, "non_spacing");
298           ctype_class_new (lr, ctype, "non_spacing_level3");
299           ctype_class_new (lr, ctype, "normal_connect");
300           ctype_class_new (lr, ctype, "r_connect");
301           ctype_class_new (lr, ctype, "no_connect");
302           ctype_class_new (lr, ctype, "no_connect-space");
303           ctype_class_new (lr, ctype, "vowel_connect");
304 #endif
305
306           ctype->class_collection_max = charmap->mb_cur_max == 1 ? 256 : 512;
307           ctype->class_collection
308             = (uint32_t *) xcalloc (sizeof (unsigned long int),
309                                     ctype->class_collection_max);
310           ctype->class_collection_act = 256;
311
312           /* Fill character map information.  */
313           ctype->last_map_idx = MAX_NR_CHARMAP;
314           ctype_map_new (lr, ctype, "toupper", charmap);
315           ctype_map_new (lr, ctype, "tolower", charmap);
316 #ifdef PREDEFINED_CLASSES
317           ctype_map_new (lr, ctype, "tosymmetric", charmap);
318 #endif
319
320           /* Fill first 256 entries in `toXXX' arrays.  */
321           for (cnt = 0; cnt < 256; ++cnt)
322             {
323               ctype->map_collection[0][cnt] = cnt;
324               ctype->map_collection[1][cnt] = cnt;
325 #ifdef PREDEFINED_CLASSES
326               ctype->map_collection[2][cnt] = cnt;
327 #endif
328               ctype->map256_collection[0][cnt] = cnt;
329               ctype->map256_collection[1][cnt] = cnt;
330             }
331
332           obstack_init (&ctype->mempool);
333         }
334       else
335         ctype = locale->categories[LC_CTYPE].ctype =
336           copy_locale->categories[LC_CTYPE].ctype;
337     }
338 }
339
340
341 void
342 ctype_finish (struct localedef_t *locale, struct charmap_t *charmap)
343 {
344   /* See POSIX.2, table 2-6 for the meaning of the following table.  */
345 #define NCLASS 12
346   static const struct
347   {
348     const char *name;
349     const char allow[NCLASS];
350   }
351   valid_table[NCLASS] =
352   {
353     /* The order is important.  See token.h for more information.
354        M = Always, D = Default, - = Permitted, X = Mutually exclusive  */
355     { "upper",  "--MX-XDDXXX-" },
356     { "lower",  "--MX-XDDXXX-" },
357     { "alpha",  "---X-XDDXXX-" },
358     { "digit",  "XXX--XDDXXX-" },
359     { "xdigit", "-----XDDXXX-" },
360     { "space",  "XXXXX------X" },
361     { "print",  "---------X--" },
362     { "graph",  "---------X--" },
363     { "blank",  "XXXXXM-----X" },
364     { "cntrl",  "XXXXX-XX--XX" },
365     { "punct",  "XXXXX-DD-X-X" },
366     { "alnum",  "-----XDDXXX-" }
367   };
368   size_t cnt;
369   int cls1, cls2;
370   uint32_t space_value;
371   struct charseq *space_seq;
372   struct locale_ctype_t *ctype = locale->categories[LC_CTYPE].ctype;
373   int warned;
374   const void *key;
375   size_t len;
376   void *vdata;
377   void *curs;
378
379   /* Now resolve copying and also handle completely missing definitions.  */
380   if (ctype == NULL)
381     {
382       const char *repertoire_name;
383
384       /* First see whether we were supposed to copy.  If yes, find the
385          actual definition.  */
386       if (locale->copy_name[LC_CTYPE] != NULL)
387         {
388           /* Find the copying locale.  This has to happen transitively since
389              the locale we are copying from might also copying another one.  */
390           struct localedef_t *from = locale;
391
392           do
393             from = find_locale (LC_CTYPE, from->copy_name[LC_CTYPE],
394                                 from->repertoire_name, charmap);
395           while (from->categories[LC_CTYPE].ctype == NULL
396                  && from->copy_name[LC_CTYPE] != NULL);
397
398           ctype = locale->categories[LC_CTYPE].ctype
399             = from->categories[LC_CTYPE].ctype;
400         }
401
402       /* If there is still no definition issue an warning and create an
403          empty one.  */
404       if (ctype == NULL)
405         {
406           if (! be_quiet)
407             error (0, 0, _("No definition for %s category found"), "LC_CTYPE");
408           ctype_startup (NULL, locale, charmap, NULL, 0);
409           ctype = locale->categories[LC_CTYPE].ctype;
410         }
411
412       /* Get the repertoire we have to use.  */
413       repertoire_name = locale->repertoire_name ?: repertoire_global;
414       if (repertoire_name != NULL)
415         ctype->repertoire = repertoire_read (repertoire_name);
416     }
417
418   /* We need the name of the currently used 8-bit character set to
419      make correct conversion between this 8-bit representation and the
420      ISO 10646 character set used internally for wide characters.  */
421   ctype->codeset_name = charmap->code_set_name;
422   if (ctype->codeset_name == NULL)
423     {
424       if (! be_quiet)
425         error (0, 0, _("No character set name specified in charmap"));
426       ctype->codeset_name = "//UNKNOWN//";
427     }
428
429   /* Set default value for classes not specified.  */
430   set_class_defaults (ctype, charmap, ctype->repertoire);
431
432   /* Check according to table.  */
433   for (cnt = 0; cnt < ctype->class_collection_act; ++cnt)
434     {
435       uint32_t tmp = ctype->class_collection[cnt];
436
437       if (tmp != 0)
438         {
439           for (cls1 = 0; cls1 < NCLASS; ++cls1)
440             if ((tmp & _ISwbit (cls1)) != 0)
441               for (cls2 = 0; cls2 < NCLASS; ++cls2)
442                 if (valid_table[cls1].allow[cls2] != '-')
443                   {
444                     int eq = (tmp & _ISwbit (cls2)) != 0;
445                     switch (valid_table[cls1].allow[cls2])
446                       {
447                       case 'M':
448                         if (!eq)
449                           {
450                             uint32_t value = ctype->charnames[cnt];
451
452                             if (!be_quiet)
453                               error (0, 0, _("\
454 character L'\\u%0*x' in class `%s' must be in class `%s'"),
455                                      value > 0xffff ? 8 : 4, value,
456                                      valid_table[cls1].name,
457                                      valid_table[cls2].name);
458                           }
459                         break;
460
461                       case 'X':
462                         if (eq)
463                           {
464                             uint32_t value = ctype->charnames[cnt];
465
466                             if (!be_quiet)
467                               error (0, 0, _("\
468 character L'\\u%0*x' in class `%s' must not be in class `%s'"),
469                                      value > 0xffff ? 8 : 4, value,
470                                      valid_table[cls1].name,
471                                      valid_table[cls2].name);
472                           }
473                         break;
474
475                       case 'D':
476                         ctype->class_collection[cnt] |= _ISwbit (cls2);
477                         break;
478
479                       default:
480                         error (5, 0, _("internal error in %s, line %u"),
481                                __FUNCTION__, __LINE__);
482                       }
483                   }
484         }
485     }
486
487   for (cnt = 0; cnt < 256; ++cnt)
488     {
489       uint32_t tmp = ctype->class256_collection[cnt];
490
491       if (tmp != 0)
492         {
493           for (cls1 = 0; cls1 < NCLASS; ++cls1)
494             if ((tmp & _ISbit (cls1)) != 0)
495               for (cls2 = 0; cls2 < NCLASS; ++cls2)
496                 if (valid_table[cls1].allow[cls2] != '-')
497                   {
498                     int eq = (tmp & _ISbit (cls2)) != 0;
499                     switch (valid_table[cls1].allow[cls2])
500                       {
501                       case 'M':
502                         if (!eq)
503                           {
504                             char buf[17];
505
506                             snprintf (buf, sizeof buf, "\\%Zo", cnt);
507
508                             if (!be_quiet)
509                               error (0, 0, _("\
510 character '%s' in class `%s' must be in class `%s'"),
511                                      buf, valid_table[cls1].name,
512                                      valid_table[cls2].name);
513                           }
514                         break;
515
516                       case 'X':
517                         if (eq)
518                           {
519                             char buf[17];
520
521                             snprintf (buf, sizeof buf, "\\%Zo", cnt);
522
523                             if (!be_quiet)
524                               error (0, 0, _("\
525 character '%s' in class `%s' must not be in class `%s'"),
526                                      buf, valid_table[cls1].name,
527                                      valid_table[cls2].name);
528                           }
529                         break;
530
531                       case 'D':
532                         ctype->class256_collection[cnt] |= _ISbit (cls2);
533                         break;
534
535                       default:
536                         error (5, 0, _("internal error in %s, line %u"),
537                                __FUNCTION__, __LINE__);
538                       }
539                   }
540         }
541     }
542
543   /* ... and now test <SP> as a special case.  */
544   space_value = 32;
545   if (((cnt = BITPOS (tok_space),
546         (ELEM (ctype, class_collection, , space_value)
547          & BITw (tok_space)) == 0)
548        || (cnt = BITPOS (tok_blank),
549            (ELEM (ctype, class_collection, , space_value)
550             & BITw (tok_blank)) == 0)))
551     {
552       if (!be_quiet)
553         error (0, 0, _("<SP> character not in class `%s'"),
554                valid_table[cnt].name);
555     }
556   else if (((cnt = BITPOS (tok_punct),
557              (ELEM (ctype, class_collection, , space_value)
558               & BITw (tok_punct)) != 0)
559             || (cnt = BITPOS (tok_graph),
560                 (ELEM (ctype, class_collection, , space_value)
561                  & BITw (tok_graph))
562                 != 0)))
563     {
564       if (!be_quiet)
565         error (0, 0, _("<SP> character must not be in class `%s'"),
566                valid_table[cnt].name);
567     }
568   else
569     ELEM (ctype, class_collection, , space_value) |= BITw (tok_print);
570
571   space_seq = charmap_find_value (charmap, "SP", 2);
572   if (space_seq == NULL)
573     space_seq = charmap_find_value (charmap, "space", 5);
574   if (space_seq == NULL)
575     space_seq = charmap_find_value (charmap, "U00000020", 9);
576   if (space_seq == NULL || space_seq->nbytes != 1)
577     {
578       if (!be_quiet)
579         error (0, 0, _("character <SP> not defined in character map"));
580     }
581   else if (((cnt = BITPOS (tok_space),
582              (ctype->class256_collection[space_seq->bytes[0]]
583               & BIT (tok_space)) == 0)
584             || (cnt = BITPOS (tok_blank),
585                 (ctype->class256_collection[space_seq->bytes[0]]
586                  & BIT (tok_blank)) == 0)))
587     {
588       if (!be_quiet)
589         error (0, 0, _("<SP> character not in class `%s'"),
590                valid_table[cnt].name);
591     }
592   else if (((cnt = BITPOS (tok_punct),
593              (ctype->class256_collection[space_seq->bytes[0]]
594               & BIT (tok_punct)) != 0)
595             || (cnt = BITPOS (tok_graph),
596                 (ctype->class256_collection[space_seq->bytes[0]]
597                  & BIT (tok_graph)) != 0)))
598     {
599       if (!be_quiet)
600         error (0, 0, _("<SP> character must not be in class `%s'"),
601                valid_table[cnt].name);
602     }
603   else
604     ctype->class256_collection[space_seq->bytes[0]] |= BIT (tok_print);
605
606   /* Now that the tests are done make sure the name array contains all
607      characters which are handled in the WIDTH section of the
608      character set definition file.  */
609   if (charmap->width_rules != NULL)
610     for (cnt = 0; cnt < charmap->nwidth_rules; ++cnt)
611       {
612         unsigned char bytes[charmap->mb_cur_max];
613         int nbytes = charmap->width_rules[cnt].from->nbytes;
614
615         /* We have the range of character for which the width is
616            specified described using byte sequences of the multibyte
617            charset.  We have to convert this to UCS4 now.  And we
618            cannot simply convert the beginning and the end of the
619            sequence, we have to iterate over the byte sequence and
620            convert it for every single character.  */
621         memcpy (bytes, charmap->width_rules[cnt].from->bytes, nbytes);
622
623         while (nbytes < charmap->width_rules[cnt].to->nbytes
624                || memcmp (bytes, charmap->width_rules[cnt].to->bytes,
625                           nbytes) <= 0)
626           {
627             /* Find the UCS value for `bytes'.  */
628             int inner;
629             uint32_t wch;
630             struct charseq *seq = charmap_find_symbol (charmap, bytes, nbytes);
631
632             if (seq == NULL)
633               wch = ILLEGAL_CHAR_VALUE;
634             else if (seq->ucs4 != UNINITIALIZED_CHAR_VALUE)
635               wch = seq->ucs4;
636             else
637               wch = repertoire_find_value (ctype->repertoire, seq->name,
638                                            strlen (seq->name));
639
640             if (wch != ILLEGAL_CHAR_VALUE)
641               /* We are only interested in the side-effects of the
642                  `find_idx' call.  It will add appropriate entries in
643                  the name array if this is necessary.  */
644               (void) find_idx (ctype, NULL, NULL, NULL, wch);
645
646             /* "Increment" the bytes sequence.  */
647             inner = nbytes - 1;
648             while (inner >= 0 && bytes[inner] == 0xff)
649               --inner;
650
651             if (inner < 0)
652               {
653                 /* We have to extend the byte sequence.  */
654                 if (nbytes >= charmap->width_rules[cnt].to->nbytes)
655                   break;
656
657                 bytes[0] = 1;
658                 memset (&bytes[1], 0, nbytes);
659                 ++nbytes;
660               }
661             else
662               {
663                 ++bytes[inner];
664                 while (++inner < nbytes)
665                   bytes[inner] = 0;
666               }
667           }
668       }
669
670   /* Now set all the other characters of the character set to the
671      default width.  */
672   curs = NULL;
673   while (iterate_table (&charmap->char_table, &curs, &key, &len, &vdata) == 0)
674     {
675       struct charseq *data = (struct charseq *) vdata;
676
677       if (data->ucs4 == UNINITIALIZED_CHAR_VALUE)
678         data->ucs4 = repertoire_find_value (ctype->repertoire,
679                                             data->name, len);
680
681       if (data->ucs4 != ILLEGAL_CHAR_VALUE)
682         (void) find_idx (ctype, NULL, NULL, NULL, data->ucs4);
683     }
684
685   /* There must be a multiple of 10 digits.  */
686   if (ctype->mbdigits_act % 10 != 0)
687     {
688       assert (ctype->mbdigits_act == ctype->wcdigits_act);
689       ctype->wcdigits_act -= ctype->mbdigits_act % 10;
690       ctype->mbdigits_act -= ctype->mbdigits_act % 10;
691       error (0, 0, _("`digit' category has not entries in groups of ten"));
692     }
693
694   /* Check the input digits.  There must be a multiple of ten available.
695      In each group it could be that one or the other character is missing.
696      In this case the whole group must be removed.  */
697   cnt = 0;
698   while (cnt < ctype->mbdigits_act)
699     {
700       size_t inner;
701       for (inner = 0; inner < 10; ++inner)
702         if (ctype->mbdigits[cnt + inner] == NULL)
703           break;
704
705       if (inner == 10)
706         cnt += 10;
707       else
708         {
709           /* Remove the group.  */
710           memmove (&ctype->mbdigits[cnt], &ctype->mbdigits[cnt + 10],
711                    ((ctype->wcdigits_act - cnt - 10)
712                     * sizeof (ctype->mbdigits[0])));
713           ctype->mbdigits_act -= 10;
714         }
715     }
716
717   /* If no input digits are given use the default.  */
718   if (ctype->mbdigits_act == 0)
719     {
720       if (ctype->mbdigits_max == 0)
721         {
722           ctype->mbdigits = obstack_alloc (&charmap->mem_pool,
723                                            10 * sizeof (struct charseq *));
724           ctype->mbdigits_max = 10;
725         }
726
727       for (cnt = 0; cnt < 10; ++cnt)
728         {
729           ctype->mbdigits[cnt] = charmap_find_symbol (charmap,
730                                                       digits + cnt, 1);
731           if (ctype->mbdigits[cnt] == NULL)
732             {
733               ctype->mbdigits[cnt] = charmap_find_symbol (charmap,
734                                                           longnames[cnt],
735                                                           strlen (longnames[cnt]));
736               if (ctype->mbdigits[cnt] == NULL)
737                 {
738                   /* Hum, this ain't good.  */
739                   error (0, 0, _("\
740 no input digits defined and none of the standard names in the charmap"));
741
742                   ctype->mbdigits[cnt] = obstack_alloc (&charmap->mem_pool,
743                                                         sizeof (struct charseq) + 1);
744
745                   /* This is better than nothing.  */
746                   ctype->mbdigits[cnt]->bytes[0] = digits[cnt];
747                   ctype->mbdigits[cnt]->nbytes = 1;
748                 }
749             }
750         }
751
752       ctype->mbdigits_act = 10;
753     }
754
755   /* Check the wide character input digits.  There must be a multiple
756      of ten available.  In each group it could be that one or the other
757      character is missing.  In this case the whole group must be
758      removed.  */
759   cnt = 0;
760   while (cnt < ctype->wcdigits_act)
761     {
762       size_t inner;
763       for (inner = 0; inner < 10; ++inner)
764         if (ctype->wcdigits[cnt + inner] == ILLEGAL_CHAR_VALUE)
765           break;
766
767       if (inner == 10)
768         cnt += 10;
769       else
770         {
771           /* Remove the group.  */
772           memmove (&ctype->wcdigits[cnt], &ctype->wcdigits[cnt + 10],
773                    ((ctype->wcdigits_act - cnt - 10)
774                     * sizeof (ctype->wcdigits[0])));
775           ctype->wcdigits_act -= 10;
776         }
777     }
778
779   /* If no input digits are given use the default.  */
780   if (ctype->wcdigits_act == 0)
781     {
782       if (ctype->wcdigits_max == 0)
783         {
784           ctype->wcdigits = obstack_alloc (&charmap->mem_pool,
785                                            10 * sizeof (uint32_t));
786           ctype->wcdigits_max = 10;
787         }
788
789       for (cnt = 0; cnt < 10; ++cnt)
790         ctype->wcdigits[cnt] = L'0' + cnt;
791
792       ctype->mbdigits_act = 10;
793     }
794
795   /* Check the outdigits.  */
796   warned = 0;
797   for (cnt = 0; cnt < 10; ++cnt)
798     if (ctype->mboutdigits[cnt] == NULL)
799       {
800         static struct charseq replace[2];
801
802         if (!warned)
803           {
804             error (0, 0, _("\
805 not all characters used in `outdigit' are available in the charmap"));
806             warned = 1;
807           }
808
809         replace[0].nbytes = 1;
810         replace[0].bytes[0] = '?';
811         replace[0].bytes[1] = '\0';
812         ctype->mboutdigits[cnt] = &replace[0];
813       }
814
815   warned = 0;
816   for (cnt = 0; cnt < 10; ++cnt)
817     if (ctype->wcoutdigits[cnt] == 0)
818       {
819         if (!warned)
820           {
821             error (0, 0, _("\
822 not all characters used in `outdigit' are available in the repertoire"));
823             warned = 1;
824           }
825
826         ctype->wcoutdigits[cnt] = L'?';
827       }
828
829   /* Sort the entries in the translit_ignore list.  */
830   if (ctype->translit_ignore != NULL)
831     {
832       struct translit_ignore_t *firstp = ctype->translit_ignore;
833       struct translit_ignore_t *runp;
834
835       ctype->ntranslit_ignore = 1;
836
837       for (runp = firstp->next; runp != NULL; runp = runp->next)
838         {
839           struct translit_ignore_t *lastp = NULL;
840           struct translit_ignore_t *cmpp;
841
842           ++ctype->ntranslit_ignore;
843
844           for (cmpp = firstp; cmpp != NULL; lastp = cmpp, cmpp = cmpp->next)
845             if (runp->from < cmpp->from)
846               break;
847
848           runp->next = lastp;
849           if (lastp == NULL)
850             firstp = runp;
851         }
852
853       ctype->translit_ignore = firstp;
854     }
855 }
856
857
858 void
859 ctype_output (struct localedef_t *locale, struct charmap_t *charmap,
860               const char *output_path)
861 {
862   static const char nulbytes[4] = { 0, 0, 0, 0 };
863   struct locale_ctype_t *ctype = locale->categories[LC_CTYPE].ctype;
864   const size_t nelems = (_NL_ITEM_INDEX (_NL_CTYPE_EXTRA_MAP_1)
865                          + ctype->nr_charclass + ctype->map_collection_nr);
866   struct iovec iov[2 + nelems + 2 * ctype->nr_charclass
867                   + ctype->map_collection_nr + 4];
868   struct locale_file data;
869   uint32_t idx[nelems + 1];
870   uint32_t default_missing_len;
871   size_t elem, cnt, offset, total;
872   char *cp;
873
874   /* Now prepare the output: Find the sizes of the table we can use.  */
875   allocate_arrays (ctype, charmap, ctype->repertoire);
876
877   data.magic = LIMAGIC (LC_CTYPE);
878   data.n = nelems;
879   iov[0].iov_base = (void *) &data;
880   iov[0].iov_len = sizeof (data);
881
882   iov[1].iov_base = (void *) idx;
883   iov[1].iov_len = nelems * sizeof (uint32_t);
884
885   idx[0] = iov[0].iov_len + iov[1].iov_len;
886   offset = 0;
887
888   for (elem = 0; elem < nelems; ++elem)
889     {
890       if (elem < _NL_ITEM_INDEX (_NL_CTYPE_EXTRA_MAP_1))
891         switch (elem)
892           {
893 #define CTYPE_EMPTY(name) \
894           case name:                                                          \
895             iov[2 + elem + offset].iov_base = NULL;                           \
896             iov[2 + elem + offset].iov_len = 0;                               \
897             idx[elem + 1] = idx[elem];                                        \
898             break
899
900           CTYPE_EMPTY(_NL_CTYPE_GAP1);
901           CTYPE_EMPTY(_NL_CTYPE_GAP2);
902           CTYPE_EMPTY(_NL_CTYPE_GAP3);
903           CTYPE_EMPTY(_NL_CTYPE_GAP4);
904           CTYPE_EMPTY(_NL_CTYPE_GAP5);
905           CTYPE_EMPTY(_NL_CTYPE_GAP6);
906
907 #define CTYPE_DATA(name, base, len)                                           \
908           case _NL_ITEM_INDEX (name):                                         \
909             iov[2 + elem + offset].iov_base = (base);                         \
910             iov[2 + elem + offset].iov_len = (len);                           \
911             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;       \
912             break
913
914           CTYPE_DATA (_NL_CTYPE_CLASS,
915                       ctype->ctype_b,
916                       (256 + 128) * sizeof (char_class_t));
917
918           CTYPE_DATA (_NL_CTYPE_TOUPPER,
919                       ctype->map_b[0],
920                       (256 + 128) * sizeof (uint32_t));
921           CTYPE_DATA (_NL_CTYPE_TOLOWER,
922                       ctype->map_b[1],
923                       (256 + 128) * sizeof (uint32_t));
924
925           CTYPE_DATA (_NL_CTYPE_TOUPPER32,
926                       ctype->map32_b[0],
927                       256 * sizeof (uint32_t));
928           CTYPE_DATA (_NL_CTYPE_TOLOWER32,
929                       ctype->map32_b[1],
930                       256 * sizeof (uint32_t));
931
932           CTYPE_DATA (_NL_CTYPE_CLASS32,
933                       ctype->ctype32_b,
934                       256 * sizeof (char_class32_t));
935
936           CTYPE_DATA (_NL_CTYPE_CLASS_OFFSET,
937                       &ctype->class_offset, sizeof (uint32_t));
938
939           CTYPE_DATA (_NL_CTYPE_MAP_OFFSET,
940                       &ctype->map_offset, sizeof (uint32_t));
941
942           CTYPE_DATA (_NL_CTYPE_TRANSLIT_TAB_SIZE,
943                       &ctype->translit_idx_size, sizeof (uint32_t));
944
945           CTYPE_DATA (_NL_CTYPE_TRANSLIT_FROM_IDX,
946                       ctype->translit_from_idx,
947                       ctype->translit_idx_size * sizeof (uint32_t));
948
949           CTYPE_DATA (_NL_CTYPE_TRANSLIT_FROM_TBL,
950                       ctype->translit_from_tbl,
951                       ctype->translit_from_tbl_size);
952
953           CTYPE_DATA (_NL_CTYPE_TRANSLIT_TO_IDX,
954                       ctype->translit_to_idx,
955                       ctype->translit_idx_size * sizeof (uint32_t));
956
957           CTYPE_DATA (_NL_CTYPE_TRANSLIT_TO_TBL,
958                       ctype->translit_to_tbl, ctype->translit_to_tbl_size);
959
960           case _NL_ITEM_INDEX (_NL_CTYPE_CLASS_NAMES):
961             /* The class name array.  */
962             total = 0;
963             for (cnt = 0; cnt < ctype->nr_charclass; ++cnt, ++offset)
964               {
965                 iov[2 + elem + offset].iov_base
966                   = (void *) ctype->classnames[cnt];
967                 iov[2 + elem + offset].iov_len
968                   = strlen (ctype->classnames[cnt]) + 1;
969                 total += iov[2 + elem + offset].iov_len;
970               }
971             iov[2 + elem + offset].iov_base = (void *) nulbytes;
972             iov[2 + elem + offset].iov_len = 1 + (4 - ((total + 1) % 4));
973             total += 1 + (4 - ((total + 1) % 4));
974
975             idx[elem + 1] = idx[elem] + total;
976             break;
977
978           case _NL_ITEM_INDEX (_NL_CTYPE_MAP_NAMES):
979             /* The class name array.  */
980             total = 0;
981             for (cnt = 0; cnt < ctype->map_collection_nr; ++cnt, ++offset)
982               {
983                 iov[2 + elem + offset].iov_base
984                   = (void *) ctype->mapnames[cnt];
985                 iov[2 + elem + offset].iov_len
986                   = strlen (ctype->mapnames[cnt]) + 1;
987                 total += iov[2 + elem + offset].iov_len;
988               }
989             iov[2 + elem + offset].iov_base = (void *) nulbytes;
990             iov[2 + elem + offset].iov_len = 1 + (4 - ((total + 1) % 4));
991             total += 1 + (4 - ((total + 1) % 4));
992
993             idx[elem + 1] = idx[elem] + total;
994             break;
995
996           CTYPE_DATA (_NL_CTYPE_WIDTH,
997                       ctype->width.iov_base,
998                       ctype->width.iov_len);
999
1000           CTYPE_DATA (_NL_CTYPE_MB_CUR_MAX,
1001                       &ctype->mb_cur_max, sizeof (uint32_t));
1002
1003           case _NL_ITEM_INDEX (_NL_CTYPE_CODESET_NAME):
1004             total = strlen (ctype->codeset_name) + 1;
1005             if (total % 4 == 0)
1006               iov[2 + elem + offset].iov_base = (char *) ctype->codeset_name;
1007             else
1008               {
1009                 iov[2 + elem + offset].iov_base = alloca ((total + 3) & ~3);
1010                 memset (mempcpy (iov[2 + elem + offset].iov_base,
1011                                  ctype->codeset_name, total),
1012                         '\0', 4 - (total & 3));
1013                 total = (total + 3) & ~3;
1014               }
1015             iov[2 + elem + offset].iov_len = total;
1016             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1017             break;
1018
1019           case _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS_MB_LEN):
1020             iov[2 + elem + offset].iov_base = alloca (sizeof (uint32_t));
1021             iov[2 + elem + offset].iov_len = sizeof (uint32_t);
1022             *(uint32_t *) iov[2 + elem + offset].iov_base =
1023               ctype->mbdigits_act / 10;
1024             idx[elem + 1] = idx[elem] + sizeof (uint32_t);
1025             break;
1026
1027           case _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS_WC_LEN):
1028             /* Align entries.  */
1029             iov[2 + elem + offset].iov_base = (void *) nulbytes;
1030             iov[2 + elem + offset].iov_len = (4 - idx[elem] % 4) % 4;
1031             idx[elem] += iov[2 + elem + offset].iov_len;
1032             ++offset;
1033
1034             iov[2 + elem + offset].iov_base = alloca (sizeof (uint32_t));
1035             iov[2 + elem + offset].iov_len = sizeof (uint32_t);
1036             *(uint32_t *) iov[2 + elem + offset].iov_base =
1037               ctype->wcdigits_act / 10;
1038             idx[elem + 1] = idx[elem] + sizeof (uint32_t);
1039             break;
1040
1041           case _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS0_MB) ... _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS9_MB):
1042             /* Compute the length of all possible characters.  For INDIGITS
1043                there might be more than one.  We simply concatenate all of
1044                them with a NUL byte following.  The NUL byte wouldn't be
1045                necessary but it makes it easier for the user.  */
1046             total = 0;
1047
1048             for (cnt = elem - _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS0_MB);
1049                  cnt < ctype->mbdigits_act; cnt += 10)
1050               total += ctype->mbdigits[cnt]->nbytes + 1;
1051             iov[2 + elem + offset].iov_base = (char *) alloca (total);
1052             iov[2 + elem + offset].iov_len = total;
1053
1054             cp = iov[2 + elem + offset].iov_base;
1055             for (cnt = elem - _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS0_MB);
1056                  cnt < ctype->mbdigits_act; cnt += 10)
1057               {
1058                 cp = mempcpy (cp, ctype->mbdigits[cnt]->bytes,
1059                               ctype->mbdigits[cnt]->nbytes);
1060                 *cp++ = '\0';
1061               }
1062             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1063             break;
1064
1065           case _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT0_MB) ... _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT9_MB):
1066             /* Compute the length of all possible characters.  For INDIGITS
1067                there might be more than one.  We simply concatenate all of
1068                them with a NUL byte following.  The NUL byte wouldn't be
1069                necessary but it makes it easier for the user.  */
1070             cnt = elem - _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT0_MB);
1071             total = ctype->mboutdigits[cnt]->nbytes + 1;
1072             iov[2 + elem + offset].iov_base = (char *) alloca (total);
1073             iov[2 + elem + offset].iov_len = total;
1074
1075             *(char *) mempcpy (iov[2 + elem + offset].iov_base,
1076                                ctype->mboutdigits[cnt]->bytes,
1077                                ctype->mboutdigits[cnt]->nbytes) = '\0';
1078             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1079             break;
1080
1081           case _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS0_WC) ... _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS9_WC):
1082             total = ctype->wcdigits_act / 10;
1083
1084             iov[2 + elem + offset].iov_base =
1085               (uint32_t *) alloca (total * sizeof (uint32_t));
1086             iov[2 + elem + offset].iov_len = total * sizeof (uint32_t);
1087
1088             for (cnt = elem - _NL_ITEM_INDEX (_NL_CTYPE_INDIGITS0_WC);
1089                  cnt < ctype->wcdigits_act; cnt += 10)
1090               ((uint32_t *) iov[2 + elem + offset].iov_base)[cnt / 10]
1091                 = ctype->wcdigits[cnt];
1092             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1093             break;
1094
1095           case _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT0_WC):
1096             /* Align entries.  */
1097             iov[2 + elem + offset].iov_base = (void *) nulbytes;
1098             iov[2 + elem + offset].iov_len = (4 - idx[elem] % 4) % 4;
1099             idx[elem] += iov[2 + elem + offset].iov_len;
1100             ++offset;
1101             /* FALLTRHOUGH */
1102
1103           case _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT1_WC) ... _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT9_WC):
1104             cnt = elem - _NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT0_WC);
1105             iov[2 + elem + offset].iov_base = &ctype->wcoutdigits[cnt];
1106             iov[2 + elem + offset].iov_len = sizeof (uint32_t);
1107             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1108             break;
1109
1110           case _NL_ITEM_INDEX(_NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN):
1111             /* Align entries.  */
1112             iov[2 + elem + offset].iov_base = (void *) nulbytes;
1113             iov[2 + elem + offset].iov_len = (4 - idx[elem] % 4) % 4;
1114             idx[elem] += iov[2 + elem + offset].iov_len;
1115             ++offset;
1116
1117             default_missing_len = (ctype->default_missing
1118                                    ? wcslen ((wchar_t *)ctype->default_missing)
1119                                    : 0);
1120             iov[2 + elem + offset].iov_base = &default_missing_len;
1121             iov[2 + elem + offset].iov_len = sizeof (uint32_t);
1122             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1123             break;
1124
1125           case _NL_ITEM_INDEX(_NL_CTYPE_TRANSLIT_DEFAULT_MISSING):
1126             iov[2 + elem + offset].iov_base =
1127               ctype->default_missing ?: (uint32_t *) L"";
1128             iov[2 + elem + offset].iov_len =
1129               wcslen (iov[2 + elem + offset].iov_base);
1130             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1131             break;
1132
1133           case _NL_ITEM_INDEX(_NL_CTYPE_TRANSLIT_IGNORE_LEN):
1134             /* Align entries.  */
1135             iov[2 + elem + offset].iov_base = (void *) nulbytes;
1136             iov[2 + elem + offset].iov_len = (4 - idx[elem] % 4) % 4;
1137             idx[elem] += iov[2 + elem + offset].iov_len;
1138             ++offset;
1139
1140             iov[2 + elem + offset].iov_base = &ctype->ntranslit_ignore;
1141             iov[2 + elem + offset].iov_len = sizeof (uint32_t);
1142             idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1143             break;
1144
1145           case _NL_ITEM_INDEX(_NL_CTYPE_TRANSLIT_IGNORE):
1146             {
1147               uint32_t *ranges = (uint32_t *) alloca (ctype->ntranslit_ignore
1148                                                       * 3 * sizeof (uint32_t));
1149               struct translit_ignore_t *runp;
1150
1151               iov[2 + elem + offset].iov_base = ranges;
1152               iov[2 + elem + offset].iov_len = (ctype->ntranslit_ignore
1153                                                 * 3 * sizeof (uint32_t));
1154
1155               for (runp = ctype->translit_ignore; runp != NULL;
1156                    runp = runp->next)
1157                 {
1158                   *ranges++ = runp->from;
1159                   *ranges++ = runp->to;
1160                   *ranges++ = runp->step;
1161                 }
1162             }
1163             /* Remove the following line in case a new entry is added
1164                after _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN.  */
1165             if (elem < nelems)
1166               idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1167             break;
1168
1169           default:
1170             assert (! "unknown CTYPE element");
1171           }
1172       else
1173         {
1174           /* Handle extra maps.  */
1175           size_t nr = elem - _NL_ITEM_INDEX (_NL_CTYPE_EXTRA_MAP_1);
1176           if (nr < ctype->nr_charclass)
1177             {
1178               iov[2 + elem + offset].iov_base = ctype->class_b[nr];
1179               iov[2 + elem + offset].iov_len = 256 / 32 * sizeof (uint32_t);
1180               idx[elem] += iov[2 + elem + offset].iov_len;
1181               ++offset;
1182
1183               iov[2 + elem + offset] = ctype->class_3level[nr];
1184             }
1185           else
1186             {
1187               nr -= ctype->nr_charclass;
1188               assert (nr < ctype->map_collection_nr);
1189               iov[2 + elem + offset] = ctype->map_3level[nr];
1190             }
1191           idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
1192         }
1193     }
1194
1195   assert (2 + elem + offset == (nelems + 2 * ctype->nr_charclass
1196                                 + ctype->map_collection_nr + 4 + 2));
1197
1198   write_locale_data (output_path, "LC_CTYPE", 2 + elem + offset, iov);
1199 }
1200
1201
1202 /* Local functions.  */
1203 static void
1204 ctype_class_new (struct linereader *lr, struct locale_ctype_t *ctype,
1205                  const char *name)
1206 {
1207   size_t cnt;
1208
1209   for (cnt = 0; cnt < ctype->nr_charclass; ++cnt)
1210     if (strcmp (ctype->classnames[cnt], name) == 0)
1211       break;
1212
1213   if (cnt < ctype->nr_charclass)
1214     {
1215       lr_error (lr, _("character class `%s' already defined"), name);
1216       return;
1217     }
1218
1219   if (ctype->nr_charclass == MAX_NR_CHARCLASS)
1220     /* Exit code 2 is prescribed in P1003.2b.  */
1221     error (2, 0, _("\
1222 implementation limit: no more than %Zd character classes allowed"),
1223            MAX_NR_CHARCLASS);
1224
1225   ctype->classnames[ctype->nr_charclass++] = name;
1226 }
1227
1228
1229 static void
1230 ctype_map_new (struct linereader *lr, struct locale_ctype_t *ctype,
1231                const char *name, struct charmap_t *charmap)
1232 {
1233   size_t max_chars = 0;
1234   size_t cnt;
1235
1236   for (cnt = 0; cnt < ctype->map_collection_nr; ++cnt)
1237     {
1238       if (strcmp (ctype->mapnames[cnt], name) == 0)
1239         break;
1240
1241       if (max_chars < ctype->map_collection_max[cnt])
1242         max_chars = ctype->map_collection_max[cnt];
1243     }
1244
1245   if (cnt < ctype->map_collection_nr)
1246     {
1247       lr_error (lr, _("character map `%s' already defined"), name);
1248       return;
1249     }
1250
1251   if (ctype->map_collection_nr == MAX_NR_CHARMAP)
1252     /* Exit code 2 is prescribed in P1003.2b.  */
1253     error (2, 0, _("\
1254 implementation limit: no more than %d character maps allowed"),
1255            MAX_NR_CHARMAP);
1256
1257   ctype->mapnames[cnt] = name;
1258
1259   if (max_chars == 0)
1260     ctype->map_collection_max[cnt] = charmap->mb_cur_max == 1 ? 256 : 512;
1261   else
1262     ctype->map_collection_max[cnt] = max_chars;
1263
1264   ctype->map_collection[cnt] = (uint32_t *)
1265     xcalloc (sizeof (uint32_t), ctype->map_collection_max[cnt]);
1266   ctype->map_collection_act[cnt] = 256;
1267
1268   ++ctype->map_collection_nr;
1269 }
1270
1271
1272 /* We have to be prepared that TABLE, MAX, and ACT can be NULL.  This
1273    is possible if we only want to extend the name array.  */
1274 static uint32_t *
1275 find_idx (struct locale_ctype_t *ctype, uint32_t **table, size_t *max,
1276           size_t *act, uint32_t idx)
1277 {
1278   size_t cnt;
1279
1280   if (idx < 256)
1281     return table == NULL ? NULL : &(*table)[idx];
1282
1283   /* If idx is in the usual range, use the charnames_idx lookup table
1284      instead of the slow search loop.  */
1285   if (idx < MAX_CHARNAMES_IDX)
1286     {
1287       if (ctype->charnames_idx[idx] != ~((uint32_t) 0))
1288         /* Found.  */
1289         cnt = ctype->charnames_idx[idx];
1290       else
1291         /* Not found.  */
1292         cnt = ctype->charnames_act;
1293     }
1294   else
1295     {
1296       for (cnt = 256; cnt < ctype->charnames_act; ++cnt)
1297         if (ctype->charnames[cnt] == idx)
1298           break;
1299     }
1300
1301   /* We have to distinguish two cases: the name is found or not.  */
1302   if (cnt == ctype->charnames_act)
1303     {
1304       /* Extend the name array.  */
1305       if (ctype->charnames_act == ctype->charnames_max)
1306         {
1307           ctype->charnames_max *= 2;
1308           ctype->charnames = (uint32_t *)
1309             xrealloc (ctype->charnames,
1310                       sizeof (uint32_t) * ctype->charnames_max);
1311         }
1312       ctype->charnames[ctype->charnames_act++] = idx;
1313       if (idx < MAX_CHARNAMES_IDX)
1314         ctype->charnames_idx[idx] = cnt;
1315     }
1316
1317   if (table == NULL)
1318     /* We have done everything we are asked to do.  */
1319     return NULL;
1320
1321   if (max == NULL)
1322     /* The caller does not want to extend the table.  */
1323     return (cnt >= *act ? NULL : &(*table)[cnt]);
1324
1325   if (cnt >= *act)
1326     {
1327       if (cnt >= *max)
1328         {
1329           size_t old_max = *max;
1330           do
1331             *max *= 2;
1332           while (*max <= cnt);
1333
1334           *table =
1335             (uint32_t *) xrealloc (*table, *max * sizeof (uint32_t));
1336           memset (&(*table)[old_max], '\0',
1337                   (*max - old_max) * sizeof (uint32_t));
1338         }
1339
1340       *act = cnt + 1;
1341     }
1342
1343   return &(*table)[cnt];
1344 }
1345
1346
1347 static int
1348 get_character (struct token *now, struct charmap_t *charmap,
1349                struct repertoire_t *repertoire,
1350                struct charseq **seqp, uint32_t *wchp)
1351 {
1352   if (now->tok == tok_bsymbol)
1353     {
1354       /* This will hopefully be the normal case.  */
1355       *wchp = repertoire_find_value (repertoire, now->val.str.startmb,
1356                                      now->val.str.lenmb);
1357       *seqp = charmap_find_value (charmap, now->val.str.startmb,
1358                                   now->val.str.lenmb);
1359     }
1360   else if (now->tok == tok_ucs4)
1361     {
1362       char utmp[10];
1363
1364       snprintf (utmp, sizeof (utmp), "U%08X", now->val.ucs4);
1365       *seqp = charmap_find_value (charmap, utmp, 9);
1366
1367       if (*seqp == NULL)
1368         *seqp = repertoire_find_seq (repertoire, now->val.ucs4);
1369
1370       if (*seqp == NULL)
1371         {
1372           /* Compute the value in the charmap from the UCS value.  */
1373           const char *symbol = repertoire_find_symbol (repertoire,
1374                                                        now->val.ucs4);
1375
1376           if (symbol == NULL)
1377             *seqp = NULL;
1378           else
1379             *seqp = charmap_find_value (charmap, symbol, strlen (symbol));
1380
1381           if (*seqp == NULL)
1382             {
1383               if (repertoire != NULL)
1384                 {
1385                   /* Insert a negative entry.  */
1386                   static const struct charseq negative
1387                     = { .ucs4 = ILLEGAL_CHAR_VALUE };
1388                   uint32_t *newp = obstack_alloc (&repertoire->mem_pool,
1389                                                   sizeof (uint32_t));
1390                   *newp = now->val.ucs4;
1391
1392                   insert_entry (&repertoire->seq_table, newp,
1393                                 sizeof (uint32_t), (void *) &negative);
1394                 }
1395             }
1396           else
1397             (*seqp)->ucs4 = now->val.ucs4;
1398         }
1399       else if ((*seqp)->ucs4 != now->val.ucs4)
1400         *seqp = NULL;
1401
1402       *wchp = now->val.ucs4;
1403     }
1404   else if (now->tok == tok_charcode)
1405     {
1406       /* We must map from the byte code to UCS4.  */
1407       *seqp = charmap_find_symbol (charmap, now->val.str.startmb,
1408                                    now->val.str.lenmb);
1409
1410       if (*seqp == NULL)
1411         *wchp = ILLEGAL_CHAR_VALUE;
1412       else
1413         {
1414           if ((*seqp)->ucs4 == UNINITIALIZED_CHAR_VALUE)
1415             (*seqp)->ucs4 = repertoire_find_value (repertoire, (*seqp)->name,
1416                                                    strlen ((*seqp)->name));
1417           *wchp = (*seqp)->ucs4;
1418         }
1419     }
1420   else
1421     return 1;
1422
1423   return 0;
1424 }
1425
1426
1427 /* Ellipsis like in `<foo123>..<foo12a>' or `<j1234>....<j1245>' and
1428    the .(2). counterparts.  */
1429 static void
1430 charclass_symbolic_ellipsis (struct linereader *ldfile,
1431                              struct locale_ctype_t *ctype,
1432                              struct charmap_t *charmap,
1433                              struct repertoire_t *repertoire,
1434                              struct token *now,
1435                              const char *last_str,
1436                              unsigned long int class256_bit,
1437                              unsigned long int class_bit, int base,
1438                              int ignore_content, int handle_digits, int step)
1439 {
1440   const char *nowstr = now->val.str.startmb;
1441   char tmp[now->val.str.lenmb + 1];
1442   const char *cp;
1443   char *endp;
1444   unsigned long int from;
1445   unsigned long int to;
1446
1447   /* We have to compute the ellipsis values using the symbolic names.  */
1448   assert (last_str != NULL);
1449
1450   if (strlen (last_str) != now->val.str.lenmb)
1451     {
1452     invalid_range:
1453       lr_error (ldfile,
1454                 _("`%s' and `%.*s' are no valid names for symbolic range"),
1455                 last_str, (int) now->val.str.lenmb, nowstr);
1456       return;
1457     }
1458
1459   if (memcmp (last_str, nowstr, now->val.str.lenmb) == 0)
1460     /* Nothing to do, the names are the same.  */
1461     return;
1462
1463   for (cp = last_str; *cp == *(nowstr + (cp - last_str)); ++cp)
1464     ;
1465
1466   errno = 0;
1467   from = strtoul (cp, &endp, base);
1468   if ((from == UINT_MAX && errno == ERANGE) || *endp != '\0')
1469     goto invalid_range;
1470
1471   to = strtoul (nowstr + (cp - last_str), &endp, base);
1472   if ((to == UINT_MAX && errno == ERANGE)
1473       || (endp - nowstr) != now->val.str.lenmb || from >= to)
1474     goto invalid_range;
1475
1476   /* OK, we have a range FROM - TO.  Now we can create the symbolic names.  */
1477   if (!ignore_content)
1478     {
1479       now->val.str.startmb = tmp;
1480       while ((from += step) <= to)
1481         {
1482           struct charseq *seq;
1483           uint32_t wch;
1484
1485           sprintf (tmp, (base == 10 ? "%.*s%0*ld" : "%.*s%0*lX"),
1486                    (int) (cp - last_str), last_str,
1487                    (int) (now->val.str.lenmb - (cp - last_str)),
1488                    from);
1489
1490           get_character (now, charmap, repertoire, &seq, &wch);
1491
1492           if (seq != NULL && seq->nbytes == 1)
1493             /* Yep, we can store information about this byte sequence.  */
1494             ctype->class256_collection[seq->bytes[0]] |= class256_bit;
1495
1496           if (wch != ILLEGAL_CHAR_VALUE && class_bit != 0)
1497             /* We have the UCS4 position.  */
1498             *find_idx (ctype, &ctype->class_collection,
1499                        &ctype->class_collection_max,
1500                        &ctype->class_collection_act, wch) |= class_bit;
1501
1502           if (handle_digits == 1)
1503             {
1504               /* We must store the digit values.  */
1505               if (ctype->mbdigits_act == ctype->mbdigits_max)
1506                 {
1507                   ctype->mbdigits_max *= 2;
1508                   ctype->mbdigits = xrealloc (ctype->mbdigits,
1509                                               (ctype->mbdigits_max
1510                                                * sizeof (char *)));
1511                   ctype->wcdigits_max *= 2;
1512                   ctype->wcdigits = xrealloc (ctype->wcdigits,
1513                                               (ctype->wcdigits_max
1514                                                * sizeof (uint32_t)));
1515                 }
1516
1517               ctype->mbdigits[ctype->mbdigits_act++] = seq;
1518               ctype->wcdigits[ctype->wcdigits_act++] = wch;
1519             }
1520           else if (handle_digits == 2)
1521             {
1522               /* We must store the digit values.  */
1523               if (ctype->outdigits_act >= 10)
1524                 {
1525                   lr_error (ldfile, _("\
1526 %s: field `%s' does not contain exactly ten entries"),
1527                             "LC_CTYPE", "outdigit");
1528                   return;
1529                 }
1530
1531               ctype->mboutdigits[ctype->outdigits_act] = seq;
1532               ctype->wcoutdigits[ctype->outdigits_act] = wch;
1533               ++ctype->outdigits_act;
1534             }
1535         }
1536     }
1537 }
1538
1539
1540 /* Ellipsis like in `<U1234>..<U2345>' or `<U1234>..(2)..<U2345>'.  */
1541 static void
1542 charclass_ucs4_ellipsis (struct linereader *ldfile,
1543                          struct locale_ctype_t *ctype,
1544                          struct charmap_t *charmap,
1545                          struct repertoire_t *repertoire,
1546                          struct token *now, uint32_t last_wch,
1547                          unsigned long int class256_bit,
1548                          unsigned long int class_bit, int ignore_content,
1549                          int handle_digits, int step)
1550 {
1551   if (last_wch > now->val.ucs4)
1552     {
1553       lr_error (ldfile, _("\
1554 to-value <U%0*X> of range is smaller than from-value <U%0*X>"),
1555                 (now->val.ucs4 | last_wch) < 65536 ? 4 : 8, now->val.ucs4,
1556                 (now->val.ucs4 | last_wch) < 65536 ? 4 : 8, last_wch);
1557       return;
1558     }
1559
1560   if (!ignore_content)
1561     while ((last_wch += step) <= now->val.ucs4)
1562       {
1563         /* We have to find out whether there is a byte sequence corresponding
1564            to this UCS4 value.  */
1565         struct charseq *seq;
1566         char utmp[10];
1567
1568         snprintf (utmp, sizeof (utmp), "U%08X", last_wch);
1569         seq = charmap_find_value (charmap, utmp, 9);
1570         if (seq == NULL)
1571           {
1572             snprintf (utmp, sizeof (utmp), "U%04X", last_wch);
1573             seq = charmap_find_value (charmap, utmp, 5);
1574           }
1575
1576         if (seq == NULL)
1577           /* Try looking in the repertoire map.  */
1578           seq = repertoire_find_seq (repertoire, last_wch);
1579
1580         /* If this is the first time we look for this sequence create a new
1581            entry.  */
1582         if (seq == NULL)
1583           {
1584             static const struct charseq negative
1585               = { .ucs4 = ILLEGAL_CHAR_VALUE };
1586
1587             /* Find the symbolic name for this UCS4 value.  */
1588             if (repertoire != NULL)
1589               {
1590                 const char *symbol = repertoire_find_symbol (repertoire,
1591                                                              last_wch);
1592                 uint32_t *newp = obstack_alloc (&repertoire->mem_pool,
1593                                                 sizeof (uint32_t));
1594                 *newp = last_wch;
1595
1596                 if (symbol != NULL)
1597                   /* We have a name, now search the multibyte value.  */
1598                   seq = charmap_find_value (charmap, symbol, strlen (symbol));
1599
1600                 if (seq == NULL)
1601                   /* We have to create a fake entry.  */
1602                   seq = (struct charseq *) &negative;
1603                 else
1604                   seq->ucs4 = last_wch;
1605
1606                 insert_entry (&repertoire->seq_table, newp, sizeof (uint32_t),
1607                               seq);
1608               }
1609             else
1610               /* We have to create a fake entry.  */
1611               seq = (struct charseq *) &negative;
1612           }
1613
1614         /* We have a name, now search the multibyte value.  */
1615         if (seq->ucs4 == last_wch && seq->nbytes == 1)
1616           /* Yep, we can store information about this byte sequence.  */
1617           ctype->class256_collection[(size_t) seq->bytes[0]]
1618             |= class256_bit;
1619
1620         /* And of course we have the UCS4 position.  */
1621         if (class_bit != 0)
1622           *find_idx (ctype, &ctype->class_collection,
1623                      &ctype->class_collection_max,
1624                      &ctype->class_collection_act, last_wch) |= class_bit;
1625
1626         if (handle_digits == 1)
1627           {
1628             /* We must store the digit values.  */
1629             if (ctype->mbdigits_act == ctype->mbdigits_max)
1630               {
1631                 ctype->mbdigits_max *= 2;
1632                 ctype->mbdigits = xrealloc (ctype->mbdigits,
1633                                             (ctype->mbdigits_max
1634                                              * sizeof (char *)));
1635                 ctype->wcdigits_max *= 2;
1636                 ctype->wcdigits = xrealloc (ctype->wcdigits,
1637                                             (ctype->wcdigits_max
1638                                              * sizeof (uint32_t)));
1639               }
1640
1641             ctype->mbdigits[ctype->mbdigits_act++] = (seq->ucs4 == last_wch
1642                                                       ? seq : NULL);
1643             ctype->wcdigits[ctype->wcdigits_act++] = last_wch;
1644           }
1645         else if (handle_digits == 2)
1646           {
1647             /* We must store the digit values.  */
1648             if (ctype->outdigits_act >= 10)
1649               {
1650                 lr_error (ldfile, _("\
1651 %s: field `%s' does not contain exactly ten entries"),
1652                           "LC_CTYPE", "outdigit");
1653                 return;
1654               }
1655
1656             ctype->mboutdigits[ctype->outdigits_act] = (seq->ucs4 == last_wch
1657                                                         ? seq : NULL);
1658             ctype->wcoutdigits[ctype->outdigits_act] = last_wch;
1659             ++ctype->outdigits_act;
1660           }
1661       }
1662 }
1663
1664
1665 /* Ellipsis as in `/xea/x12.../xea/x34'.  */
1666 static void
1667 charclass_charcode_ellipsis (struct linereader *ldfile,
1668                              struct locale_ctype_t *ctype,
1669                              struct charmap_t *charmap,
1670                              struct repertoire_t *repertoire,
1671                              struct token *now, char *last_charcode,
1672                              uint32_t last_charcode_len,
1673                              unsigned long int class256_bit,
1674                              unsigned long int class_bit, int ignore_content,
1675                              int handle_digits)
1676 {
1677   /* First check whether the to-value is larger.  */
1678   if (now->val.charcode.nbytes != last_charcode_len)
1679     {
1680       lr_error (ldfile, _("\
1681 start and end character sequence of range must have the same length"));
1682       return;
1683     }
1684
1685   if (memcmp (last_charcode, now->val.charcode.bytes, last_charcode_len) > 0)
1686     {
1687       lr_error (ldfile, _("\
1688 to-value character sequence is smaller than from-value sequence"));
1689       return;
1690     }
1691
1692   if (!ignore_content)
1693     {
1694       do
1695         {
1696           /* Increment the byte sequence value.  */
1697           struct charseq *seq;
1698           uint32_t wch;
1699           int i;
1700
1701           for (i = last_charcode_len - 1; i >= 0; --i)
1702             if (++last_charcode[i] != 0)
1703               break;
1704
1705           if (last_charcode_len == 1)
1706             /* Of course we have the charcode value.  */
1707             ctype->class256_collection[(size_t) last_charcode[0]]
1708               |= class256_bit;
1709
1710           /* Find the symbolic name.  */
1711           seq = charmap_find_symbol (charmap, last_charcode,
1712                                      last_charcode_len);
1713           if (seq != NULL)
1714             {
1715               if (seq->ucs4 == UNINITIALIZED_CHAR_VALUE)
1716                 seq->ucs4 = repertoire_find_value (repertoire, seq->name,
1717                                                    strlen (seq->name));
1718               wch = seq == NULL ? ILLEGAL_CHAR_VALUE : seq->ucs4;
1719
1720               if (wch != ILLEGAL_CHAR_VALUE && class_bit != 0)
1721                 *find_idx (ctype, &ctype->class_collection,
1722                            &ctype->class_collection_max,
1723                            &ctype->class_collection_act, wch) |= class_bit;
1724             }
1725           else
1726             wch = ILLEGAL_CHAR_VALUE;
1727
1728           if (handle_digits == 1)
1729             {
1730               /* We must store the digit values.  */
1731               if (ctype->mbdigits_act == ctype->mbdigits_max)
1732                 {
1733                   ctype->mbdigits_max *= 2;
1734                   ctype->mbdigits = xrealloc (ctype->mbdigits,
1735                                               (ctype->mbdigits_max
1736                                                * sizeof (char *)));
1737                   ctype->wcdigits_max *= 2;
1738                   ctype->wcdigits = xrealloc (ctype->wcdigits,
1739                                               (ctype->wcdigits_max
1740                                                * sizeof (uint32_t)));
1741                 }
1742
1743               seq = xmalloc (sizeof (struct charseq) + last_charcode_len);
1744               memcpy ((char *) (seq + 1), last_charcode, last_charcode_len);
1745               seq->nbytes = last_charcode_len;
1746
1747               ctype->mbdigits[ctype->mbdigits_act++] = seq;
1748               ctype->wcdigits[ctype->wcdigits_act++] = wch;
1749             }
1750           else if (handle_digits == 2)
1751             {
1752               struct charseq *seq;
1753               /* We must store the digit values.  */
1754               if (ctype->outdigits_act >= 10)
1755                 {
1756                   lr_error (ldfile, _("\
1757 %s: field `%s' does not contain exactly ten entries"),
1758                             "LC_CTYPE", "outdigit");
1759                   return;
1760                 }
1761
1762               seq = xmalloc (sizeof (struct charseq) + last_charcode_len);
1763               memcpy ((char *) (seq + 1), last_charcode, last_charcode_len);
1764               seq->nbytes = last_charcode_len;
1765
1766               ctype->mboutdigits[ctype->outdigits_act] = seq;
1767               ctype->wcoutdigits[ctype->outdigits_act] = wch;
1768               ++ctype->outdigits_act;
1769             }
1770         }
1771       while (memcmp (last_charcode, now->val.charcode.bytes,
1772                      last_charcode_len) != 0);
1773     }
1774 }
1775
1776
1777 /* Read one transliteration entry.  */
1778 static uint32_t *
1779 read_widestring (struct linereader *ldfile, struct token *now,
1780                  struct charmap_t *charmap, struct repertoire_t *repertoire)
1781 {
1782   uint32_t *wstr;
1783
1784   if (now->tok == tok_default_missing)
1785     /* The special name "" will denote this case.  */
1786     wstr = ((uint32_t *) { 0 });
1787   else if (now->tok == tok_bsymbol)
1788     {
1789       /* Get the value from the repertoire.  */
1790       wstr = (uint32_t *) xmalloc (2 * sizeof (uint32_t));
1791       wstr[0] = repertoire_find_value (repertoire, now->val.str.startmb,
1792                                        now->val.str.lenmb);
1793       if (wstr[0] == ILLEGAL_CHAR_VALUE)
1794         {
1795           /* We cannot proceed, we don't know the UCS4 value.  */
1796           free (wstr);
1797           return NULL;
1798         }
1799
1800       wstr[1] = 0;
1801     }
1802   else if (now->tok == tok_ucs4)
1803     {
1804       wstr = (uint32_t *) xmalloc (2 * sizeof (uint32_t));
1805       wstr[0] = now->val.ucs4;
1806       wstr[1] = 0;
1807     }
1808   else if (now->tok == tok_charcode)
1809     {
1810       /* Argh, we have to convert to the symbol name first and then to the
1811          UCS4 value.  */
1812       struct charseq *seq = charmap_find_symbol (charmap,
1813                                                  now->val.str.startmb,
1814                                                  now->val.str.lenmb);
1815       if (seq == NULL)
1816         /* Cannot find the UCS4 value.  */
1817         return NULL;
1818
1819       if (seq->ucs4 == UNINITIALIZED_CHAR_VALUE)
1820         seq->ucs4 = repertoire_find_value (repertoire, seq->name,
1821                                            strlen (seq->name));
1822       if (seq->ucs4 == ILLEGAL_CHAR_VALUE)
1823         /* We cannot proceed, we don't know the UCS4 value.  */
1824         return NULL;
1825
1826       wstr = (uint32_t *) xmalloc (2 * sizeof (uint32_t));
1827       wstr[0] = seq->ucs4;
1828       wstr[1] = 0;
1829     }
1830   else if (now->tok == tok_string)
1831     {
1832       wstr = now->val.str.startwc;
1833       if (wstr == NULL || wstr[0] == 0)
1834         return NULL;
1835     }
1836   else
1837     {
1838       if (now->tok != tok_eol && now->tok != tok_eof)
1839         lr_ignore_rest (ldfile, 0);
1840       SYNTAX_ERROR (_("%s: syntax error"), "LC_CTYPE");
1841       return (uint32_t *) -1l;
1842     }
1843
1844   return wstr;
1845 }
1846
1847
1848 static void
1849 read_translit_entry (struct linereader *ldfile, struct locale_ctype_t *ctype,
1850                      struct token *now, struct charmap_t *charmap,
1851                      struct repertoire_t *repertoire)
1852 {
1853   uint32_t *from_wstr = read_widestring (ldfile, now, charmap, repertoire);
1854   struct translit_t *result;
1855   struct translit_to_t **top;
1856   struct obstack *ob = &ctype->mempool;
1857   int first;
1858   int ignore;
1859
1860   if (from_wstr == NULL)
1861     /* There is no valid from string.  */
1862     return;
1863
1864   result = (struct translit_t *) obstack_alloc (ob,
1865                                                 sizeof (struct translit_t));
1866   result->from = from_wstr;
1867   result->fname = ldfile->fname;
1868   result->lineno = ldfile->lineno;
1869   result->next = NULL;
1870   result->to = NULL;
1871   top = &result->to;
1872   first = 1;
1873   ignore = 0;
1874
1875   while (1)
1876     {
1877       uint32_t *to_wstr;
1878
1879       /* Next we have one or more transliterations.  They are
1880          separated by semicolons.  */
1881       now = lr_token (ldfile, charmap, repertoire);
1882
1883       if (!first && (now->tok == tok_semicolon || now->tok == tok_eol))
1884         {
1885           /* One string read.  */
1886           const uint32_t zero = 0;
1887
1888           if (!ignore)
1889             {
1890               obstack_grow (ob, &zero, 4);
1891               to_wstr = obstack_finish (ob);
1892
1893               *top = obstack_alloc (ob, sizeof (struct translit_to_t));
1894               (*top)->str = to_wstr;
1895               (*top)->next = NULL;
1896             }
1897
1898           if (now->tok == tok_eol)
1899             {
1900               result->next = ctype->translit;
1901               ctype->translit = result;
1902               return;
1903             }
1904
1905           if (!ignore)
1906             top = &(*top)->next;
1907           ignore = 0;
1908         }
1909       else
1910         {
1911           to_wstr = read_widestring (ldfile, now, charmap, repertoire);
1912           if (to_wstr == (uint32_t *) -1l)
1913             {
1914               /* An error occurred.  */
1915               obstack_free (ob, result);
1916               return;
1917             }
1918
1919           if (to_wstr == NULL)
1920             ignore = 1;
1921           else
1922             /* This value is usable.  */
1923             obstack_grow (ob, to_wstr, wcslen ((wchar_t *) to_wstr) * 4);
1924
1925           first = 0;
1926         }
1927     }
1928 }
1929
1930
1931 static void
1932 read_translit_ignore_entry (struct linereader *ldfile,
1933                             struct locale_ctype_t *ctype,
1934                             struct charmap_t *charmap,
1935                             struct repertoire_t *repertoire)
1936 {
1937   /* We expect a semicolon-separated list of characters we ignore.  We are
1938      only interested in the wide character definitions.  These must be
1939      single characters, possibly defining a range when an ellipsis is used.  */
1940   while (1)
1941     {
1942       struct token *now = lr_token (ldfile, charmap, repertoire);
1943       struct translit_ignore_t *newp;
1944       uint32_t from;
1945
1946       if (now->tok == tok_eol || now->tok == tok_eof)
1947         {
1948           lr_error (ldfile,
1949                     _("premature end of `translit_ignore' definition"));
1950           return;
1951         }
1952
1953       if (now->tok != tok_bsymbol && now->tok != tok_ucs4)
1954         {
1955           lr_error (ldfile, _("syntax error"));
1956           lr_ignore_rest (ldfile, 0);
1957           return;
1958         }
1959
1960       if (now->tok == tok_ucs4)
1961         from = now->val.ucs4;
1962       else
1963         /* Try to get the value.  */
1964         from = repertoire_find_value (repertoire, now->val.str.startmb,
1965                                       now->val.str.lenmb);
1966
1967       if (from == ILLEGAL_CHAR_VALUE)
1968         {
1969           lr_error (ldfile, "invalid character name");
1970           newp = NULL;
1971         }
1972       else
1973         {
1974           newp = (struct translit_ignore_t *)
1975             obstack_alloc (&ctype->mempool, sizeof (struct translit_ignore_t));
1976           newp->from = from;
1977           newp->to = from;
1978           newp->step = 1;
1979
1980           newp->next = ctype->translit_ignore;
1981           ctype->translit_ignore = newp;
1982         }
1983
1984       /* Now we expect either a semicolon, an ellipsis, or the end of the
1985          line.  */
1986       now = lr_token (ldfile, charmap, repertoire);
1987
1988       if (now->tok == tok_ellipsis2 || now->tok == tok_ellipsis2_2)
1989         {
1990           /* XXX Should we bother implementing `....'?  `...' certainly
1991              will not be implemented.  */
1992           uint32_t to;
1993           int step = now->tok == tok_ellipsis2_2 ? 2 : 1;
1994
1995           now = lr_token (ldfile, charmap, repertoire);
1996
1997           if (now->tok == tok_eol || now->tok == tok_eof)
1998             {
1999               lr_error (ldfile,
2000                         _("premature end of `translit_ignore' definition"));
2001               return;
2002             }
2003
2004           if (now->tok != tok_bsymbol && now->tok != tok_ucs4)
2005             {
2006               lr_error (ldfile, _("syntax error"));
2007               lr_ignore_rest (ldfile, 0);
2008               return;
2009             }
2010
2011           if (now->tok == tok_ucs4)
2012             to = now->val.ucs4;
2013           else
2014             /* Try to get the value.  */
2015             to = repertoire_find_value (repertoire, now->val.str.startmb,
2016                                         now->val.str.lenmb);
2017
2018           if (to == ILLEGAL_CHAR_VALUE)
2019             lr_error (ldfile, "invalid character name");
2020           else
2021             {
2022               /* Make sure the `to'-value is larger.  */
2023               if (to >= from)
2024                 {
2025                   newp->to = to;
2026                   newp->step = step;
2027                 }
2028               else
2029                 lr_error (ldfile, _("\
2030 to-value <U%0*X> of range is smaller than from-value <U%0*X>"),
2031                           (to | from) < 65536 ? 4 : 8, to,
2032                           (to | from) < 65536 ? 4 : 8, from);
2033             }
2034
2035           /* And the next token.  */
2036           now = lr_token (ldfile, charmap, repertoire);
2037         }
2038
2039       if (now->tok == tok_eol || now->tok == tok_eof)
2040         /* We are done.  */
2041         return;
2042
2043       if (now->tok == tok_semicolon)
2044         /* Next round.  */
2045         continue;
2046
2047       /* If we come here something is wrong.  */
2048       lr_error (ldfile, _("syntax error"));
2049       lr_ignore_rest (ldfile, 0);
2050       return;
2051     }
2052 }
2053
2054
2055 /* The parser for the LC_CTYPE section of the locale definition.  */
2056 void
2057 ctype_read (struct linereader *ldfile, struct localedef_t *result,
2058             struct charmap_t *charmap, const char *repertoire_name,
2059             int ignore_content)
2060 {
2061   struct repertoire_t *repertoire = NULL;
2062   struct locale_ctype_t *ctype;
2063   struct token *now;
2064   enum token_t nowtok;
2065   size_t cnt;
2066   struct charseq *last_seq;
2067   uint32_t last_wch = 0;
2068   enum token_t last_token;
2069   enum token_t ellipsis_token;
2070   int step;
2071   char last_charcode[16];
2072   size_t last_charcode_len = 0;
2073   const char *last_str = NULL;
2074   int mapidx;
2075   struct localedef_t *copy_locale = NULL;
2076
2077   /* Get the repertoire we have to use.  */
2078   if (repertoire_name != NULL)
2079     repertoire = repertoire_read (repertoire_name);
2080
2081   /* The rest of the line containing `LC_CTYPE' must be free.  */
2082   lr_ignore_rest (ldfile, 1);
2083
2084
2085   do
2086     {
2087       now = lr_token (ldfile, charmap, NULL);
2088       nowtok = now->tok;
2089     }
2090   while (nowtok == tok_eol);
2091
2092   /* If we see `copy' now we are almost done.  */
2093   if (nowtok == tok_copy)
2094     {
2095       now = lr_token (ldfile, charmap, NULL);
2096       if (now->tok != tok_string)
2097         {
2098           SYNTAX_ERROR (_("%s: syntax error"), "LC_CTYPE");
2099
2100         skip_category:
2101           do
2102             now = lr_token (ldfile, charmap, NULL);
2103           while (now->tok != tok_eof && now->tok != tok_end);
2104
2105           if (now->tok != tok_eof
2106               || (now = lr_token (ldfile, charmap, NULL), now->tok == tok_eof))
2107             lr_error (ldfile, _("%s: premature end of file"), "LC_CTYPE");
2108           else if (now->tok != tok_lc_ctype)
2109             {
2110               lr_error (ldfile, _("\
2111 %1$s: definition does not end with `END %1$s'"), "LC_CTYPE");
2112               lr_ignore_rest (ldfile, 0);
2113             }
2114           else
2115             lr_ignore_rest (ldfile, 1);
2116
2117           return;
2118         }
2119
2120       if (! ignore_content)
2121         {
2122           /* Get the locale definition.  */
2123           copy_locale = load_locale (LC_CTYPE, now->val.str.startmb,
2124                                      repertoire_name, charmap, NULL);
2125           if ((copy_locale->avail & CTYPE_LOCALE) == 0)
2126             {
2127               /* Not yet loaded.  So do it now.  */
2128               if (locfile_read (copy_locale, charmap) != 0)
2129                 goto skip_category;
2130             }
2131         }
2132
2133       lr_ignore_rest (ldfile, 1);
2134
2135       now = lr_token (ldfile, charmap, NULL);
2136       nowtok = now->tok;
2137     }
2138
2139   /* Prepare the data structures.  */
2140   ctype_startup (ldfile, result, charmap, copy_locale, ignore_content);
2141   ctype = result->categories[LC_CTYPE].ctype;
2142
2143   /* Remember the repertoire we use.  */
2144   if (!ignore_content)
2145     ctype->repertoire = repertoire;
2146
2147   while (1)
2148     {
2149       unsigned long int class_bit = 0;
2150       unsigned long int class256_bit = 0;
2151       int handle_digits = 0;
2152
2153       /* Of course we don't proceed beyond the end of file.  */
2154       if (nowtok == tok_eof)
2155         break;
2156
2157       /* Ingore empty lines.  */
2158       if (nowtok == tok_eol)
2159         {
2160           now = lr_token (ldfile, charmap, NULL);
2161           nowtok = now->tok;
2162           continue;
2163         }
2164
2165       switch (nowtok)
2166         {
2167         case tok_charclass:
2168           now = lr_token (ldfile, charmap, NULL);
2169           while (now->tok == tok_ident || now->tok == tok_string)
2170             {
2171               ctype_class_new (ldfile, ctype, now->val.str.startmb);
2172               now = lr_token (ldfile, charmap, NULL);
2173               if (now->tok != tok_semicolon)
2174                 break;
2175               now = lr_token (ldfile, charmap, NULL);
2176             }
2177           if (now->tok != tok_eol)
2178             SYNTAX_ERROR (_("\
2179 %s: syntax error in definition of new character class"), "LC_CTYPE");
2180           break;
2181
2182         case tok_charconv:
2183           now = lr_token (ldfile, charmap, NULL);
2184           while (now->tok == tok_ident || now->tok == tok_string)
2185             {
2186               ctype_map_new (ldfile, ctype, now->val.str.startmb, charmap);
2187               now = lr_token (ldfile, charmap, NULL);
2188               if (now->tok != tok_semicolon)
2189                 break;
2190               now = lr_token (ldfile, charmap, NULL);
2191             }
2192           if (now->tok != tok_eol)
2193             SYNTAX_ERROR (_("\
2194 %s: syntax error in definition of new character map"), "LC_CTYPE");
2195           break;
2196
2197         case tok_class:
2198           /* Ignore the rest of the line if we don't need the input of
2199              this line.  */
2200           if (ignore_content)
2201             {
2202               lr_ignore_rest (ldfile, 0);
2203               break;
2204             }
2205
2206           /* We simply forget the `class' keyword and use the following
2207              operand to determine the bit.  */
2208           now = lr_token (ldfile, charmap, NULL);
2209           if (now->tok == tok_ident || now->tok == tok_string)
2210             {
2211               /* Must can be one of the predefined class names.  */
2212               for (cnt = 0; cnt < ctype->nr_charclass; ++cnt)
2213                 if (strcmp (ctype->classnames[cnt], now->val.str.startmb) == 0)
2214                   break;
2215               if (cnt >= ctype->nr_charclass)
2216                 {
2217 #ifdef PREDEFINED_CLASSES
2218                   if (now->val.str.lenmb == 8
2219                       && memcmp ("special1", now->val.str.startmb, 8) == 0)
2220                     class_bit = _ISwspecial1;
2221                   else if (now->val.str.lenmb == 8
2222                       && memcmp ("special2", now->val.str.startmb, 8) == 0)
2223                     class_bit = _ISwspecial2;
2224                   else if (now->val.str.lenmb == 8
2225                       && memcmp ("special3", now->val.str.startmb, 8) == 0)
2226                     class_bit = _ISwspecial3;
2227                   else
2228 #endif
2229                     {
2230                       /* OK, it's a new class.  */
2231                       ctype_class_new (ldfile, ctype, now->val.str.startmb);
2232
2233                       class_bit = _ISwbit (ctype->nr_charclass - 1);
2234                     }
2235                 }
2236               else
2237                 {
2238                   class_bit = _ISwbit (cnt);
2239
2240                   free (now->val.str.startmb);
2241                 }
2242             }
2243           else if (now->tok == tok_digit)
2244             goto handle_tok_digit;
2245           else if (now->tok < tok_upper || now->tok > tok_blank)
2246             goto err_label;
2247           else
2248             {
2249               class_bit = BITw (now->tok);
2250               class256_bit = BIT (now->tok);
2251             }
2252
2253           /* The next character must be a semicolon.  */
2254           now = lr_token (ldfile, charmap, NULL);
2255           if (now->tok != tok_semicolon)
2256             goto err_label;
2257           goto read_charclass;
2258
2259         case tok_upper:
2260         case tok_lower:
2261         case tok_alpha:
2262         case tok_alnum:
2263         case tok_space:
2264         case tok_cntrl:
2265         case tok_punct:
2266         case tok_graph:
2267         case tok_print:
2268         case tok_xdigit:
2269         case tok_blank:
2270           /* Ignore the rest of the line if we don't need the input of
2271              this line.  */
2272           if (ignore_content)
2273             {
2274               lr_ignore_rest (ldfile, 0);
2275               break;
2276             }
2277
2278           class_bit = BITw (now->tok);
2279           class256_bit = BIT (now->tok);
2280           handle_digits = 0;
2281         read_charclass:
2282           ctype->class_done |= class_bit;
2283           last_token = tok_none;
2284           ellipsis_token = tok_none;
2285           step = 1;
2286           now = lr_token (ldfile, charmap, NULL);
2287           while (now->tok != tok_eol && now->tok != tok_eof)
2288             {
2289               uint32_t wch;
2290               struct charseq *seq;
2291
2292               if (ellipsis_token == tok_none)
2293                 {
2294                   if (get_character (now, charmap, repertoire, &seq, &wch))
2295                     goto err_label;
2296
2297                   if (!ignore_content && seq != NULL && seq->nbytes == 1)
2298                     /* Yep, we can store information about this byte
2299                        sequence.  */
2300                     ctype->class256_collection[seq->bytes[0]] |= class256_bit;
2301
2302                   if (!ignore_content && wch != ILLEGAL_CHAR_VALUE
2303                       && class_bit != 0)
2304                     /* We have the UCS4 position.  */
2305                     *find_idx (ctype, &ctype->class_collection,
2306                                &ctype->class_collection_max,
2307                                &ctype->class_collection_act, wch) |= class_bit;
2308
2309                   last_token = now->tok;
2310                   /* Terminate the string.  */
2311                   if (last_token == tok_bsymbol)
2312                     {
2313                       now->val.str.startmb[now->val.str.lenmb] = '\0';
2314                       last_str = now->val.str.startmb;
2315                     }
2316                   else
2317                     last_str = NULL;
2318                   last_seq = seq;
2319                   last_wch = wch;
2320                   memcpy (last_charcode, now->val.charcode.bytes, 16);
2321                   last_charcode_len = now->val.charcode.nbytes;
2322
2323                   if (!ignore_content && handle_digits == 1)
2324                     {
2325                       /* We must store the digit values.  */
2326                       if (ctype->mbdigits_act == ctype->mbdigits_max)
2327                         {
2328                           ctype->mbdigits_max += 10;
2329                           ctype->mbdigits = xrealloc (ctype->mbdigits,
2330                                                       (ctype->mbdigits_max
2331                                                        * sizeof (char *)));
2332                           ctype->wcdigits_max += 10;
2333                           ctype->wcdigits = xrealloc (ctype->wcdigits,
2334                                                       (ctype->wcdigits_max
2335                                                        * sizeof (uint32_t)));
2336                         }
2337
2338                       ctype->mbdigits[ctype->mbdigits_act++] = seq;
2339                       ctype->wcdigits[ctype->wcdigits_act++] = wch;
2340                     }
2341                   else if (!ignore_content && handle_digits == 2)
2342                     {
2343                       /* We must store the digit values.  */
2344                       if (ctype->outdigits_act >= 10)
2345                         {
2346                           lr_error (ldfile, _("\
2347 %s: field `%s' does not contain exactly ten entries"),
2348                             "LC_CTYPE", "outdigit");
2349                           lr_ignore_rest (ldfile, 0);
2350                           break;
2351                         }
2352
2353                       ctype->mboutdigits[ctype->outdigits_act] = seq;
2354                       ctype->wcoutdigits[ctype->outdigits_act] = wch;
2355                       ++ctype->outdigits_act;
2356                     }
2357                 }
2358               else
2359                 {
2360                   /* Now it gets complicated.  We have to resolve the
2361                      ellipsis problem.  First we must distinguish between
2362                      the different kind of ellipsis and this must match the
2363                      tokens we have seen.  */
2364                   assert (last_token != tok_none);
2365
2366                   if (last_token != now->tok)
2367                     {
2368                       lr_error (ldfile, _("\
2369 ellipsis range must be marked by two operands of same type"));
2370                       lr_ignore_rest (ldfile, 0);
2371                       break;
2372                     }
2373
2374                   if (last_token == tok_bsymbol)
2375                     {
2376                       if (ellipsis_token == tok_ellipsis3)
2377                         lr_error (ldfile, _("with symbolic name range values \
2378 the absolute ellipsis `...' must not be used"));
2379
2380                       charclass_symbolic_ellipsis (ldfile, ctype, charmap,
2381                                                    repertoire, now, last_str,
2382                                                    class256_bit, class_bit,
2383                                                    (ellipsis_token
2384                                                     == tok_ellipsis4
2385                                                     ? 10 : 16),
2386                                                    ignore_content,
2387                                                    handle_digits, step);
2388                     }
2389                   else if (last_token == tok_ucs4)
2390                     {
2391                       if (ellipsis_token != tok_ellipsis2)
2392                         lr_error (ldfile, _("\
2393 with UCS range values one must use the hexadecimal symbolic ellipsis `..'"));
2394
2395                       charclass_ucs4_ellipsis (ldfile, ctype, charmap,
2396                                                repertoire, now, last_wch,
2397                                                class256_bit, class_bit,
2398                                                ignore_content, handle_digits,
2399                                                step);
2400                     }
2401                   else
2402                     {
2403                       assert (last_token == tok_charcode);
2404
2405                       if (ellipsis_token != tok_ellipsis3)
2406                         lr_error (ldfile, _("\
2407 with character code range values one must use the absolute ellipsis `...'"));
2408
2409                       charclass_charcode_ellipsis (ldfile, ctype, charmap,
2410                                                    repertoire, now,
2411                                                    last_charcode,
2412                                                    last_charcode_len,
2413                                                    class256_bit, class_bit,
2414                                                    ignore_content,
2415                                                    handle_digits);
2416                     }
2417
2418                   /* Now we have used the last value.  */
2419                   last_token = tok_none;
2420                 }
2421
2422               /* Next we expect a semicolon or the end of the line.  */
2423               now = lr_token (ldfile, charmap, NULL);
2424               if (now->tok == tok_eol || now->tok == tok_eof)
2425                 break;
2426
2427               if (last_token != tok_none
2428                   && now->tok >= tok_ellipsis2 && now->tok <= tok_ellipsis4_2)
2429                 {
2430                   if (now->tok == tok_ellipsis2_2)
2431                     {
2432                       now->tok = tok_ellipsis2;
2433                       step = 2;
2434                     }
2435                   else if (now->tok == tok_ellipsis4_2)
2436                     {
2437                       now->tok = tok_ellipsis4;
2438                       step = 2;
2439                     }
2440
2441                   ellipsis_token = now->tok;
2442
2443                   now = lr_token (ldfile, charmap, NULL);
2444                   continue;
2445                 }
2446
2447               if (now->tok != tok_semicolon)
2448                 goto err_label;
2449
2450               /* And get the next character.  */
2451               now = lr_token (ldfile, charmap, NULL);
2452
2453               ellipsis_token = tok_none;
2454               step = 1;
2455             }
2456           break;
2457
2458         case tok_digit:
2459           /* Ignore the rest of the line if we don't need the input of
2460              this line.  */
2461           if (ignore_content)
2462             {
2463               lr_ignore_rest (ldfile, 0);
2464               break;
2465             }
2466
2467         handle_tok_digit:
2468           class_bit = _ISwdigit;
2469           class256_bit = _ISdigit;
2470           handle_digits = 1;
2471           goto read_charclass;
2472
2473         case tok_outdigit:
2474           /* Ignore the rest of the line if we don't need the input of
2475              this line.  */
2476           if (ignore_content)
2477             {
2478               lr_ignore_rest (ldfile, 0);
2479               break;
2480             }
2481
2482           if (ctype->outdigits_act != 0)
2483             lr_error (ldfile, _("\
2484 %s: field `%s' declared more than once"),
2485                       "LC_CTYPE", "outdigit");
2486           class_bit = 0;
2487           class256_bit = 0;
2488           handle_digits = 2;
2489           goto read_charclass;
2490
2491         case tok_toupper:
2492           /* Ignore the rest of the line if we don't need the input of
2493              this line.  */
2494           if (ignore_content)
2495             {
2496               lr_ignore_rest (ldfile, 0);
2497               break;
2498             }
2499
2500           mapidx = 0;
2501           goto read_mapping;
2502
2503         case tok_tolower:
2504           /* Ignore the rest of the line if we don't need the input of
2505              this line.  */
2506           if (ignore_content)
2507             {
2508               lr_ignore_rest (ldfile, 0);
2509               break;
2510             }
2511
2512           mapidx = 1;
2513           goto read_mapping;
2514
2515         case tok_map:
2516           /* Ignore the rest of the line if we don't need the input of
2517              this line.  */
2518           if (ignore_content)
2519             {
2520               lr_ignore_rest (ldfile, 0);
2521               break;
2522             }
2523
2524           /* We simply forget the `map' keyword and use the following
2525              operand to determine the mapping.  */
2526           now = lr_token (ldfile, charmap, NULL);
2527           if (now->tok == tok_ident || now->tok == tok_string)
2528             {
2529               size_t cnt;
2530
2531               for (cnt = 2; cnt < ctype->map_collection_nr; ++cnt)
2532                 if (strcmp (now->val.str.startmb, ctype->mapnames[cnt]) == 0)
2533                   break;
2534
2535               if (cnt < ctype->map_collection_nr)
2536                 free (now->val.str.startmb);
2537               else
2538                 /* OK, it's a new map.  */
2539                 ctype_map_new (ldfile, ctype, now->val.str.startmb, charmap);
2540
2541               mapidx = cnt;
2542             }
2543           else if (now->tok < tok_toupper || now->tok > tok_tolower)
2544             goto err_label;
2545           else
2546             mapidx = now->tok - tok_toupper;
2547
2548           now = lr_token (ldfile, charmap, NULL);
2549           /* This better should be a semicolon.  */
2550           if (now->tok != tok_semicolon)
2551             goto err_label;
2552
2553         read_mapping:
2554           /* Test whether this mapping was already defined.  */
2555           if (ctype->tomap_done[mapidx])
2556             {
2557               lr_error (ldfile, _("duplicated definition for mapping `%s'"),
2558                         ctype->mapnames[mapidx]);
2559               lr_ignore_rest (ldfile, 0);
2560               break;
2561             }
2562           ctype->tomap_done[mapidx] = 1;
2563
2564           now = lr_token (ldfile, charmap, NULL);
2565           while (now->tok != tok_eol && now->tok != tok_eof)
2566             {
2567               struct charseq *from_seq;
2568               uint32_t from_wch;
2569               struct charseq *to_seq;
2570               uint32_t to_wch;
2571
2572               /* Every pair starts with an opening brace.  */
2573               if (now->tok != tok_open_brace)
2574                 goto err_label;
2575
2576               /* Next comes the from-value.  */
2577               now = lr_token (ldfile, charmap, NULL);
2578               if (get_character (now, charmap, repertoire, &from_seq,
2579                                  &from_wch) != 0)
2580                 goto err_label;
2581
2582               /* The next is a comma.  */
2583               now = lr_token (ldfile, charmap, NULL);
2584               if (now->tok != tok_comma)
2585                 goto err_label;
2586
2587               /* And the other value.  */
2588               now = lr_token (ldfile, charmap, NULL);
2589               if (get_character (now, charmap, repertoire, &to_seq,
2590                                  &to_wch) != 0)
2591                 goto err_label;
2592
2593               /* And the last thing is the closing brace.  */
2594               now = lr_token (ldfile, charmap, NULL);
2595               if (now->tok != tok_close_brace)
2596                 goto err_label;
2597
2598               if (!ignore_content)
2599                 {
2600                   if (mapidx < 2 && from_seq != NULL && to_seq != NULL
2601                       && from_seq->nbytes == 1 && to_seq->nbytes == 1)
2602                     /* We can use this value.  */
2603                     ctype->map256_collection[mapidx][from_seq->bytes[0]]
2604                       = to_seq->bytes[0];
2605
2606                   if (from_wch != ILLEGAL_CHAR_VALUE
2607                       && to_wch != ILLEGAL_CHAR_VALUE)
2608                     /* Both correct values.  */
2609                     *find_idx (ctype, &ctype->map_collection[mapidx],
2610                                &ctype->map_collection_max[mapidx],
2611                                &ctype->map_collection_act[mapidx],
2612                                from_wch) = to_wch;
2613                 }
2614
2615               /* Now comes a semicolon or the end of the line/file.  */
2616               now = lr_token (ldfile, charmap, NULL);
2617               if (now->tok == tok_semicolon)
2618                 now = lr_token (ldfile, charmap, NULL);
2619             }
2620           break;
2621
2622         case tok_translit_start:
2623           /* Ignore the entire translit section with its peculiar syntax
2624              if we don't need the input.  */
2625           if (ignore_content)
2626             {
2627               do
2628                 {
2629                   lr_ignore_rest (ldfile, 0);
2630                   now = lr_token (ldfile, charmap, NULL);
2631                 }
2632               while (now->tok != tok_translit_end && now->tok != tok_eof);
2633
2634               if (now->tok == tok_eof)
2635                 lr_error (ldfile, _(\
2636 "%s: `translit_start' section does not end with `translit_end'"),
2637                           "LC_CTYPE");
2638
2639               break;
2640             }
2641
2642           /* The rest of the line better should be empty.  */
2643           lr_ignore_rest (ldfile, 1);
2644
2645           /* We count here the number of allocated entries in the `translit'
2646              array.  */
2647           cnt = 0;
2648
2649           ldfile->translate_strings = 1;
2650           ldfile->return_widestr = 1;
2651
2652           /* We proceed until we see the `translit_end' token.  */
2653           while (now = lr_token (ldfile, charmap, repertoire),
2654                  now->tok != tok_translit_end && now->tok != tok_eof)
2655             {
2656               if (now->tok == tok_eol)
2657                 /* Ignore empty lines.  */
2658                 continue;
2659
2660               if (now->tok == tok_include)
2661                 {
2662                   /* We have to include locale.  */
2663                   const char *locale_name;
2664                   const char *repertoire_name;
2665                   struct translit_include_t *include_stmt, **include_ptr;
2666
2667                   now = lr_token (ldfile, charmap, NULL);
2668                   /* This should be a string or an identifier.  In any
2669                      case something to name a locale.  */
2670                   if (now->tok != tok_string && now->tok != tok_ident)
2671                     {
2672                     translit_syntax:
2673                       lr_error (ldfile, _("%s: syntax error"), "LC_CTYPE");
2674                       lr_ignore_rest (ldfile, 0);
2675                       continue;
2676                     }
2677                   locale_name = now->val.str.startmb;
2678
2679                   /* Next should be a semicolon.  */
2680                   now = lr_token (ldfile, charmap, NULL);
2681                   if (now->tok != tok_semicolon)
2682                     goto translit_syntax;
2683
2684                   /* Now the repertoire name.  */
2685                   now = lr_token (ldfile, charmap, NULL);
2686                   if ((now->tok != tok_string && now->tok != tok_ident)
2687                       || now->val.str.startmb == NULL)
2688                     goto translit_syntax;
2689                   repertoire_name = now->val.str.startmb;
2690
2691                   /* Save the include statement for later processing.  */
2692                   include_stmt = (struct translit_include_t *)
2693                     xmalloc (sizeof (struct translit_include_t));
2694                   include_stmt->copy_locale = locale_name;
2695                   include_stmt->copy_repertoire = repertoire_name;
2696                   include_stmt->next = NULL;
2697
2698                   include_ptr = &ctype->translit_include;
2699                   while (*include_ptr != NULL)
2700                     include_ptr = &(*include_ptr)->next;
2701                   *include_ptr = include_stmt;
2702
2703                   /* The rest of the line must be empty.  */
2704                   lr_ignore_rest (ldfile, 1);
2705
2706                   /* Make sure the locale is read.  */
2707                   add_to_readlist (LC_CTYPE, locale_name, repertoire_name,
2708                                    1, NULL);
2709                   continue;
2710                 }
2711               else if (now->tok == tok_default_missing)
2712                 {
2713                   uint32_t *wstr;
2714
2715                   while (1)
2716                     {
2717                       /* We expect a single character or string as the
2718                          argument.  */
2719                       now = lr_token (ldfile, charmap, NULL);
2720                       wstr = read_widestring (ldfile, now, charmap,
2721                                               repertoire);
2722
2723                       if (wstr != NULL)
2724                         {
2725                           if (ctype->default_missing != NULL)
2726                             {
2727                               lr_error (ldfile, _("\
2728 %s: duplicate `default_missing' definition"), "LC_CTYPE");
2729                               error_at_line (0, 0, ctype->default_missing_file,
2730                                              ctype->default_missing_lineno,
2731                                              _("\
2732 previous definition was here"));
2733                             }
2734                           else
2735                             {
2736                               ctype->default_missing = wstr;
2737                               ctype->default_missing_file = ldfile->fname;
2738                               ctype->default_missing_lineno = ldfile->lineno;
2739                             }
2740                           /* We can have more entries, ignore them.  */
2741                           lr_ignore_rest (ldfile, 0);
2742                           break;
2743                         }
2744                       else if (wstr == (uint32_t *) -1l)
2745                         /* This was an syntax error.  */
2746                         break;
2747
2748                       /* Maybe there is another replacement we can use.  */
2749                       now = lr_token (ldfile, charmap, NULL);
2750                       if (now->tok == tok_eol || now->tok == tok_eof)
2751                         {
2752                           /* Nothing found.  We tell the user.  */
2753                           lr_error (ldfile, _("\
2754 %s: no representable `default_missing' definition found"), "LC_CTYPE");
2755                           break;
2756                         }
2757                       if (now->tok != tok_semicolon)
2758                         goto translit_syntax;
2759                     }
2760
2761                   continue;
2762                 }
2763               else if (now->tok == tok_translit_ignore)
2764                 {
2765                   read_translit_ignore_entry (ldfile, ctype, charmap,
2766                                               repertoire);
2767                   continue;
2768                 }
2769
2770               read_translit_entry (ldfile, ctype, now, charmap, repertoire);
2771             }
2772           ldfile->return_widestr = 0;
2773
2774           if (now->tok == tok_eof)
2775             lr_error (ldfile, _(\
2776 "%s: `translit_start' section does not end with `translit_end'"),
2777                       "LC_CTYPE");
2778
2779           break;
2780
2781         case tok_ident:
2782           /* Ignore the rest of the line if we don't need the input of
2783              this line.  */
2784           if (ignore_content)
2785             {
2786               lr_ignore_rest (ldfile, 0);
2787               break;
2788             }
2789
2790           /* This could mean one of several things.  First test whether
2791              it's a character class name.  */
2792           for (cnt = 0; cnt < ctype->nr_charclass; ++cnt)
2793             if (strcmp (now->val.str.startmb, ctype->classnames[cnt]) == 0)
2794               break;
2795           if (cnt < ctype->nr_charclass)
2796             {
2797               class_bit = _ISwbit (cnt);
2798               class256_bit = cnt <= 11 ? _ISbit (cnt) : 0;
2799               free (now->val.str.startmb);
2800               goto read_charclass;
2801             }
2802           for (cnt = 0; cnt < ctype->map_collection_nr; ++cnt)
2803             if (strcmp (now->val.str.startmb, ctype->mapnames[cnt]) == 0)
2804               break;
2805           if (cnt < ctype->map_collection_nr)
2806             {
2807               mapidx = cnt;
2808               free (now->val.str.startmb);
2809               goto read_mapping;
2810             }
2811 #ifdef PREDEFINED_CLASSES
2812           if (strcmp (now->val.str.startmb, "special1") == 0)
2813             {
2814               class_bit = _ISwspecial1;
2815               free (now->val.str.startmb);
2816               goto read_charclass;
2817             }
2818           if (strcmp (now->val.str.startmb, "special2") == 0)
2819             {
2820               class_bit = _ISwspecial2;
2821               free (now->val.str.startmb);
2822               goto read_charclass;
2823             }
2824           if (strcmp (now->val.str.startmb, "special3") == 0)
2825             {
2826               class_bit = _ISwspecial3;
2827               free (now->val.str.startmb);
2828               goto read_charclass;
2829             }
2830           if (strcmp (now->val.str.startmb, "tosymmetric") == 0)
2831             {
2832               mapidx = 2;
2833               goto read_mapping;
2834             }
2835 #endif
2836           break;
2837
2838         case tok_end:
2839           /* Next we assume `LC_CTYPE'.  */
2840           now = lr_token (ldfile, charmap, NULL);
2841           if (now->tok == tok_eof)
2842             break;
2843           if (now->tok == tok_eol)
2844             lr_error (ldfile, _("%s: incomplete `END' line"),
2845                       "LC_CTYPE");
2846           else if (now->tok != tok_lc_ctype)
2847             lr_error (ldfile, _("\
2848 %1$s: definition does not end with `END %1$s'"), "LC_CTYPE");
2849           lr_ignore_rest (ldfile, now->tok == tok_lc_ctype);
2850           return;
2851
2852         default:
2853         err_label:
2854           if (now->tok != tok_eof)
2855             SYNTAX_ERROR (_("%s: syntax error"), "LC_CTYPE");
2856         }
2857
2858       /* Prepare for the next round.  */
2859       now = lr_token (ldfile, charmap, NULL);
2860       nowtok = now->tok;
2861     }
2862
2863   /* When we come here we reached the end of the file.  */
2864   lr_error (ldfile, _("%s: premature end of file"), "LC_CTYPE");
2865 }
2866
2867
2868 static void
2869 set_class_defaults (struct locale_ctype_t *ctype, struct charmap_t *charmap,
2870                     struct repertoire_t *repertoire)
2871 {
2872   size_t cnt;
2873
2874   /* These function defines the default values for the classes and conversions
2875      according to POSIX.2 2.5.2.1.
2876      It may seem that the order of these if-blocks is arbitrary but it is NOT.
2877      Don't move them unless you know what you do!  */
2878
2879   auto void set_default (int bitpos, int from, int to);
2880
2881   void set_default (int bitpos, int from, int to)
2882     {
2883       char tmp[2];
2884       int ch;
2885       int bit = _ISbit (bitpos);
2886       int bitw = _ISwbit (bitpos);
2887       /* Define string.  */
2888       strcpy (tmp, "?");
2889
2890       for (ch = from; ch <= to; ++ch)
2891         {
2892           struct charseq *seq;
2893           tmp[0] = ch;
2894
2895           seq = charmap_find_value (charmap, tmp, 1);
2896           if (seq == NULL)
2897             {
2898               char buf[10];
2899               sprintf (buf, "U%08X", ch);
2900               seq = charmap_find_value (charmap, buf, 9);
2901             }
2902           if (seq == NULL)
2903             {
2904               if (!be_quiet)
2905                 error (0, 0, _("\
2906 %s: character `%s' not defined in charmap while needed as default value"),
2907                        "LC_CTYPE", tmp);
2908             }
2909           else if (seq->nbytes != 1)
2910             error (0, 0, _("\
2911 %s: character `%s' in charmap not representable with one byte"),
2912                    "LC_CTYPE", tmp);
2913           else
2914             ctype->class256_collection[seq->bytes[0]] |= bit;
2915
2916           /* No need to search here, the ASCII value is also the Unicode
2917              value.  */
2918           ELEM (ctype, class_collection, , ch) |= bitw;
2919         }
2920     }
2921
2922   /* Set default values if keyword was not present.  */
2923   if ((ctype->class_done & BITw (tok_upper)) == 0)
2924     /* "If this keyword [lower] is not specified, the lowercase letters
2925         `A' through `Z', ..., shall automatically belong to this class,
2926         with implementation defined character values."  [P1003.2, 2.5.2.1]  */
2927     set_default (BITPOS (tok_upper), 'A', 'Z');
2928
2929   if ((ctype->class_done & BITw (tok_lower)) == 0)
2930     /* "If this keyword [lower] is not specified, the lowercase letters
2931         `a' through `z', ..., shall automatically belong to this class,
2932         with implementation defined character values."  [P1003.2, 2.5.2.1]  */
2933     set_default (BITPOS (tok_lower), 'a', 'z');
2934
2935   if ((ctype->class_done & BITw (tok_alpha)) == 0)
2936     {
2937       /* Table 2-6 in P1003.2 says that characters in class `upper' or
2938          class `lower' *must* be in class `alpha'.  */
2939       unsigned long int mask = BIT (tok_upper) | BIT (tok_lower);
2940       unsigned long int maskw = BITw (tok_upper) | BITw (tok_lower);
2941
2942       for (cnt = 0; cnt < 256; ++cnt)
2943         if ((ctype->class256_collection[cnt] & mask) != 0)
2944           ctype->class256_collection[cnt] |= BIT (tok_alpha);
2945
2946       for (cnt = 0; cnt < ctype->class_collection_act; ++cnt)
2947         if ((ctype->class_collection[cnt] & maskw) != 0)
2948           ctype->class_collection[cnt] |= BITw (tok_alpha);
2949     }
2950
2951   if ((ctype->class_done & BITw (tok_digit)) == 0)
2952     /* "If this keyword [digit] is not specified, the digits `0' through
2953         `9', ..., shall automatically belong to this class, with
2954         implementation-defined character values."  [P1003.2, 2.5.2.1]  */
2955     set_default (BITPOS (tok_digit), '0', '9');
2956
2957   /* "Only characters specified for the `alpha' and `digit' keyword
2958      shall be specified.  Characters specified for the keyword `alpha'
2959      and `digit' are automatically included in this class.  */
2960   {
2961     unsigned long int mask = BIT (tok_alpha) | BIT (tok_digit);
2962     unsigned long int maskw = BITw (tok_alpha) | BITw (tok_digit);
2963
2964     for (cnt = 0; cnt < 256; ++cnt)
2965       if ((ctype->class256_collection[cnt] & mask) != 0)
2966         ctype->class256_collection[cnt] |= BIT (tok_alnum);
2967
2968     for (cnt = 0; cnt < ctype->class_collection_act; ++cnt)
2969       if ((ctype->class_collection[cnt] & maskw) != 0)
2970         ctype->class_collection[cnt] |= BITw (tok_alnum);
2971   }
2972
2973   if ((ctype->class_done & BITw (tok_space)) == 0)
2974     /* "If this keyword [space] is not specified, the characters <space>,
2975         <form-feed>, <newline>, <carriage-return>, <tab>, and
2976         <vertical-tab>, ..., shall automatically belong to this class,
2977         with implementation-defined character values."  [P1003.2, 2.5.2.1]  */
2978     {
2979       struct charseq *seq;
2980
2981       seq = charmap_find_value (charmap, "space", 5);
2982       if (seq == NULL)
2983         seq = charmap_find_value (charmap, "SP", 2);
2984       if (seq == NULL)
2985         seq = charmap_find_value (charmap, "U00000020", 9);
2986       if (seq == NULL)
2987         {
2988           if (!be_quiet)
2989             error (0, 0, _("\
2990 %s: character `%s' not defined while needed as default value"),
2991                    "LC_CTYPE", "<space>");
2992         }
2993       else if (seq->nbytes != 1)
2994         error (0, 0, _("\
2995 %s: character `%s' in charmap not representable with one byte"),
2996                "LC_CTYPE", "<space>");
2997       else
2998         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_space);
2999
3000       /* No need to search.  */
3001       ELEM (ctype, class_collection, , L' ') |= BITw (tok_space);
3002
3003       seq = charmap_find_value (charmap, "form-feed", 9);
3004       if (seq == NULL)
3005         seq = charmap_find_value (charmap, "U0000000C", 9);
3006       if (seq == NULL)
3007         {
3008           if (!be_quiet)
3009             error (0, 0, _("\
3010 %s: character `%s' not defined while needed as default value"),
3011                    "LC_CTYPE", "<form-feed>");
3012         }
3013       else if (seq->nbytes != 1)
3014         error (0, 0, _("\
3015 %s: character `%s' in charmap not representable with one byte"),
3016                "LC_CTYPE", "<form-feed>");
3017       else
3018         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_space);
3019
3020       /* No need to search.  */
3021       ELEM (ctype, class_collection, , L'\f') |= BITw (tok_space);
3022
3023
3024       seq = charmap_find_value (charmap, "newline", 7);
3025       if (seq == NULL)
3026         seq = charmap_find_value (charmap, "U0000000A", 9);
3027       if (seq == NULL)
3028         {
3029           if (!be_quiet)
3030             error (0, 0, _("\
3031 character `%s' not defined while needed as default value"),
3032                    "<newline>");
3033         }
3034       else if (seq->nbytes != 1)
3035         error (0, 0, _("\
3036 %s: character `%s' in charmap not representable with one byte"),
3037                "LC_CTYPE", "<newline>");
3038       else
3039         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_space);
3040
3041       /* No need to search.  */
3042       ELEM (ctype, class_collection, , L'\n') |= BITw (tok_space);
3043
3044
3045       seq = charmap_find_value (charmap, "carriage-return", 15);
3046       if (seq == NULL)
3047         seq = charmap_find_value (charmap, "U0000000D", 9);
3048       if (seq == NULL)
3049         {
3050           if (!be_quiet)
3051             error (0, 0, _("\
3052 %s: character `%s' not defined while needed as default value"),
3053                    "LC_CTYPE", "<carriage-return>");
3054         }
3055       else if (seq->nbytes != 1)
3056         error (0, 0, _("\
3057 %s: character `%s' in charmap not representable with one byte"),
3058                "LC_CTYPE", "<carriage-return>");
3059       else
3060         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_space);
3061
3062       /* No need to search.  */
3063       ELEM (ctype, class_collection, , L'\r') |= BITw (tok_space);
3064
3065
3066       seq = charmap_find_value (charmap, "tab", 3);
3067       if (seq == NULL)
3068         seq = charmap_find_value (charmap, "U00000009", 9);
3069       if (seq == NULL)
3070         {
3071           if (!be_quiet)
3072             error (0, 0, _("\
3073 %s: character `%s' not defined while needed as default value"),
3074                    "LC_CTYPE", "<tab>");
3075         }
3076       else if (seq->nbytes != 1)
3077         error (0, 0, _("\
3078 %s: character `%s' in charmap not representable with one byte"),
3079                "LC_CTYPE", "<tab>");
3080       else
3081         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_space);
3082
3083       /* No need to search.  */
3084       ELEM (ctype, class_collection, , L'\t') |= BITw (tok_space);
3085
3086
3087       seq = charmap_find_value (charmap, "vertical-tab", 12);
3088       if (seq == NULL)
3089         seq = charmap_find_value (charmap, "U0000000B", 9);
3090       if (seq == NULL)
3091         {
3092           if (!be_quiet)
3093             error (0, 0, _("\
3094 %s: character `%s' not defined while needed as default value"),
3095                    "LC_CTYPE", "<vertical-tab>");
3096         }
3097       else if (seq->nbytes != 1)
3098         error (0, 0, _("\
3099 %s: character `%s' in charmap not representable with one byte"),
3100                "LC_CTYPE", "<vertical-tab>");
3101       else
3102         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_space);
3103
3104       /* No need to search.  */
3105       ELEM (ctype, class_collection, , L'\v') |= BITw (tok_space);
3106     }
3107
3108   if ((ctype->class_done & BITw (tok_xdigit)) == 0)
3109     /* "If this keyword is not specified, the digits `0' to `9', the
3110         uppercase letters `A' through `F', and the lowercase letters `a'
3111         through `f', ..., shell automatically belong to this class, with
3112         implementation defined character values."  [P1003.2, 2.5.2.1]  */
3113     {
3114       set_default (BITPOS (tok_xdigit), '0', '9');
3115       set_default (BITPOS (tok_xdigit), 'A', 'F');
3116       set_default (BITPOS (tok_xdigit), 'a', 'f');
3117     }
3118
3119   if ((ctype->class_done & BITw (tok_blank)) == 0)
3120     /* "If this keyword [blank] is unspecified, the characters <space> and
3121        <tab> shall belong to this character class."  [P1003.2, 2.5.2.1]  */
3122    {
3123       struct charseq *seq;
3124
3125       seq = charmap_find_value (charmap, "space", 5);
3126       if (seq == NULL)
3127         seq = charmap_find_value (charmap, "SP", 2);
3128       if (seq == NULL)
3129         seq = charmap_find_value (charmap, "U00000020", 9);
3130       if (seq == NULL)
3131         {
3132           if (!be_quiet)
3133             error (0, 0, _("\
3134 %s: character `%s' not defined while needed as default value"),
3135                    "LC_CTYPE", "<space>");
3136         }
3137       else if (seq->nbytes != 1)
3138         error (0, 0, _("\
3139 %s: character `%s' in charmap not representable with one byte"),
3140                "LC_CTYPE", "<space>");
3141       else
3142         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_blank);
3143
3144       /* No need to search.  */
3145       ELEM (ctype, class_collection, , L' ') |= BITw (tok_blank);
3146
3147
3148       seq = charmap_find_value (charmap, "tab", 3);
3149       if (seq == NULL)
3150         seq = charmap_find_value (charmap, "U00000009", 9);
3151       if (seq == NULL)
3152         {
3153           if (!be_quiet)
3154             error (0, 0, _("\
3155 %s: character `%s' not defined while needed as default value"),
3156                    "LC_CTYPE", "<tab>");
3157         }
3158       else if (seq->nbytes != 1)
3159         error (0, 0, _("\
3160 %s: character `%s' in charmap not representable with one byte"),
3161                "LC_CTYPE", "<tab>");
3162       else
3163         ctype->class256_collection[seq->bytes[0]] |= BIT (tok_blank);
3164
3165       /* No need to search.  */
3166       ELEM (ctype, class_collection, , L'\t') |= BITw (tok_blank);
3167     }
3168
3169   if ((ctype->class_done & BITw (tok_graph)) == 0)
3170     /* "If this keyword [graph] is not specified, characters specified for
3171         the keywords `upper', `lower', `alpha', `digit', `xdigit' and `punct',
3172         shall belong to this character class."  [P1003.2, 2.5.2.1]  */
3173     {
3174       unsigned long int mask = BIT (tok_upper) | BIT (tok_lower) |
3175         BIT (tok_alpha) | BIT (tok_digit) | BIT (tok_xdigit) | BIT (tok_punct);
3176       unsigned long int maskw = BITw (tok_upper) | BITw (tok_lower) |
3177         BITw (tok_alpha) | BITw (tok_digit) | BITw (tok_xdigit) |
3178         BITw (tok_punct);
3179       size_t cnt;
3180
3181       for (cnt = 0; cnt < ctype->class_collection_act; ++cnt)
3182         if ((ctype->class_collection[cnt] & maskw) != 0)
3183           ctype->class_collection[cnt] |= BITw (tok_graph);
3184
3185       for (cnt = 0; cnt < 256; ++cnt)