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