diff options
Diffstat (limited to 'usr.bin/mklocale')
| -rw-r--r-- | usr.bin/mklocale/Japanese | 158 | ||||
| -rw-r--r-- | usr.bin/mklocale/Makefile | 8 | ||||
| -rw-r--r-- | usr.bin/mklocale/POSIX | 33 | ||||
| -rw-r--r-- | usr.bin/mklocale/ldef.h | 53 | ||||
| -rw-r--r-- | usr.bin/mklocale/lex.l | 152 | ||||
| -rw-r--r-- | usr.bin/mklocale/mklocale.1 | 257 | ||||
| -rw-r--r-- | usr.bin/mklocale/yacc.y | 821 |
7 files changed, 1482 insertions, 0 deletions
diff --git a/usr.bin/mklocale/Japanese b/usr.bin/mklocale/Japanese new file mode 100644 index 0000000..55eb155 --- /dev/null +++ b/usr.bin/mklocale/Japanese @@ -0,0 +1,158 @@ +# @(#)Japanese 8.1 (Berkeley) 6/6/93 + +/* + * Japanese LOCALE_CTYPE definitions using EUC of JIS character sets + */ + +ENCODING "EUC" + +/* JIS JIS JIS */ +/* X201 X208 X201 */ +/* 00-7f 84-fe */ + +VARIABLE 1 0x0000 2 0x8080 2 0x0080 3 0x8000 0x8080 + +/* + * Code Set 1 + */ +ALPHA 'A' - 'Z' 'a' - 'z' +CONTROL 0x00 - 0x1f 0x7f +DIGIT '0' - '9' +GRAPH 0x21 - 0x7e +LOWER 'a' - 'z' +PUNCT 0x21 - 0x2f 0x3a - 0x40 0x5b - 0x60 0x7b - 0x7e +SPACE 0x09 - 0x0d 0x20 +UPPER 'A' - 'Z' +XDIGIT 'a' - 'f' 'A' - 'F' +BLANK ' ' '\t' +PRINT 0x20 - 0x7e + +MAPLOWER < 'A' - 'Z' : 'a' > +MAPLOWER < 'a' - 'z' : 'a' > +MAPUPPER < 'A' - 'Z' : 'A' > +MAPUPPER < 'a' - 'z' : 'A' > +TODIGIT < '0' - '9' : 0 > +TODIGIT < 'A' - 'F' : 10 > +TODIGIT < 'a' - 'f' : 10 > + +/* + * Code Set 2 + */ + +SPACE 0xa1a1 +PHONOGRAM 0xa1bc +SPECIAL 0xa1a2 - 0xa1fe +PUNCT 0xa1a2 - 0xa1f8 /* A few too many in here... */ + +SPECIAL 0xa2a1 - 0xa2ae 0xa2ba - 0xa2c1 0xa2ca - 0xa2d0 0xa2dc - 0xa2ea +SPECIAL 0xa2f2 - 0xa2f9 0xa2fe + +DIGIT 0xa3b0 - 0xa3b9 +UPPER 0xa3c1 - 0xa3da /* Romaji */ +LOWER 0xa3e1 - 0xa3fa /* Romaji */ +MAPLOWER < 0xa3c1 - 0xa3da : 0xa3e1 > /* English */ +MAPLOWER < 0xa3e1 - 0xa3fa : 0xa3e1 > /* English */ +MAPUPPER < 0xa3c1 - 0xa3da : 0xa3c1 > +MAPUPPER < 0xa3e1 - 0xa3fa : 0xa3c1 > + +XDIGIT 0xa3c1 - 0xa3c6 0xa3e1 - 0xa3e6 + +TODIGIT < 0xa3b0 - 0xa3b9 : 0 > +TODIGIT < 0xa3c1 - 0xa3c6 : 10 > +TODIGIT < 0xa3e1 - 0xa3e6 : 10 > + +PHONOGRAM 0xa4a1 - 0xa4f3 +PHONOGRAM 0xa5a1 - 0xa5f6 + +UPPER 0xa6a1 - 0xa6b8 /* Greek */ +LOWER 0xa6c1 - 0xa6d8 /* Greek */ +MAPLOWER < 0xa6a1 - 0xa6b8 : 0xa6c1 > +MAPLOWER < 0xa6c1 - 0xa6d8 : 0xa6c1 > +MAPUPPER < 0xa6a1 - 0xa6b8 : 0xa6a1 > +MAPUPPER < 0xa6c1 - 0xa6d8 : 0xa6a1 > + +UPPER 0xa7a1 - 0xa7c1 /* Cyrillic */ +LOWER 0xa7d1 - 0xa7f1 /* Cyrillic */ +MAPLOWER < 0xa7a1 - 0xa7c1 : 0xa7d1 > +MAPLOWER < 0xa7d1 - 0xa7f1 : 0xa7d1 > +MAPUPPER < 0xa7a1 - 0xa7c1 : 0xa7a1 > +MAPUPPER < 0xa7d1 - 0xa7f1 : 0xa7a1 > + +SPECIAL 0xa8a1 - 0xa8c0 + +IDEOGRAM 0xb0a1 - 0xb0fe +IDEOGRAM 0xb1a1 - 0xb1fe +IDEOGRAM 0xb2a1 - 0xb2fe +IDEOGRAM 0xb3a1 - 0xb3fe +IDEOGRAM 0xb4a1 - 0xb4fe +IDEOGRAM 0xb5a1 - 0xb5fe +IDEOGRAM 0xb6a1 - 0xb6fe +IDEOGRAM 0xb7a1 - 0xb7fe +IDEOGRAM 0xb8a1 - 0xb8fe +IDEOGRAM 0xb9a1 - 0xb9fe +IDEOGRAM 0xbaa1 - 0xbafe +IDEOGRAM 0xbba1 - 0xbbfe +IDEOGRAM 0xbca1 - 0xbcfe +IDEOGRAM 0xbda1 - 0xbdfe +IDEOGRAM 0xbea1 - 0xbefe +IDEOGRAM 0xbfa1 - 0xbffe +IDEOGRAM 0xc0a1 - 0xc0fe +IDEOGRAM 0xc1a1 - 0xc1fe +IDEOGRAM 0xc2a1 - 0xc2fe +IDEOGRAM 0xc3a1 - 0xc3fe +IDEOGRAM 0xc4a1 - 0xc4fe +IDEOGRAM 0xc5a1 - 0xc5fe +IDEOGRAM 0xc6a1 - 0xc6fe +IDEOGRAM 0xc7a1 - 0xc7fe +IDEOGRAM 0xc8a1 - 0xc8fe +IDEOGRAM 0xc9a1 - 0xc9fe +IDEOGRAM 0xcaa1 - 0xcafe +IDEOGRAM 0xcba1 - 0xcbfe +IDEOGRAM 0xcca1 - 0xccfe +IDEOGRAM 0xcda1 - 0xcdfe +IDEOGRAM 0xcea1 - 0xcefe +IDEOGRAM 0xcfa1 - 0xcfd3 +IDEOGRAM 0xd0a1 - 0xd0fe +IDEOGRAM 0xd1a1 - 0xd1fe +IDEOGRAM 0xd2a1 - 0xd2fe +IDEOGRAM 0xd3a1 - 0xd3fe +IDEOGRAM 0xd4a1 - 0xd4fe +IDEOGRAM 0xd5a1 - 0xd5fe +IDEOGRAM 0xd6a1 - 0xd6fe +IDEOGRAM 0xd7a1 - 0xd7fe +IDEOGRAM 0xd8a1 - 0xd8fe +IDEOGRAM 0xd9a1 - 0xd9fe +IDEOGRAM 0xdaa1 - 0xdafe +IDEOGRAM 0xdba1 - 0xdbfe +IDEOGRAM 0xdca1 - 0xdcfe +IDEOGRAM 0xdda1 - 0xddfe +IDEOGRAM 0xdea1 - 0xdefe +IDEOGRAM 0xdfa1 - 0xdffe +IDEOGRAM 0xe0a1 - 0xe0fe +IDEOGRAM 0xe1a1 - 0xe1fe +IDEOGRAM 0xe2a1 - 0xe2fe +IDEOGRAM 0xe3a1 - 0xe3fe +IDEOGRAM 0xe4a1 - 0xe4fe +IDEOGRAM 0xe5a1 - 0xe5fe +IDEOGRAM 0xe6a1 - 0xe6fe +IDEOGRAM 0xe7a1 - 0xe7fe +IDEOGRAM 0xe8a1 - 0xe8fe +IDEOGRAM 0xe9a1 - 0xe9fe +IDEOGRAM 0xeaa1 - 0xeafe +IDEOGRAM 0xeba1 - 0xebfe +IDEOGRAM 0xeca1 - 0xecfe +IDEOGRAM 0xeda1 - 0xedfe +IDEOGRAM 0xeea1 - 0xeefe +IDEOGRAM 0xefa1 - 0xeffe +IDEOGRAM 0xf0a1 - 0xf0fe +IDEOGRAM 0xf1a1 - 0xf1fe +IDEOGRAM 0xf2a1 - 0xf2fe +IDEOGRAM 0xf3a1 - 0xf3fe +IDEOGRAM 0xf4a1 - 0xf4a4 + +/* + * This is for Code Set 3, half-width kana + */ +SPECIAL 0xa1 - 0xdf +PHONOGRAM 0xa1 - 0xdf +CONTROL 0x84 - 0x97 0x9b - 0x9f 0xe0 - 0xfe diff --git a/usr.bin/mklocale/Makefile b/usr.bin/mklocale/Makefile new file mode 100644 index 0000000..ec108bd --- /dev/null +++ b/usr.bin/mklocale/Makefile @@ -0,0 +1,8 @@ +# @(#)Makefile 8.1 (Berkeley) 6/7/93 + +PROG= mklocale +SRCS= yacc.c lex.c +CFLAGS+=-I. +CLEANFILES+=y.tab.h yacc.c lex.c + +.include <bsd.prog.mk> diff --git a/usr.bin/mklocale/POSIX b/usr.bin/mklocale/POSIX new file mode 100644 index 0000000..ead0bc8 --- /dev/null +++ b/usr.bin/mklocale/POSIX @@ -0,0 +1,33 @@ +# @(#)POSIX 8.1 (Berkeley) 6/6/93 + +/* + * Standard LOCALE_CTYPE for the C Locale + */ +ENCODING "UTF2" +VARIABLE A comment line or data line. Only 1 allowed. Copied verbatim. + +# +# This is a comment +# +ALPHA 'A' - 'Z' 'a' - 'z' +CONTROL 0x00 - 0x1f 0x7f +DIGIT '0' - '9' +GRAPH 0x21 - 0x7e +LOWER 'a' - 'z' +PUNCT 0x21 - 0x2f 0x3a - 0x40 0x5b - 0x60 0x7b - 0x7e +SPACE 0x09 - 0x0d 0x20 +UPPER 'A' - 'Z' +XDIGIT 'a' - 'f' 'A' - 'F' +BLANK ' ' '\t' +PRINT 0x20 - 0x7e +# IDEOGRAM +# SPECIAL +# PHONEGRAM + +MAPLOWER <'A' - 'Z' : 'a'> +MAPLOWER <'a' - 'z' : 'a'> +MAPUPPER <'A' - 'Z' : 'A'> +MAPUPPER <'a' - 'z' : 'A'> +TODIGIT <'0' - '9' : 0> +TODIGIT <'A' - 'F' : 10> +TODIGIT <'a' - 'f' : 10> diff --git a/usr.bin/mklocale/ldef.h b/usr.bin/mklocale/ldef.h new file mode 100644 index 0000000..95b51da --- /dev/null +++ b/usr.bin/mklocale/ldef.h @@ -0,0 +1,53 @@ +/*- + * Copyright (c) 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Paul Borman at Krystal Technologies. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ldef.h 8.1 (Berkeley) 6/6/93 + */ + +/* + * This should look a LOT like a _RuneEntry + */ +typedef struct rune_list { + rune_t min; + rune_t max; + rune_t map; + u_long *types; + struct rune_list *next; +} rune_list; + +typedef struct rune_map { + u_long map[_CACHED_RUNES]; + rune_list *root; +} rune_map; diff --git a/usr.bin/mklocale/lex.l b/usr.bin/mklocale/lex.l new file mode 100644 index 0000000..0e2f1a9 --- /dev/null +++ b/usr.bin/mklocale/lex.l @@ -0,0 +1,152 @@ +%{ +/*- + * Copyright (c) 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Paul Borman at Krystal Technologies. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)lex.l 8.1 (Berkeley) 6/6/93"; +#endif /* not lint */ + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> + +#include "ldef.h" +#include "y.tab.h" +%} + +ODIGIT [0-7] +DIGIT [0-9] +XDIGIT [0-9a-fA-F] +W [\t\n\r ] + +%% +\'.\' { yylval.rune = yytext[1]; + return(RUNE); } + +'\\a' { yylval.rune = '\a'; + return(RUNE); } +'\\b' { yylval.rune = '\b'; + return(RUNE); } +'\\f' { yylval.rune = '\f'; + return(RUNE); } +'\\n' { yylval.rune = '\n'; + return(RUNE); } +'\\r' { yylval.rune = '\r'; + return(RUNE); } +'\\t' { yylval.rune = '\t'; + return(RUNE); } +'\\v' { yylval.rune = '\v'; + return(RUNE); } + +0x{XDIGIT}+ { yylval.rune = strtol(yytext, 0, 16); + return(RUNE); } +0{ODIGIT}+ { yylval.rune = strtol(yytext, 0, 8); + return(RUNE); } +{DIGIT}+ { yylval.rune = strtol(yytext, 0, 10); + return(RUNE); } + + +MAPLOWER { return(MAPLOWER); } +MAPUPPER { return(MAPUPPER); } +TODIGIT { return(DIGITMAP); } +INVALID { return(INVALID); } + +ALPHA { yylval.i = _A|_R|_G; return(LIST); } +CONTROL { yylval.i = _C; return(LIST); } +DIGIT { yylval.i = _D|_R|_G; return(LIST); } +GRAPH { yylval.i = _G|_R; return(LIST); } +LOWER { yylval.i = _L|_R|_G; return(LIST); } +PUNCT { yylval.i = _P|_R|_G; return(LIST); } +SPACE { yylval.i = _S; return(LIST); } +UPPER { yylval.i = _U|_R|_G; return(LIST); } +XDIGIT { yylval.i = _X|_R|_G; return(LIST); } +BLANK { yylval.i = _B; return(LIST); } +PRINT { yylval.i = _R; return(LIST); } +IDEOGRAM { yylval.i = _I|_R|_G; return(LIST); } +SPECIAL { yylval.i = _T|_R|_G; return(LIST); } +PHONOGRAM { yylval.i = _Q|_R|_G; return(LIST); } + +VARIABLE[\t ] { static char vbuf[1024]; + char *v = vbuf; + while ((*v = input()) && *v != '\n') + ++v; + if (*v) { + unput(*v); + *v = 0; + } + yylval.str = vbuf; + return(VARIABLE); + } + +ENCODING { return(ENCODING); } + +\".*\" { char *e = yytext + 1; + yylval.str = e; + while (*e && *e != '"') + ++e; + *e = 0; + return(STRING); } + +\<|\(|\[ { return(LBRK); } + +\>|\)|\] { return(RBRK); } + +\- { return(THRU); } +\.\.\. { return(THRU); } + +\: { return(':'); } + +{W}+ ; + +^\#.*\n ; +\/\* { char lc = 0; + do { + while ((lc) != '*') + if ((lc = input()) == 0) + break; + } while((lc = input()) != '/'); + } + +\\$ ; +. { printf("Lex is skipping '%s'\n", yytext); } +%% + +#if !defined(yywrap) +yywrap() +{ + return(1); +} +#endif diff --git a/usr.bin/mklocale/mklocale.1 b/usr.bin/mklocale/mklocale.1 new file mode 100644 index 0000000..b0b0c62 --- /dev/null +++ b/usr.bin/mklocale/mklocale.1 @@ -0,0 +1,257 @@ +.\" Copyright (c) 1993, 1994 +.\" The Regents of the University of California. All rights reserved. +.\" +.\" This code is derived from software contributed to Berkeley by +.\" Paul Borman at Krystal Technologies. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by the University of +.\" California, Berkeley and its contributors. +.\" 4. Neither the name of the University nor the names of its contributors +.\" may be used to endorse or promote products derived from this software +.\" without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" @(#)mklocale.1 8.2 (Berkeley) 4/18/94 +.\" +.Dd "April 18, 1994" +.Dt MKLOCALE 1 +.Os +.Sh NAME +.Nm mklocale +.Nd make LC_CTYPE locale files +.Sh SYNOPSIS +.Nm mklocale +.Ar "< src-file" +.Ar "> language/LC_CTYPE" +.Sh DESCRIPTION +The +.Nm mklocale +utility reads a +.Dv LC_CTYPE +source file from standard input and produces a +.Dv LC_CTYPE +binary file on standard output suitable for placement in +.Dv /usr/share/locale/\fIlanguage\fP/LC_CTYPE. +.Pp +The format of +.Ar src-file +is quite simple. +It consists of a series of lines which start with a keyword and have +associated data following. C style comments are used +to place comments in the file. +.Pp +Besides the keywords which will be listed below, +the following are valid tokens in +.Ar src-file : +.Bl -tag -width literal +.It Dv RUNE +A +.Dv RUNE +may be any of the following: +.Bl -tag -width 0x[0-9a-z]* +.It Ar 'x' +The ascii character +.Ar x . +.It Ar '\ex' +The ANSI C character +.Ar \ex +where +.Ar \ex +is one of +.Dv \ea , +.Dv \eb , +.Dv \ef , +.Dv \en , +.Dv \er , +.Dv \et , +or +.Dv \ev . +.It Ar 0x[0-9a-z]* +A hexadecimal number representing a rune code. +.It Ar 0[0-7]* +An octal number representing a rune code. +.It Ar [1-9][0-9]* +A decimal number representing a rune code. +.El +.It Dv STRING +A string enclosed in double quotes ("). +.It Dv THRU +Either +.Dv ... +or +.Dv - . +Used to indicate ranges. +.It Ar literal +The follow characters are taken literally: +.Bl -tag -width "<\|\|(\|\|[" +.It Dv "<\|(\|[" +Used to start a mapping. All are equivalent. +.It Dv ">\|\^)\|]" +Used to end a mapping. All are equivalent. +.It Dv : +Used as a delimiter in mappings. +.El +.El +.sp +Key words which should only appear once are: +.Bl -tag -width PHONOGRAM +.It Dv ENCODING +Followed by a +.Dv STRING +which indicates the encoding mechanism to be used for this locale. +The current encodings are: +.Bl -tag -width NONE +.It Dv NONE +No translation and the default. +.It Dv UTF2 +.Dv "Universal character set Transformation Format" +adopted from +.Nm "Plan 9 from Bell Labs" . +This is the preferred encoding. +.It Dv EUC +.Dv EUC +encoding as used by several +vendors of +.Ux +systems. +.El +.It Dv VARIABLE +This keyword must be followed by a single tab or space character, +after which encoding specific data is placed. +Currently only the +.Dv "EUC" +encoding requires variable data. +See +.Xr euc 4 +for further details. +.It Dv INVALID +A single +.Dv RUNE +follows and is used as the invalid rune for this locale. +.El +.sp +The following keywords may appear multiple times and have the following +format for data: +.in +.5i +.Bl -tag -width "<RUNE1 THRU RUNEn : RUNE2>" +.It Dv <RUNE1 RUNE2> +.Dv RUNE1 +is mapped to +.Dv RUNE2 . +.It Dv <RUNE1 THRU RUNEn : RUNE2> +Runes +.Dv RUNE1 +through +.Dv RUNEn +are mapped to +.Dv RUNE2 +through +.Dv RUNE2 ++ n-1. +.El +.in -.5i +.Bl -tag -width PHONOGRAM +.It Dv MAPLOWER +Defines the tolower mappings. +.Dv RUNE2 +is the lower case representation of +.Dv RUNE1. +.It Dv MAPUPPER +Defines the toupper mappings. +.Dv RUNE2 +is the upper case representation of +.Dv RUNE1. +.It Dv TODIGIT +Defines a map from runes to their digit value. +.Dv RUNE2 +is the integer value represented by +.Dv RUNE1 . +For example, the ascii character +.Nm '0' +would map to the decimal value +.Nm 0 . +Only values up to +.Nm 255 +are allowed. +.El +.sp +The following keywords may appear multiple times and have the following +format for data: +.in +.5i +.Bl -tag -width "RUNE1 THRU RUNEn" +.It Dv RUNE +This rune has the property defined by the keyword. +.It Dv "RUNE1 THRU RUNEn" +All the runes between and including +.Dv RUNE1 +and +.Dv RUNEn +have the property defined by the keyword. +.El +.in -.5i +.Bl -tag -width PHONOGRAM +.It Dv ALPHA +Defines runes which are alphabetic, printable and graphic. +.It Dv CONTROL +Defines runes which are control characters. +.It Dv DIGIT +Defines runes which are decimal digits, printable and graphic. +.It Dv GRAPH +Defines runes which are graphic and printable. +.It Dv LOWER +Defines runes which are lower case, printable and graphic. +.It Dv PUNCT +Defines runes which are punctuation, printable and graphic. +.It Dv SPACE +Defines runes which are spaces. +.It Dv UPPER +Defines runes which are upper case, printable and graphic. +.It Dv XDIGIT +Defines runes which are hexadecimal digits, printable and graphic. +.It Dv BLANK +Defines runes which are blank. +.It Dv PRINT +Defines runes which are printable. +.It Dv IDEOGRAM +Defines runes which are ideograms, printable and graphic. +.It Dv SPECIAL +Defines runes which are special characters, printable and graphic. +.It Dv PHONOGRAM +Defines runes which are phonograms, printable and graphic. +.El +.Sh SEE ALSO +.Xr mbrune 3 , +.Xr rune 3 , +.Xr setlocale 3 , +.Xr euc 4 , +.Xr utf2 4 +.Sh BUGS +The +.Nm mklocale +utility is overly simplistic. +.Sh HISTORY +The +.Nm mklocale +utility first appeared in +.Bx 4.4 . diff --git a/usr.bin/mklocale/yacc.y b/usr.bin/mklocale/yacc.y new file mode 100644 index 0000000..193b7b1 --- /dev/null +++ b/usr.bin/mklocale/yacc.y @@ -0,0 +1,821 @@ +%{ +/*- + * Copyright (c) 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Paul Borman at Krystal Technologies. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)yacc.y 8.1 (Berkeley) 6/6/93"; +#endif /* not lint */ + +#include <ctype.h> +#include <rune.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> + +#include "ldef.h" + +char *locale_file = "<stdout>"; + +rune_map maplower = { 0, }; +rune_map mapupper = { 0, }; +rune_map types = { 0, }; + +_RuneLocale new_locale = { 0, }; + +void set_map __P((rune_map *, rune_list *, u_long)); +void set_digitmap __P((rune_map *, rune_list *)); +void add_map __P((rune_map *, rune_list *, u_long)); +%} + +%union { + rune_t rune; + int i; + char *str; + + rune_list *list; +} + +%token <rune> RUNE +%token LBRK +%token RBRK +%token THRU +%token MAPLOWER +%token MAPUPPER +%token DIGITMAP +%token <i> LIST +%token <str> VARIABLE +%token ENCODING +%token INVALID +%token <str> STRING + +%type <list> list +%type <list> map + + +%% + +locale : /* empty */ + | table + { dump_tables(); } + ; + +table : entry + | table entry + ; + +entry : ENCODING STRING + { strncpy(new_locale.encoding, $2, sizeof(new_locale.encoding)); } + | VARIABLE + { new_locale.variable_len = strlen($1) + 1; + new_locale.variable = malloc(new_locale.variable_len); + strcpy((char *)new_locale.variable, $1); + } + | INVALID RUNE + { new_locale.invalid_rune = $2; } + | LIST list + { set_map(&types, $2, $1); } + | MAPLOWER map + { set_map(&maplower, $2, 0); } + | MAPUPPER map + { set_map(&mapupper, $2, 0); } + | DIGITMAP map + { set_digitmap(&types, $2); } + ; + +list : RUNE + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $1; + $$->max = $1; + $$->next = 0; + } + | RUNE THRU RUNE + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $1; + $$->max = $3; + $$->next = 0; + } + | list RUNE + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $2; + $$->next = $1; + } + | list RUNE THRU RUNE + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $4; + $$->next = $1; + } + ; + +map : LBRK RUNE RUNE RBRK + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $2; + $$->map = $3; + $$->next = 0; + } + | map LBRK RUNE RUNE RBRK + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $3; + $$->max = $3; + $$->map = $4; + $$->next = $1; + } + | LBRK RUNE THRU RUNE ':' RUNE RBRK + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $4; + $$->map = $6; + $$->next = 0; + } + | map LBRK RUNE THRU RUNE ':' RUNE RBRK + { + $$ = (rune_list *)malloc(sizeof(rune_list)); + $$->min = $3; + $$->max = $5; + $$->map = $7; + $$->next = $1; + } + ; +%% + +int debug = 0; +FILE *fp = stdout; + +main(ac, av) + int ac; + char *av[]; +{ + int x; + + extern char *optarg; + extern int optind; + + while ((x = getopt(ac, av, "do:")) != EOF) { + switch(x) { + case 'd': + debug = 1; + break; + case 'o': + locale_file = optarg; + if ((fp = fopen(locale_file, "w")) == 0) { + perror(locale_file); + exit(1); + } + break; + default: + usage: + fprintf(stderr, "Usage: mklocale [-d] [-o output] [source]\n"); + exit(1); + } + } + + switch (ac - optind) { + case 0: + break; + case 1: + if (freopen(av[optind], "r", stdin) == 0) { + perror(av[optind]); + exit(1); + } + break; + default: + goto usage; + } + for (x = 0; x < _CACHED_RUNES; ++x) { + mapupper.map[x] = x; + maplower.map[x] = x; + } + new_locale.invalid_rune = _INVALID_RUNE; + memcpy(new_locale.magic, _RUNE_MAGIC_1, sizeof(new_locale.magic)); + + yyparse(); +} + +yyerror(s) + char *s; +{ + fprintf(stderr, "%s\n", s); +} + +void * +xmalloc(sz) + unsigned int sz; +{ + void *r = malloc(sz); + if (!r) { + perror("xmalloc"); + abort(); + } + return(r); +} + +u_long * +xlalloc(sz) + unsigned int sz; +{ + u_long *r = (u_long *)malloc(sz * sizeof(u_long)); + if (!r) { + perror("xlalloc"); + abort(); + } + return(r); +} + +u_long * +xrelalloc(old, sz) + u_long *old; + unsigned int sz; +{ + u_long *r = (u_long *)realloc((char *)old, sz * sizeof(u_long)); + if (!r) { + perror("xrelalloc"); + abort(); + } + return(r); +} + +void +set_map(map, list, flag) + rune_map *map; + rune_list *list; + u_long flag; +{ + while (list) { + rune_list *nlist = list->next; + add_map(map, list, flag); + list = nlist; + } +} + +void +set_digitmap(map, list) + rune_map *map; + rune_list *list; +{ + rune_t i; + + while (list) { + rune_list *nlist = list->next; + for (i = list->min; i <= list->max; ++i) { + if (list->map + (i - list->min)) { + rune_list *tmp = (rune_list *)xmalloc(sizeof(rune_list)); + tmp->min = i; + tmp->max = i; + add_map(map, tmp, list->map + (i - list->min)); + } + } + free(list); + list = nlist; + } +} + +void +add_map(map, list, flag) + rune_map *map; + rune_list *list; + u_long flag; +{ + rune_t i; + rune_list *lr = 0; + rune_list *r; + rune_t run; + + while (list->min < _CACHED_RUNES && list->min <= list->max) { + if (flag) + map->map[list->min++] |= flag; + else + map->map[list->min++] = list->map++; + } + + if (list->min > list->max) { + free(list); + return; + } + + run = list->max - list->min + 1; + + if (!(r = map->root) || (list->max < r->min - 1) + || (!flag && list->max == r->min - 1)) { + if (flag) { + list->types = xlalloc(run); + for (i = 0; i < run; ++i) + list->types[i] = flag; + } + list->next = map->root; + map->root = list; + return; + } + + for (r = map->root; r && r->max + 1 < list->min; r = r->next) + lr = r; + + if (!r) { + /* + * We are off the end. + */ + if (flag) { + list->types = xlalloc(run); + for (i = 0; i < run; ++i) + list->types[i] = flag; + } + list->next = 0; + lr->next = list; + return; + } + + if (list->max < r->min - 1) { + /* + * We come before this range and we do not intersect it. + * We are not before the root node, it was checked before the loop + */ + if (flag) { + list->types = xlalloc(run); + for (i = 0; i < run; ++i) + list->types[i] = flag; + } + list->next = lr->next; + lr->next = list; + return; + } + + /* + * At this point we have found that we at least intersect with + * the range pointed to by `r', we might intersect with one or + * more ranges beyond `r' as well. + */ + + if (!flag && list->map - list->min != r->map - r->min) { + /* + * There are only two cases when we are doing case maps and + * our maps needn't have the same offset. When we are adjoining + * but not intersecting. + */ + if (list->max + 1 == r->min) { + lr->next = list; + list->next = r; + return; + } + if (list->min - 1 == r->max) { + list->next = r->next; + r->next = list; + return; + } + fprintf(stderr, "Error: conflicting map entries\n"); + exit(1); + } + + if (list->min >= r->min && list->max <= r->max) { + /* + * Subset case. + */ + + if (flag) { + for (i = list->min; i <= list->max; ++i) + r->types[i - r->min] |= flag; + } + free(list); + return; + } + if (list->min <= r->min && list->max >= r->max) { + /* + * Superset case. Make him big enough to hold us. + * We might need to merge with the guy after him. + */ + if (flag) { + list->types = xlalloc(list->max - list->min + 1); + + for (i = list->min; i <= list->max; ++i) + list->types[i - list->min] = flag; + + for (i = r->min; i <= r->max; ++i) + list->types[i - list->min] |= r->types[i - r->min]; + + free(r->types); + r->types = list->types; + } else { + r->map = list->map; + } + r->min = list->min; + r->max = list->max; + free(list); + } else if (list->min < r->min) { + /* + * Our tail intersects his head. + */ + if (flag) { + list->types = xlalloc(r->max - list->min + 1); + + for (i = r->min; i <= r->max; ++i) + list->types[i - list->min] = r->types[i - r->min]; + + for (i = list->min; i < r->min; ++i) + list->types[i - list->min] = flag; + + for (i = r->min; i <= list->max; ++i) + list->types[i - list->min] |= flag; + + free(r->types); + r->types = list->types; + } else { + r->map = list->map; + } + r->min = list->min; + free(list); + return; + } else { + /* + * Our head intersects his tail. + * We might need to merge with the guy after him. + */ + if (flag) { + r->types = xrelalloc(r->types, list->max - r->min + 1); + + for (i = list->min; i <= r->max; ++i) + r->types[i - r->min] |= flag; + + for (i = r->max+1; i <= list->max; ++i) + r->types[i - r->min] = flag; + } + r->max = r->max; + free(list); + } + + /* + * Okay, check to see if we grew into the next guy(s) + */ + while ((lr = r->next) && r->max >= lr->min) { + if (flag) { + if (r->max >= lr->max) { + /* + * Good, we consumed all of him. + */ + for (i = lr->min; i <= lr->max; ++i) + r->types[i - r->min] |= lr->types[i - lr->min]; + } else { + /* + * "append" him on to the end of us. + */ + r->types = xrelalloc(r->types, lr->max - r->min + 1); + + for (i = lr->min; i <= r->max; ++i) + r->types[i - r->min] |= lr->types[i - lr->min]; + + for (i = r->max+1; i <= lr->max; ++i) + r->types[i - r->min] = lr->types[i - lr->min]; + + r->max = lr->max; + } + } else { + if (lr->max > r->max) + r->max = lr->max; + } + + r->next = lr->next; + + if (flag) + free(lr->types); + free(lr); + } +} + +void +dump_tables() +{ + int x; + rune_list *list; + + /* + * See if we can compress some of the istype arrays + */ + for(list = types.root; list; list = list->next) { + list->map = list->types[0]; + for (x = 1; x < list->max - list->min + 1; ++x) { + if (list->types[x] != list->map) { + list->map = 0; + break; + } + } + } + + new_locale.invalid_rune = htonl(new_locale.invalid_rune); + + /* + * Fill in our tables. Do this in network order so that + * diverse machines have a chance of sharing data. + * (Machines like Crays cannot share with little machines due to + * word size. Sigh. We tried.) + */ + for (x = 0; x < _CACHED_RUNES; ++x) { + new_locale.runetype[x] = htonl(types.map[x]); + new_locale.maplower[x] = htonl(maplower.map[x]); + new_locale.mapupper[x] = htonl(mapupper.map[x]); + } + + /* + * Count up how many ranges we will need for each of the extents. + */ + list = types.root; + + while (list) { + new_locale.runetype_ext.nranges++; + list = list->next; + } + new_locale.runetype_ext.nranges = htonl(new_locale.runetype_ext.nranges); + + list = maplower.root; + + while (list) { + new_locale.maplower_ext.nranges++; + list = list->next; + } + new_locale.maplower_ext.nranges = htonl(new_locale.maplower_ext.nranges); + + list = mapupper.root; + + while (list) { + new_locale.mapupper_ext.nranges++; + list = list->next; + } + new_locale.mapupper_ext.nranges = htonl(new_locale.mapupper_ext.nranges); + + new_locale.variable_len = htonl(new_locale.variable_len); + + /* + * Okay, we are now ready to write the new locale file. + */ + + /* + * PART 1: The _RuneLocale structure + */ + if (fwrite((char *)&new_locale, sizeof(new_locale), 1, fp) != 1) { + perror(locale_file); + exit(1); + } + /* + * PART 2: The runetype_ext structures (not the actual tables) + */ + list = types.root; + + while (list) { + _RuneEntry re; + + re.min = htonl(list->min); + re.max = htonl(list->max); + re.map = htonl(list->map); + + if (fwrite((char *)&re, sizeof(re), 1, fp) != 1) { + perror(locale_file); + exit(1); + } + + list = list->next; + } + /* + * PART 3: The maplower_ext structures + */ + list = maplower.root; + + while (list) { + _RuneEntry re; + + re.min = htonl(list->min); + re.max = htonl(list->max); + re.map = htonl(list->map); + + if (fwrite((char *)&re, sizeof(re), 1, fp) != 1) { + perror(locale_file); + exit(1); + } + + list = list->next; + } + /* + * PART 4: The mapupper_ext structures + */ + list = mapupper.root; + + while (list) { + _RuneEntry re; + + re.min = htonl(list->min); + re.max = htonl(list->max); + re.map = htonl(list->map); + + if (fwrite((char *)&re, sizeof(re), 1, fp) != 1) { + perror(locale_file); + exit(1); + } + + list = list->next; + } + /* + * PART 5: The runetype_ext tables + */ + list = types.root; + + while (list) { + for (x = 0; x < list->max - list->min + 1; ++x) + list->types[x] = htonl(list->types[x]); + + if (!list->map) { + if (fwrite((char *)&list->types, + (list->max - list->min + 1)*sizeof(u_long), 1, fp) != 1) { + perror(locale_file); + exit(1); + } + } + list = list->next; + } + /* + * PART 5: And finally the variable data + */ + if (fwrite((char *)new_locale.variable, + ntohl(new_locale.variable_len), 1, fp) != 1) { + perror(locale_file); + exit(1); + } + fclose(fp); + + if (!debug) + return; + + if (new_locale.encoding[0]) + fprintf(stderr, "ENCODING %s\n", new_locale.encoding); + if (new_locale.variable) + fprintf(stderr, "VARIABLE %s\n", new_locale.variable); + + fprintf(stderr, "\nMAPLOWER:\n\n"); + + for (x = 0; x < _CACHED_RUNES; ++x) { + if (isprint(maplower.map[x])) + fprintf(stderr, " '%c'", maplower.map[x]); + else if (maplower.map[x]) + fprintf(stderr, "%04x", maplower.map[x]); + else + fprintf(stderr, "%4x", 0); + if ((x & 0xf) == 0xf) + fprintf(stderr, "\n"); + else + fprintf(stderr, " "); + } + fprintf(stderr, "\n"); + + for (list = maplower.root; list; list = list->next) + fprintf(stderr, "\t%04x - %04x : %04x\n", list->min, list->max, list->map); + + fprintf(stderr, "\nMAPUPPER:\n\n"); + + for (x = 0; x < _CACHED_RUNES; ++x) { + if (isprint(mapupper.map[x])) + fprintf(stderr, " '%c'", mapupper.map[x]); + else if (mapupper.map[x]) + fprintf(stderr, "%04x", mapupper.map[x]); + else + fprintf(stderr, "%4x", 0); + if ((x & 0xf) == 0xf) + fprintf(stderr, "\n"); + else + fprintf(stderr, " "); + } + fprintf(stderr, "\n"); + + for (list = mapupper.root; list; list = list->next) + fprintf(stderr, "\t%04x - %04x : %04x\n", list->min, list->max, list->map); + + + fprintf(stderr, "\nTYPES:\n\n"); + + for (x = 0; x < _CACHED_RUNES; ++x) { + u_long r = types.map[x]; + + if (r) { + if (isprint(x)) + fprintf(stderr, " '%c': %2d", x, r & 0xff); + else + fprintf(stderr, "%04x: %2d", x, r & 0xff); + + fprintf(stderr, " %4s", (r & _A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _Q) ? "phon" : ""); + fprintf(stderr, "\n"); + } + } + + for (list = types.root; list; list = list->next) { + if (list->map && list->min + 3 < list->max) { + u_long r = list->map; + + fprintf(stderr, "%04x: %2d", list->min, r & 0xff); + + fprintf(stderr, " %4s", (r & _A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _Q) ? "phon" : ""); + fprintf(stderr, "\n...\n"); + + fprintf(stderr, "%04x: %2d", list->max, r & 0xff); + + fprintf(stderr, " %4s", (r & _A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _Q) ? "phon" : ""); + fprintf(stderr, "\n"); + } else + for (x = list->min; x <= list->max; ++x) { + u_long r = ntohl(list->types[x - list->min]); + + if (r) { + fprintf(stderr, "%04x: %2d", x, r & 0xff); + + fprintf(stderr, " %4s", (r & _A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _Q) ? "phon" : ""); + fprintf(stderr, "\n"); + } + } + } +} |
