Generate a Unicode conforming LC_CTYPE category from a UnicodeData file.
[kopensolaris-gnu/glibc.git] / localedata / gen-unicode-ctype.c
1 /* Generate a Unicode conforming LC_CTYPE category from a UnicodeData file.
2    Copyright (C) 2000 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Bruno Haible <haible@clisp.cons.org>, 2000.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU UTF-8 Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 /* Usage example:
22      $ gen-unicode /usr/local/share/Unidata/UnicodeData.txt \
23                    /usr/local/share/Unidata/PropList.txt \
24                    3.0
25  */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <stdbool.h>
30 #include <string.h>
31 #include <time.h>
32
33 /* This structure represents one line in the UnicodeData.txt file.  */
34 struct unicode_attribute
35 {
36   const char *name;           /* Character name */
37   const char *category;       /* General category */
38   const char *combining;      /* Canonical combining classes */
39   const char *bidi;           /* Bidirectional category */
40   const char *decomposition;  /* Character decomposition mapping */
41   const char *decdigit;       /* Decimal digit value */
42   const char *digit;          /* Digit value */
43   const char *numeric;        /* Numeric value */
44   int mirrored;               /* mirrored */
45   const char *oldname;        /* Old Unicode 1.0 name */
46   const char *comment;        /* Comment */
47   unsigned int upper;         /* Uppercase mapping */
48   unsigned int lower;         /* Lowercase mapping */
49   unsigned int title;         /* Titlecase mapping */
50 };
51
52 /* Missing fields are represented with "" for strings, and NONE for
53    characters.  */
54 #define NONE (~(unsigned int)0)
55
56 /* The entire contents of the UnicodeData.txt file.  */
57 struct unicode_attribute unicode_attributes [0x10000];
58
59 /* Stores in unicode_attributes[i] the values from the given fields.  */
60 static void
61 fill_attribute (unsigned int i,
62                 const char *field1, const char *field2,
63                 const char *field3, const char *field4,
64                 const char *field5, const char *field6,
65                 const char *field7, const char *field8,
66                 const char *field9, const char *field10,
67                 const char *field11, const char *field12,
68                 const char *field13, const char *field14)
69 {
70   struct unicode_attribute * uni;
71
72   if (i >= 0x10000)
73     {
74       fprintf (stderr, "index too large\n");
75       exit (1);
76     }
77   uni = &unicode_attributes[i];
78   /* Copy the strings.  */
79   uni->name          = strdup (field1);
80   uni->category      = (field2[0] == '\0' ? "" : strdup (field2));
81   uni->combining     = (field3[0] == '\0' ? "" : strdup (field3));
82   uni->bidi          = (field4[0] == '\0' ? "" : strdup (field4));
83   uni->decomposition = (field5[0] == '\0' ? "" : strdup (field5));
84   uni->decdigit      = (field6[0] == '\0' ? "" : strdup (field6));
85   uni->digit         = (field7[0] == '\0' ? "" : strdup (field7));
86   uni->numeric       = (field8[0] == '\0' ? "" : strdup (field8));
87   uni->mirrored      = (field9[0] == 'Y');
88   uni->oldname       = (field10[0] == '\0' ? "" : strdup (field10));
89   uni->comment       = (field11[0] == '\0' ? "" : strdup (field11));
90   uni->upper = (field12[0] =='\0' ? NONE : strtoul (field12, NULL, 16));
91   uni->lower = (field13[0] =='\0' ? NONE : strtoul (field13, NULL, 16));
92   uni->title = (field14[0] =='\0' ? NONE : strtoul (field14, NULL, 16));
93 }
94
95 /* Maximum length of a field in the UnicodeData.txt file.  */
96 #define FIELDLEN 120
97
98 /* Reads the next field from STREAM.  The buffer BUFFER has size FIELDLEN.
99    Reads up to (but excluding) DELIM.
100    Returns 1 when a field was successfully read, otherwise 0.  */
101 static int
102 getfield (FILE *stream, char *buffer, int delim)
103 {
104   int count = 0;
105   int c;
106
107   for (; (c = getc (stream)), (c != EOF && c != delim); )
108     {
109       /* The original unicode.org UnicodeData.txt file happens to have
110          CR/LF line terminators.  Silently convert to LF.  */
111       if (c == '\r')
112         continue;
113
114       /* Put c into the buffer.  */
115       if (++count >= FIELDLEN - 1)
116         {
117           fprintf (stderr, "field too long\n");
118           exit (1);
119         }
120       *buffer++ = c;
121     }
122
123   if (c == EOF)
124     return 0;
125
126   *buffer = '\0';
127   return 1;
128 }
129
130 /* Stores in unicode_attributes[] the entire contents of the UnicodeData.txt
131    file.  */
132 static void
133 fill_attributes (const char *unicodedata_filename)
134 {
135   unsigned int i, j;
136   FILE *stream;
137   char field0[FIELDLEN];
138   char field1[FIELDLEN];
139   char field2[FIELDLEN];
140   char field3[FIELDLEN];
141   char field4[FIELDLEN];
142   char field5[FIELDLEN];
143   char field6[FIELDLEN];
144   char field7[FIELDLEN];
145   char field8[FIELDLEN];
146   char field9[FIELDLEN];
147   char field10[FIELDLEN];
148   char field11[FIELDLEN];
149   char field12[FIELDLEN];
150   char field13[FIELDLEN];
151   char field14[FIELDLEN];
152   int lineno = 0;
153
154   for (i = 0; i < 0x10000; i++)
155     unicode_attributes[i].name = NULL;
156
157   stream = fopen (unicodedata_filename, "r");
158   if (stream == NULL)
159     {
160       fprintf (stderr, "error during fopen of '%s'\n", unicodedata_filename);
161       exit (1);
162     }
163
164   for (;;)
165     {
166       int n;
167
168       lineno++;
169       n = getfield(stream, field0, ';');
170       n += getfield(stream, field1, ';');
171       n += getfield(stream, field2, ';');
172       n += getfield(stream, field3, ';');
173       n += getfield(stream, field4, ';');
174       n += getfield(stream, field5, ';');
175       n += getfield(stream, field6, ';');
176       n += getfield(stream, field7, ';');
177       n += getfield(stream, field8, ';');
178       n += getfield(stream, field9, ';');
179       n += getfield(stream, field10, ';');
180       n += getfield(stream, field11, ';');
181       n += getfield(stream, field12, ';');
182       n += getfield(stream, field13, ';');
183       n += getfield(stream, field14, '\n');
184       if (n == 0)
185         break;
186       if (n != 15)
187         {
188           fprintf (stderr, "short line in'%s':%d\n",
189                    unicodedata_filename, lineno);
190           exit (1);
191         }
192       i = strtoul (field0, NULL, 16);
193       if (field1[0] == '<'
194           && strlen (field1) >= 9
195           && !strcmp (field1 + strlen(field1) - 8, ", First>"))
196         {
197           /* Deal with a range. */
198           lineno++;
199           n = getfield(stream, field0, ';');
200           n += getfield(stream, field1, ';');
201           n += getfield(stream, field2, ';');
202           n += getfield(stream, field3, ';');
203           n += getfield(stream, field4, ';');
204           n += getfield(stream, field5, ';');
205           n += getfield(stream, field6, ';');
206           n += getfield(stream, field7, ';');
207           n += getfield(stream, field8, ';');
208           n += getfield(stream, field9, ';');
209           n += getfield(stream, field10, ';');
210           n += getfield(stream, field11, ';');
211           n += getfield(stream, field12, ';');
212           n += getfield(stream, field13, ';');
213           n += getfield(stream, field14, '\n');
214           if (n != 15)
215             {
216               fprintf (stderr, "missing end range in '%s':%d\n",
217                        unicodedata_filename, lineno);
218               exit (1);
219             }
220           if (!(field1[0] == '<'
221                 && strlen (field1) >= 8
222                 && !strcmp (field1 + strlen (field1) - 7, ", Last>")))
223             {
224               fprintf (stderr, "missing end range in '%s':%d\n",
225                        unicodedata_filename, lineno);
226               exit (1);
227             }
228           field1[strlen (field1) - 7] = '\0';
229           j = strtoul (field0, NULL, 16);
230           for (; i <= j; i++)
231             fill_attribute (i, field1+1, field2, field3, field4, field5,
232                                field6, field7, field8, field9, field10,
233                                field11, field12, field13, field14);
234         }
235       else
236         {
237           /* Single character line */
238           fill_attribute (i, field1, field2, field3, field4, field5,
239                              field6, field7, field8, field9, field10,
240                              field11, field12, field13, field14);
241         }
242     }
243   if (ferror (stream) || fclose (stream))
244     {
245       fprintf (stderr, "error reading from '%s'\n", unicodedata_filename);
246       exit (1);
247     }
248 }
249
250 /* The combining property from the PropList.txt file.  */
251 char unicode_combining[0x10000];
252
253 /* Stores in unicode_combining[] the Combining property from the
254    PropList.txt file.  */
255 static void
256 fill_combining (const char *proplist_filename)
257 {
258   unsigned int i;
259   FILE *stream;
260   char buf[100+1];
261
262   for (i = 0; i < 0x10000; i++)
263     unicode_combining[i] = 0;
264
265   stream = fopen (proplist_filename, "r");
266   if (stream == NULL)
267     {
268       fprintf (stderr, "error during fopen of '%s'\n", proplist_filename);
269       exit (1);
270     }
271
272   /* Search for the "Property dump for: 0x20000004 (Combining)" line.  */
273   do
274     {
275       if (fscanf (stream, "%100[^\n]\n", buf) < 1)
276         {
277           fprintf (stderr, "no combining property found in '%s'\n",
278                    proplist_filename);
279           exit (1);
280         }
281     }
282   while (strstr (buf, "(Combining)") == NULL);
283
284   for (;;)
285     {
286       unsigned int i1, i2;
287
288       if (fscanf (stream, "%100[^\n]\n", buf) < 1)
289         {
290           fprintf (stderr, "premature end of combining property in '%s'\n",
291                    proplist_filename);
292           exit (1);
293         }
294       if (buf[0] == '*')
295         break;
296       if (strlen (buf) >= 10 && buf[4] == '.' && buf[5] == '.')
297         {
298           if (sscanf (buf, "%4X..%4X", &i1, &i2) < 2)
299             {
300               fprintf (stderr, "parse error in combining property in '%s'\n",
301                        proplist_filename);
302               exit (1);
303             }
304         }
305       else if (strlen (buf) >= 4)
306         {
307           if (sscanf (buf, "%4X", &i1) < 1)
308             {
309               fprintf (stderr, "parse error in combining property in '%s'\n",
310                        proplist_filename);
311               exit (1);
312             }
313           i2 = i1;
314         }
315       else
316         {
317           fprintf (stderr, "parse error in combining property in '%s'\n",
318                    proplist_filename);
319           exit (1);
320         }
321       for (i = i1; i <= i2; i++)
322         unicode_combining[i] = 1;
323     }
324   if (ferror (stream) || fclose (stream))
325     {
326       fprintf (stderr, "error reading from '%s'\n", proplist_filename);
327       exit (1);
328     }
329 }
330
331 /* Character mappings.  */
332
333 static unsigned int
334 to_upper (unsigned int ch)
335 {
336   if (unicode_attributes[ch].name != NULL
337       && unicode_attributes[ch].upper != NONE)
338     return unicode_attributes[ch].upper;
339   else
340     return ch;
341 }
342
343 static unsigned int
344 to_lower (unsigned int ch)
345 {
346   if (unicode_attributes[ch].name != NULL
347       && unicode_attributes[ch].lower != NONE)
348     return unicode_attributes[ch].lower;
349   else
350     return ch;
351 }
352
353 static unsigned int
354 to_title (unsigned int ch)
355 {
356   if (unicode_attributes[ch].name != NULL
357       && unicode_attributes[ch].title != NONE)
358     return unicode_attributes[ch].title;
359   else
360     return ch;
361 }
362
363 /* Character class properties.  */
364
365 static bool
366 is_upper (unsigned int ch)
367 {
368   return (to_lower (ch) != ch);
369 }
370
371 static bool
372 is_lower (unsigned int ch)
373 {
374   return (to_upper (ch) != ch)
375          /* <U00DF> is lowercase, but without simple to_upper mapping.  */
376          || (ch == 0x00DF);
377 }
378
379 static bool
380 is_alpha (unsigned int ch)
381 {
382   return (unicode_attributes[ch].name != NULL
383           && (unicode_attributes[ch].category[0] == 'L'
384               /* Avoid warning for <U0345>.  */
385               || (ch == 0x0345)
386               /* Avoid warnings for <U2160>..<U217F>.  */
387               || (unicode_attributes[ch].category[0] == 'N'
388                   && unicode_attributes[ch].category[1] == 'l')
389               /* Avoid warnings for <U24B6>..<U24E9>.  */
390               || (unicode_attributes[ch].category[0] == 'S'
391                   && unicode_attributes[ch].category[1] == 'o'
392                   && strstr (unicode_attributes[ch].name, " LETTER ")
393                      != NULL)));
394 }
395
396 static bool
397 is_digit (unsigned int ch)
398 {
399   return (unicode_attributes[ch].name != NULL
400           && unicode_attributes[ch].category[0] == 'N'
401           && unicode_attributes[ch].category[1] == 'd');
402   /* Note: U+0BE7..U+0BEF and U+1369..U+1371 are digit systems without
403      a zero.  Must add <0> in front of them by hand.  */
404 }
405
406 static bool
407 is_outdigit (unsigned int ch)
408 {
409   return (ch >= 0x0030 && ch <= 0x0039);
410 }
411
412 static bool
413 is_blank (unsigned int ch)
414 {
415   return (ch == 0x0009 /* '\t' */
416           /* Category Zs without mention of "<noBreak>" */
417           || (unicode_attributes[ch].name != NULL
418               && unicode_attributes[ch].category[0] == 'Z'
419               && unicode_attributes[ch].category[1] == 's'
420               && !strstr (unicode_attributes[ch].decomposition, "<noBreak>")));
421 }
422
423 static bool
424 is_space (unsigned int ch)
425 {
426   /* Don't make U+00A0 a space. Non-breaking space means that all programs
427      should treat it like a punctuation character, not like a space. */
428   return (ch == 0x0020 /* ' ' */
429           || ch == 0x000C /* '\f' */
430           || ch == 0x000A /* '\n' */
431           || ch == 0x000D /* '\r' */
432           || ch == 0x0009 /* '\t' */
433           || ch == 0x000B /* '\v' */
434           /* Categories Zl, Zp, and Zs without mention of "<noBreak>" */
435           || (unicode_attributes[ch].name != NULL
436               && unicode_attributes[ch].category[0] == 'Z'
437               && (unicode_attributes[ch].category[1] == 'l'
438                   || unicode_attributes[ch].category[1] == 'p'
439                   || (unicode_attributes[ch].category[1] == 's'
440                       && !strstr (unicode_attributes[ch].decomposition,
441                                   "<noBreak>")))));
442 }
443
444 static bool
445 is_cntrl (unsigned int ch)
446 {
447   return (unicode_attributes[ch].name != NULL
448           && (!strcmp (unicode_attributes[ch].name, "<control>")
449               /* Categories Zl and Zp */
450               || (unicode_attributes[ch].category[0] == 'Z'
451                   && (unicode_attributes[ch].category[1] == 'l'
452                       || unicode_attributes[ch].category[1] == 'p'))));
453 }
454
455 static bool
456 is_xdigit (unsigned int ch)
457 {
458   return is_digit (ch)
459          || (ch >= 0x0041 && ch <= 0x0046)
460          || (ch >= 0x0061 && ch <= 0x0066);
461 }
462
463 static bool
464 is_graph (unsigned int ch)
465 {
466   return (unicode_attributes[ch].name != NULL
467           && strcmp (unicode_attributes[ch].name, "<control>")
468           && !is_space (ch));
469 }
470
471 static bool
472 is_print (unsigned int ch)
473 {
474   return (unicode_attributes[ch].name != NULL
475           && strcmp (unicode_attributes[ch].name, "<control>")
476           /* Categories Zl and Zp */
477           && !(unicode_attributes[ch].name != NULL
478                && unicode_attributes[ch].category[0] == 'Z'
479                && (unicode_attributes[ch].category[1] == 'l'
480                    || unicode_attributes[ch].category[1] == 'p')));
481 }
482
483 static bool
484 is_punct (unsigned int ch)
485 {
486 #if 0
487   return (unicode_attributes[ch].name != NULL
488           && unicode_attributes[ch].category[0] == 'P');
489 #else
490   /* The traditional POSIX definition of punctuation is every graphic,
491      non-alphanumeric character.  */
492   return (is_graph (ch) && !is_alpha (ch) && !is_digit (ch));
493 #endif
494 }
495
496 static bool
497 is_combining (unsigned int ch)
498 {
499   return (unicode_attributes[ch].name != NULL
500           && unicode_combining[ch] != 0);
501 }
502
503 static bool
504 is_combining_level3 (unsigned int ch)
505 {
506   return is_combining (ch)
507          && !(unicode_attributes[ch].combining[0] != '\0'
508               && unicode_attributes[ch].combining[0] != '0'
509               && strtoul (unicode_attributes[ch].combining, NULL, 10) >= 200);
510 }
511
512 /* Output a character class (= property) table.  */
513
514 static void
515 output_charclass (FILE *stream, const char *classname,
516                   bool (*func) (unsigned int))
517 {
518   char table[0x10000];
519   unsigned int i;
520   bool need_semicolon;
521   const int max_column = 75;
522   int column;
523
524   for (i = 0; i < 0x10000; i++)
525     table[i] = (int) func (i);
526
527   fprintf (stream, "%s ", classname);
528   need_semicolon = false;
529   column = 1000;
530   for (i = 0; i < 0x10000; )
531     {
532       if (!table[i])
533         i++;
534       else
535         {
536           unsigned int low, high;
537           char buf[17];
538
539           low = i;
540           do
541             i++;
542           while (i < 0x10000 && table[i]);
543           high = i - 1;
544
545           if (low == high)
546             sprintf (buf, "<U%04X>", low);
547           else
548             sprintf (buf, "<U%04X>..<U%04X>", low, high);
549
550           if (need_semicolon)
551             {
552               fprintf (stream, ";");
553               column++;
554             }
555
556           if (column + strlen (buf) > max_column)
557             {
558               fprintf (stream, "/\n   ");
559               column = 3;
560             }
561
562           fprintf (stream, "%s", buf);
563           column += strlen (buf);
564           need_semicolon = true;
565         }
566     }
567   fprintf (stream, "\n");
568 }
569
570 /* Output a character mapping table.  */
571
572 static void
573 output_charmap (FILE *stream, const char *mapname,
574                 unsigned int (*func) (unsigned int))
575 {
576   char table[0x10000];
577   unsigned int i;
578   bool need_semicolon;
579   const int max_column = 75;
580   int column;
581
582   for (i = 0; i < 0x10000; i++)
583     table[i] = (func (i) != i);
584
585   fprintf (stream, "%s ", mapname);
586   need_semicolon = false;
587   column = 1000;
588   for (i = 0; i < 0x10000; i++)
589     if (table[i])
590       {
591         char buf[18];
592
593         sprintf (buf, "(<U%04X>,<U%04X>)", i, func (i));
594
595         if (need_semicolon)
596           {
597             fprintf (stream, ";");
598             column++;
599           }
600
601         if (column + strlen (buf) > max_column)
602           {
603             fprintf (stream, "/\n   ");
604             column = 3;
605           }
606
607         fprintf (stream, "%s", buf);
608         column += strlen (buf);
609         need_semicolon = true;
610       }
611   fprintf (stream, "\n");
612 }
613
614 /* Output the width table.  */
615
616 static void
617 output_widthmap (FILE *stream)
618 {
619 }
620
621 /* Output the tables to the given file.  */
622
623 static void
624 output_tables (const char *filename, const char *version)
625 {
626   FILE *stream;
627   unsigned int ch;
628
629   stream = fopen (filename, "w");
630   if (stream == NULL)
631     {
632       fprintf (stderr, "cannot open '%s' for writing\n", filename);
633       exit (1);
634     }
635
636   fprintf (stream, "escape_char /\n");
637   fprintf (stream, "comment_char %%\n");
638   fprintf (stream, "\n");
639   fprintf (stream, "%% Generated automatically by gen-unicode for Unicode %s.\n",
640            version);
641   fprintf (stream, "\n");
642
643   fprintf (stream, "LC_IDENTIFICATION\n");
644   fprintf (stream, "title     \"Unicode %s FDCC-set\"\n", version);
645   fprintf (stream, "source    \"UnicodeData.txt, PropList.txt\"\n");
646   fprintf (stream, "address   \"\"\n");
647   fprintf (stream, "contact   \"\"\n");
648   fprintf (stream, "email     \"bug-glibc@gnu.org\"\n");
649   fprintf (stream, "tel       \"\"\n");
650   fprintf (stream, "fax       \"\"\n");
651   fprintf (stream, "language  \"\"\n");
652   fprintf (stream, "territory \"Earth\"\n");
653   fprintf (stream, "revision  \"%s\"\n", version);
654   {
655     time_t now;
656     char date[11];
657     now = time (NULL);
658     strftime (date, sizeof (date), "%Y-%m-%d", gmtime (&now));
659     fprintf (stream, "date      \"%s\"\n", date);
660   }
661   fprintf (stream, "category  \"unicode:2000\";LC_CTYPE\n");
662   fprintf (stream, "END LC_IDENTIFICATION\n");
663   fprintf (stream, "\n");
664
665   /* Verifications. */
666   for (ch = 0; ch < 0x10000; ch++)
667     {
668       /* toupper restriction: "Only characters specified for the keywords
669          lower and upper shall be specified.  */
670       if (to_upper (ch) != ch && !(is_lower (ch) || is_upper (ch)))
671         fprintf (stderr,
672                  "<U%04X> is not upper|lower but toupper(0x%04X) = 0x%04X\n",
673                  ch, ch, to_upper (ch));
674
675       /* tolower restriction: "Only characters specified for the keywords
676          lower and upper shall be specified.  */
677       if (to_lower (ch) != ch && !(is_lower (ch) || is_upper (ch)))
678         fprintf (stderr,
679                  "<U%04X> is not upper|lower but tolower(0x%04X) = 0x%04X\n",
680                  ch, ch, to_lower (ch));
681
682       /* alpha restriction: "Characters classified as either upper or lower
683          shall automatically belong to this class.  */
684       if ((is_lower (ch) || is_upper (ch)) && !is_alpha (ch))
685         fprintf (stderr, "<U%04X> is upper|lower but not alpha\n", ch);
686
687       /* alpha restriction: "No character specified for the keywords cntrl,
688          digit, punct or space shall be specified."  */
689       if (is_alpha (ch) && is_cntrl (ch))
690         fprintf (stderr, "<U%04X> is alpha and cntrl\n", ch);
691       if (is_alpha (ch) && is_digit (ch))
692         fprintf (stderr, "<U%04X> is alpha and digit\n", ch);
693       if (is_alpha (ch) && is_punct (ch))
694         fprintf (stderr, "<U%04X> is alpha and punct\n", ch);
695       if (is_alpha (ch) && is_space (ch))
696         fprintf (stderr, "<U%04X> is alpha and space\n", ch);
697
698       /* space restriction: "No character specified for the keywords upper,
699          lower, alpha, digit, graph or xdigit shall be specified."
700          upper, lower, alpha already checked above.  */
701       if (is_space (ch) && is_digit (ch))
702         fprintf (stderr, "<U%04X> is space and digit\n", ch);
703       if (is_space (ch) && is_graph (ch))
704         fprintf (stderr, "<U%04X> is space and graph\n", ch);
705       if (is_space (ch) && is_xdigit (ch))
706         fprintf (stderr, "<U%04X> is space and xdigit\n", ch);
707
708       /* cntrl restriction: "No character specified for the keywords upper,
709          lower, alpha, digit, punct, graph, print or xdigit shall be
710          specified."  upper, lower, alpha already checked above.  */
711       if (is_cntrl (ch) && is_digit (ch))
712         fprintf (stderr, "<U%04X> is cntrl and digit\n", ch);
713       if (is_cntrl (ch) && is_punct (ch))
714         fprintf (stderr, "<U%04X> is cntrl and punct\n", ch);
715       if (is_cntrl (ch) && is_graph (ch))
716         fprintf (stderr, "<U%04X> is cntrl and graph\n", ch);
717       if (is_cntrl (ch) && is_print (ch))
718         fprintf (stderr, "<U%04X> is cntrl and print\n", ch);
719       if (is_cntrl (ch) && is_xdigit (ch))
720         fprintf (stderr, "<U%04X> is cntrl and xdigit\n", ch);
721
722       /* punct restriction: "No character specified for the keywords upper,
723          lower, alpha, digit, cntrl, xdigit or as the <space> character shall
724          be specified."  upper, lower, alpha, cntrl already checked above.  */
725       if (is_punct (ch) && is_digit (ch))
726         fprintf (stderr, "<U%04X> is punct and digit\n", ch);
727       if (is_punct (ch) && is_xdigit (ch))
728         fprintf (stderr, "<U%04X> is punct and xdigit\n", ch);
729       if (is_punct (ch) && (ch == 0x0020))
730         fprintf (stderr, "<U%04X> is punct\n", ch);
731
732       /* graph restriction: "No character specified for the keyword cntrl
733          shall be specified."  Already checked above.  */
734
735       /* print restriction: "No character specified for the keyword cntrl
736          shall be specified."  Already checked above.  */
737
738       /* graph - print relation: differ only in the <space> character.
739          How is this possible if there are more than one space character?!
740          I think susv2/xbd/locale.html should speak of "space characters",
741          not "space character".  */
742       if (is_print (ch) && !(is_graph (ch) || /* ch == 0x0020 */ is_space (ch)))
743         fprintf (stderr, "<U%04X> is print but not graph|<space>\n", ch);
744       if (!is_print (ch) && (is_graph (ch) || ch == 0x0020))
745         fprintf (stderr, "<U%04X> is graph|<space> but not print\n", ch);
746     }
747
748   fprintf (stream, "LC_CTYPE\n");
749   output_charclass (stream, "upper", is_upper);
750   output_charclass (stream, "lower", is_lower);
751   output_charclass (stream, "alpha", is_alpha);
752   output_charclass (stream, "digit", is_digit);
753   output_charclass (stream, "outdigit", is_outdigit);
754   output_charclass (stream, "blank", is_blank);
755   output_charclass (stream, "space", is_space);
756   output_charclass (stream, "cntrl", is_cntrl);
757   output_charclass (stream, "punct", is_punct);
758   output_charclass (stream, "xdigit", is_xdigit);
759   output_charclass (stream, "graph", is_graph);
760   output_charclass (stream, "print", is_print);
761   output_charclass (stream, "class \"combining\";", is_combining);
762   output_charclass (stream, "class \"combining_level3\";", is_combining_level3);
763   output_charmap (stream, "toupper", to_upper);
764   output_charmap (stream, "tolower", to_lower);
765   output_charmap (stream, "map \"totitle\";", to_title);
766   output_widthmap (stream);
767   fprintf (stream, "END LC_CTYPE\n");
768
769   if (ferror (stream) || fclose (stream))
770     {
771       fprintf (stderr, "error writing to '%s'\n", filename);
772       exit (1);
773     }
774 }
775
776 int
777 main (int argc, char * argv[])
778 {
779   if (argc != 4)
780     {
781       fprintf (stderr, "Usage: %s UnicodeData.txt PropList.txt version\n",
782                argv[0]);
783       exit (1);
784     }
785
786   fill_attributes (argv[1]);
787   fill_combining (argv[2]);
788
789   output_tables ("unicode", argv[3]);
790
791   return 0;
792 }