diff options
author | Cameron Katri <me@cameronkatri.com> | 2021-05-09 14:20:58 -0400 |
---|---|---|
committer | Cameron Katri <me@cameronkatri.com> | 2021-05-09 14:20:58 -0400 |
commit | 5fd83771641d15c418f747bd343ba6738d3875f7 (patch) | |
tree | 5abf0f78f680d9837dbd93d4d4c3933bb7509599 /adv_cmds/mklocale | |
download | apple_cmds-5fd83771641d15c418f747bd343ba6738d3875f7.tar.gz apple_cmds-5fd83771641d15c418f747bd343ba6738d3875f7.tar.zst apple_cmds-5fd83771641d15c418f747bd343ba6738d3875f7.zip |
Import macOS userland
adv_cmds-176
basic_cmds-55
bootstrap_cmds-116.100.1
developer_cmds-66
diskdev_cmds-667.40.1
doc_cmds-53.60.1
file_cmds-321.40.3
mail_cmds-35
misc_cmds-34
network_cmds-606.40.1
patch_cmds-17
remote_cmds-63
shell_cmds-216.60.1
system_cmds-880.60.2
text_cmds-106
Diffstat (limited to 'adv_cmds/mklocale')
-rw-r--r-- | adv_cmds/mklocale/extern.h | 40 | ||||
-rw-r--r-- | adv_cmds/mklocale/ldef.h | 68 | ||||
-rw-r--r-- | adv_cmds/mklocale/lex.l | 179 | ||||
-rw-r--r-- | adv_cmds/mklocale/mklocale.1 | 308 | ||||
-rw-r--r-- | adv_cmds/mklocale/runefile.h | 87 | ||||
-rw-r--r-- | adv_cmds/mklocale/yacc.y | 929 |
6 files changed, 1611 insertions, 0 deletions
diff --git a/adv_cmds/mklocale/extern.h b/adv_cmds/mklocale/extern.h new file mode 100644 index 0000000..f2037dd --- /dev/null +++ b/adv_cmds/mklocale/extern.h @@ -0,0 +1,40 @@ +/*- + * 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. + * + * $FreeBSD: src/usr.bin/mklocale/extern.h,v 1.1 2002/04/28 12:34:54 markm Exp $ + */ + +int yylex(void); +int yyparse(void); diff --git a/adv_cmds/mklocale/ldef.h b/adv_cmds/mklocale/ldef.h new file mode 100644 index 0000000..da9e015 --- /dev/null +++ b/adv_cmds/mklocale/ldef.h @@ -0,0 +1,68 @@ +/*- + * 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 + * $FreeBSD: src/usr.bin/mklocale/ldef.h,v 1.5 2007/11/07 14:46:22 rafan Exp $ + */ + +#include <sys/types.h> +#ifdef __APPLE__ +#include <inttypes.h> +#include <limits.h> +#endif /* __APPLE__ */ +#include "runefile.h" + +/* + * This should look a LOT like a _RuneEntry + */ +typedef struct rune_list { + int32_t min; + int32_t max; + int32_t map; + uint32_t *types; + struct rune_list *next; +} rune_list; + +typedef struct rune_map { + uint32_t map[_CACHED_RUNES]; + rune_list *root; +} rune_map; + +#ifdef __APPLE__ +typedef struct { + char name[CHARCLASS_NAME_MAX]; + uint32_t mask; +} rune_charclass; +#endif /* __APPLE__ */ diff --git a/adv_cmds/mklocale/lex.l b/adv_cmds/mklocale/lex.l new file mode 100644 index 0000000..9ffbaca --- /dev/null +++ b/adv_cmds/mklocale/lex.l @@ -0,0 +1,179 @@ +%{ +/*- + * 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 +#if 0 +static char sccsid[] = "@(#)lex.l 8.1 (Berkeley) 6/6/93"; +#endif +#endif /* not lint */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD: src/usr.bin/mklocale/lex.l,v 1.9 2005/02/26 21:47:54 ru Exp $"); + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> + +#include "ldef.h" +#include "y.tab.h" +#include "extern.h" +%} + +ODIGIT [0-7] +DIGIT [0-9] +XDIGIT [0-9a-fA-F] +W [\t\n\r ] + +%% +\'.\' { yylval.rune = (unsigned char)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 = _CTYPE_A|_CTYPE_R|_CTYPE_G; + return(LIST); } +CONTROL { yylval.i = _CTYPE_C; + return(LIST); } +DIGIT { yylval.i = _CTYPE_D|_CTYPE_R|_CTYPE_G; + return(LIST); } +GRAPH { yylval.i = _CTYPE_G|_CTYPE_R; + return(LIST); } +LOWER { yylval.i = _CTYPE_L|_CTYPE_R|_CTYPE_G; + return(LIST); } +PUNCT { yylval.i = _CTYPE_P|_CTYPE_R|_CTYPE_G; + return(LIST); } +SPACE { yylval.i = _CTYPE_S; + return(LIST); } +UPPER { yylval.i = _CTYPE_U|_CTYPE_R|_CTYPE_G; + return(LIST); } +XDIGIT { yylval.i = _CTYPE_X|_CTYPE_R|_CTYPE_G; + return(LIST); } +BLANK { yylval.i = _CTYPE_B; + return(LIST); } +PRINT { yylval.i = _CTYPE_R; + return(LIST); } +IDEOGRAM { yylval.i = _CTYPE_I|_CTYPE_R|_CTYPE_G; + return(LIST); } +SPECIAL { yylval.i = _CTYPE_T|_CTYPE_R|_CTYPE_G; + return(LIST); } +PHONOGRAM { yylval.i = _CTYPE_Q|_CTYPE_R|_CTYPE_G; + return(LIST); } +SWIDTH0 { yylval.i = _CTYPE_SW0; return(LIST); } +SWIDTH1 { yylval.i = _CTYPE_SW1; return(LIST); } +SWIDTH2 { yylval.i = _CTYPE_SW2; return(LIST); } +SWIDTH3 { yylval.i = _CTYPE_SW3; 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); } + +CHARCLASS { return(CHARCLASS); } + +\".*\" { 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) +int +yywrap() +{ + return(1); +} +#endif diff --git a/adv_cmds/mklocale/mklocale.1 b/adv_cmds/mklocale/mklocale.1 new file mode 100644 index 0000000..8f2ec0e --- /dev/null +++ b/adv_cmds/mklocale/mklocale.1 @@ -0,0 +1,308 @@ +.\" 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 +.\" $FreeBSD: src/usr.bin/mklocale/mklocale.1,v 1.28 2008/01/22 00:04:50 ache Exp $ +.\" +.Dd October 17, 2004 +.Dt MKLOCALE 1 +.Os +.Sh NAME +.Nm mklocale +.Nd make LC_CTYPE locale files +.Sh SYNOPSIS +.Nm +.Op Fl d +.Ar "< src-file" +.Ar "> language/LC_CTYPE" +.Nm +.Op Fl d +.Fl o +.Ar language/LC_CTYPE +.Ar src-file +.Sh DESCRIPTION +The +.Nm +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 +.Pa /usr/share/locale/ Ns Ar language Ns Pa /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 +Following options are available: +.Bl -tag -width indent +.It Fl d +Turns on debugging messages. +.It Fl o +Specify output file. +.El +.Pp +Besides the keywords which will be listed below, +the following are valid tokens in +.Ar src-file : +.Bl -tag -width ".Ar literal" +.It Dv RUNE +A +.Dv RUNE +may be any of the following: +.Bl -tag -width ".Ar 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 ".Dv <\|\|(\|\|[" +.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 +.Pp +Key words which should only appear once are: +.Bl -tag -width ".Dv 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 ".Dv MSKanji" +.It Dv ASCII +American Standard Code for Information Interchange. +.It Dv BIG5 +The +.Dq Big5 +encoding of Chinese. +.It Dv EUC +.Dv EUC +encoding as used by several +vendors of +.Ux +systems. +.It Dv GB18030 +PRC national standard for encoding of Chinese text. +.It Dv GB2312 +Older PRC national standard for encoding Chinese text. +.It Dv GBK +A widely used encoding method for Chinese text, +backwards compatible with GB\ 2312-1980. +.It Dv MSKanji +The method of encoding Japanese used by Microsoft, +loosely based on JIS. +Also known as +.Dq "Shift JIS" +and +.Dq SJIS . +.It Dv NONE +No translation and the default. +.It Dv UTF-8 +The +.Dv UTF-8 +transformation format of +.Tn ISO +10646 +as defined by RFC 2279. +.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 5 +for further details. +.It Dv INVALID +(obsolete) +A single +.Dv RUNE +follows and is used as the invalid rune for this locale. +.El +.Pp +The following keywords may appear multiple times and have the following +format for data: +.Bl -tag -width ".Dv <RUNE1 THRU RUNEn : RUNE2>" -offset indent +.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 +.Bl -tag -width ".Dv 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 +.Ql 0 +would map to the decimal value 0. +Only values up to 255 +are allowed. +.El +.Pp +The following keywords may appear multiple times and have the following +format for data: +.Bl -tag -width ".Dv RUNE1 THRU RUNEn" -offset indent +.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 +.Bl -tag -width ".Dv 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. +.It Dv SWIDTH0 +Defines runes with display width 0. +.It Dv SWIDTH1 +Defines runes with display width 1. +.It Dv SWIDTH2 +Defines runes with display width 2. +.It Dv SWIDTH3 +Defines runes with display width 3. +.El +.Pp +If no display width explicitly defined, width 1 assumed +for printable runes by default. +.Sh SEE ALSO +.Xr colldef 1 , +.Xr setlocale 3 , +.Xr wcwidth 3 , +.Xr big5 5 , +.Xr euc 5 , +.Xr gb18030 5 , +.Xr gb2312 5 , +.Xr gbk 5 , +.Xr mskanji 5 , +.Xr utf8 5 +.Sh HISTORY +The +.Nm +utility first appeared in +.Bx 4.4 . +.Sh BUGS +The +.Nm +utility is overly simplistic. diff --git a/adv_cmds/mklocale/runefile.h b/adv_cmds/mklocale/runefile.h new file mode 100644 index 0000000..6b3f9f7 --- /dev/null +++ b/adv_cmds/mklocale/runefile.h @@ -0,0 +1,87 @@ +/*- + * Copyright (c) 2005 Ruslan Ermilov + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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. + * + * $FreeBSD: src/lib/libc/locale/runefile.h,v 1.1 2005/05/16 09:32:41 ru Exp $ + */ + +#ifndef _RUNEFILE_H_ +#define _RUNEFILE_H_ + +#include <sys/types.h> + +#ifndef _CACHED_RUNES +#define _CACHED_RUNES (1 << 8) +#endif + +typedef struct { + int32_t min; + int32_t max; + int32_t map; +#ifdef __APPLE__ + int32_t __types_fake; +#endif /* __APPLE__ */ +} _FileRuneEntry; + +typedef struct { + char magic[8]; + char encoding[32]; + +#ifdef __APPLE__ + int32_t __sgetrune_fake; + int32_t __sputrune_fake; + int32_t __invalid_rune; +#endif /* __APPLE__ */ + + uint32_t runetype[_CACHED_RUNES]; + int32_t maplower[_CACHED_RUNES]; + int32_t mapupper[_CACHED_RUNES]; + + int32_t runetype_ext_nranges; +#ifdef __APPLE__ + int32_t __runetype_ext_ranges_fake; +#endif /* __APPLE__ */ + int32_t maplower_ext_nranges; +#ifdef __APPLE__ + int32_t __maplower_ext_ranges_fake; +#endif /* __APPLE__ */ + int32_t mapupper_ext_nranges; +#ifdef __APPLE__ + int32_t __mapupper_ext_ranges_fake; +#endif /* __APPLE__ */ + +#ifdef __APPLE__ + int32_t __variable_fake; +#endif /* __APPLE__ */ + int32_t variable_len; + +#ifdef __APPLE__ + int32_t ncharclasses; + int32_t __charclasses_fake; +#endif /* __APPLE__ */ +} _FileRuneLocale; + +#define _FILE_RUNE_MAGIC_1 "RuneMag1" + +#endif /* !_RUNEFILE_H_ */ diff --git a/adv_cmds/mklocale/yacc.y b/adv_cmds/mklocale/yacc.y new file mode 100644 index 0000000..f76498d --- /dev/null +++ b/adv_cmds/mklocale/yacc.y @@ -0,0 +1,929 @@ +%{ +/*- + * 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 +#if 0 +static char sccsid[] = "@(#)yacc.y 8.1 (Berkeley) 6/6/93"; +#endif /* 0 */ +#endif /* not lint */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD: src/usr.bin/mklocale/yacc.y,v 1.28 2008/01/22 00:04:50 ache Exp $"); + +#include <arpa/inet.h> + +#include <ctype.h> +#include <err.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "ldef.h" +#include "extern.h" +#include "runefile.h" + +#define MAX_CHARCLASS 4 +#define CHARCLASSBIT 4 + +static void *xmalloc(unsigned int sz); +static uint32_t *xlalloc(unsigned int sz); +void yyerror(const char *s); +static uint32_t *xrelalloc(uint32_t *old, unsigned int sz); +static void dump_tables(void); +static void cleanout(void); + +const char *locale_file = "<stdout>"; + +rune_map maplower = { { 0 }, NULL }; +rune_map mapupper = { { 0 }, NULL }; +rune_map types = { { 0 }, NULL }; + +_FileRuneLocale new_locale = { "", "", 0, 0, 0, {}, {}, {}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +char *variable = NULL; + +rune_charclass charclasses[MAX_CHARCLASS]; +int charclass_index = 0; + +void set_map(rune_map *, rune_list *, uint32_t); +void set_digitmap(rune_map *, rune_list *); +void add_map(rune_map *, rune_list *, uint32_t); +static void usage(void); +%} + +%union { + int32_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 CHARCLASS +%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 + { if (strcmp($2, "NONE") && + strcmp($2, "ASCII") && + strcmp($2, "UTF-8") && + strcmp($2, "EUC") && + strcmp($2, "GBK") && + strcmp($2, "GB18030") && + strcmp($2, "GB2312") && + strcmp($2, "BIG5") && + strcmp($2, "MSKanji") && + strcmp($2, "UTF2")) + warnx("ENCODING %s is not supported by libc", $2); + strncpy(new_locale.encoding, $2, + sizeof(new_locale.encoding)); } + | VARIABLE + { new_locale.variable_len = strlen($1) + 1; + variable = xmalloc(new_locale.variable_len); + strcpy(variable, $1); + } + | INVALID RUNE + { warnx("the INVALID keyword is deprecated"); } + | LIST list + { set_map(&types, $2, $1); } + | MAPLOWER map + { set_map(&maplower, $2, 0); } + | MAPUPPER map + { set_map(&mapupper, $2, 0); } + | DIGITMAP map + { + if (($2->map >= 0) && ($2->map <= 255)) { /* Data corruption otherwise */ + set_digitmap(&types, $2); + } + } + | CHARCLASS STRING list + { + int i; + if (strlen($2) > CHARCLASS_NAME_MAX) + errx(1, "Exceeded maximum charclass name size (%d) \"%s\"", CHARCLASS_NAME_MAX, $2); + for(i = 0; i < charclass_index; i++) + if (strncmp(charclasses[i].name, $2, CHARCLASS_NAME_MAX) == 0) + break; + if (i >= charclass_index) { + if (charclass_index >= MAX_CHARCLASS) + errx(1, "Exceeded maximum number of charclasses (%d)", MAX_CHARCLASS); + strncpy(charclasses[charclass_index].name, $2, CHARCLASS_NAME_MAX); + charclasses[charclass_index].mask = (1 << (charclass_index + CHARCLASSBIT)); + charclass_index++; + } + set_map(&types, $3, charclasses[i].mask); + } + ; + +list : RUNE + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $1; + $$->max = $1; + $$->next = 0; + } + | RUNE THRU RUNE + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $1; + $$->max = $3; + $$->next = 0; + } + | list RUNE + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $2; + $$->next = $1; + } + | list RUNE THRU RUNE + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $4; + $$->next = $1; + } + ; + +map : LBRK RUNE RUNE RBRK + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $2; + $$->map = $3; + $$->next = 0; + } + | map LBRK RUNE RUNE RBRK + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $3; + $$->max = $3; + $$->map = $4; + $$->next = $1; + } + | LBRK RUNE THRU RUNE ':' RUNE RBRK + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $2; + $$->max = $4; + $$->map = $6; + $$->next = 0; + } + | map LBRK RUNE THRU RUNE ':' RUNE RBRK + { + $$ = (rune_list *)xmalloc(sizeof(rune_list)); + $$->min = $3; + $$->max = $5; + $$->map = $7; + $$->next = $1; + } + ; +%% + +int debug; +FILE *fp; + +static void +cleanout(void) +{ + if (fp != NULL) + unlink(locale_file); +} + +int +main(int ac, char *av[]) +{ + int x; + + fp = stdout; + + while ((x = getopt(ac, av, "do:")) != -1) { + switch(x) { + case 'd': + debug = 1; + break; + case 'o': + locale_file = optarg; + if ((fp = fopen(locale_file, "w")) == NULL) + err(1, "%s: fopen", locale_file); + atexit(cleanout); + break; + default: + usage(); + } + } + + switch (ac - optind) { + case 0: + break; + case 1: + if (freopen(av[optind], "r", stdin) == 0) + err(1, "%s: freopen", av[optind]); + break; + default: + usage(); + } + for (x = 0; x < _CACHED_RUNES; ++x) { + mapupper.map[x] = x; + maplower.map[x] = x; + } + memcpy(new_locale.magic, _RUNE_MAGIC_A, sizeof(new_locale.magic)); + + yyparse(); + + return(0); +} + +static void +usage() +{ + fprintf(stderr, "usage: mklocale [-d] [-o output] [source]\n"); + exit(1); +} + +void +yyerror(s) + const char *s; +{ + fprintf(stderr, "%s\n", s); +} + +static void * +xmalloc(sz) + unsigned int sz; +{ + void *r = malloc(sz); + if (!r) + errx(1, "xmalloc"); + return(r); +} + +static uint32_t * +xlalloc(sz) + unsigned int sz; +{ + uint32_t *r = (uint32_t *)malloc(sz * sizeof(uint32_t)); + if (!r) + errx(1, "xlalloc"); + return(r); +} + +static uint32_t * +xrelalloc(old, sz) + uint32_t *old; + unsigned int sz; +{ + uint32_t *r = (uint32_t *)realloc((char *)old, + sz * sizeof(uint32_t)); + if (!r) + errx(1, "xrelalloc"); + return(r); +} + +void +set_map(map, list, flag) + rune_map *map; + rune_list *list; + uint32_t 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; +{ + int32_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; + uint32_t flag; +{ + int32_t i; + rune_list *lr = 0; + rune_list *r; + int32_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; + } + errx(1, "error: conflicting map entries"); + } + + 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 = list->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); + } +} + +static void +dump_tables() +{ + int x, first_d, curr_d; + 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 ((int32_t)list->types[x] != list->map) { + list->map = 0; + break; + } + } + } + + first_d = curr_d = -1; + for (x = 0; x < _CACHED_RUNES; ++x) { + uint32_t r = types.map[x]; + + if (r & _CTYPE_D) { + if (first_d < 0) + first_d = curr_d = x; + else if (x != curr_d + 1) + errx(1, "error: DIGIT range is not contiguous"); + else if (x - first_d > 9) + errx(1, "error: DIGIT range is too big"); + else + curr_d++; + if (!(r & _CTYPE_X)) + errx(1, + "error: DIGIT range is not a subset of XDIGIT range"); + } + } + if (first_d < 0) + errx(1, "error: no DIGIT range defined in the single byte area"); + else if (curr_d - first_d < 9) + errx(1, "error: DIGIT range is too small in the single byte area"); + + new_locale.ncharclasses = htonl(charclass_index); + + /* + * 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 _FileRuneLocale structure + */ + if (fwrite((char *)&new_locale, sizeof(new_locale), 1, fp) != 1) { + err(1, "%s: _FileRuneLocale structure", locale_file); + } + /* + * PART 2: The runetype_ext structures (not the actual tables) + */ + list = types.root; + + while (list) { + _FileRuneEntry re; + + re.min = htonl(list->min); + re.max = htonl(list->max); + re.map = htonl(list->map); +#ifdef __APPLE__ + re.__types_fake = 0; +#endif + + if (fwrite((char *)&re, sizeof(re), 1, fp) != 1) { + err(1, "%s: runetype_ext structures", locale_file); + } + + list = list->next; + } + /* + * PART 3: The maplower_ext structures + */ + list = maplower.root; + + while (list) { + _FileRuneEntry re; + + re.min = htonl(list->min); + re.max = htonl(list->max); + re.map = htonl(list->map); +#ifdef __APPLE__ + re.__types_fake = 0; +#endif + + if (fwrite((char *)&re, sizeof(re), 1, fp) != 1) { + err(1, "%s: maplower_ext structures", locale_file); + } + + list = list->next; + } + /* + * PART 4: The mapupper_ext structures + */ + list = mapupper.root; + + while (list) { + _FileRuneEntry re; + + re.min = htonl(list->min); + re.max = htonl(list->max); + re.map = htonl(list->map); +#ifdef __APPLE__ + re.__types_fake = 0; +#endif + + if (fwrite((char *)&re, sizeof(re), 1, fp) != 1) { + err(1, "%s: mapupper_ext structures", locale_file); + } + + 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(uint32_t), + 1, fp) != 1) { + err(1, "%s: runetype_ext tables", locale_file); + } + } + list = list->next; + } + /* + * PART 6: The charclass names table + */ + for (x = 0; x < charclass_index; ++x) { + charclasses[x].mask = ntohl(charclasses[x].mask); + if (fwrite((char *)&charclasses[x], sizeof(rune_charclass), 1, fp) != 1) { + err(1, "%s: charclass names tables", locale_file); + } + } + /* + * PART 7: And finally the variable data + * SUSv3 says fwrite returns zero when either size or nitems is zero. + */ + if (ntohl(new_locale.variable_len) > 0 && fwrite(variable, + ntohl(new_locale.variable_len), 1, fp) != 1) { + err(1, "%s: variable data", locale_file); + } + if (fclose(fp) != 0) { + err(1, "%s: fclose", locale_file); + } + fp = NULL; + + if (!debug) + return; + + if (new_locale.encoding[0]) + fprintf(stderr, "ENCODING %s\n", new_locale.encoding); + if (variable) + fprintf(stderr, "VARIABLE %s\n", variable); + + fprintf(stderr, "\nMAPLOWER:\n\n"); + + for (x = 0; x < _CACHED_RUNES; ++x) { + if (isprint(maplower.map[x])) + fprintf(stderr, " '%c'", (int)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'", (int)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) { + uint32_t r = types.map[x]; + + if (r) { + if (isprint(x)) + fprintf(stderr, " '%c': %2d", x, (int)(r & 0xff)); + else + fprintf(stderr, "%04x: %2d", x, (int)(r & 0xff)); + + fprintf(stderr, " %4s", (r & _CTYPE_A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_Q) ? "phon" : ""); + fprintf(stderr, "\n"); + } + } + + for (list = types.root; list; list = list->next) { + if (list->map && list->min + 3 < list->max) { + uint32_t r = list->map; + + fprintf(stderr, "%04x: %2d", + (uint32_t)list->min, (int)(r & 0xff)); + + fprintf(stderr, " %4s", (r & _CTYPE_A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_Q) ? "phon" : ""); + fprintf(stderr, "\n...\n"); + + fprintf(stderr, "%04x: %2d", + (uint32_t)list->max, (int)(r & 0xff)); + + fprintf(stderr, " %4s", (r & _CTYPE_A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_Q) ? "phon" : ""); + fprintf(stderr, "\n"); + } else + for (x = list->min; x <= list->max; ++x) { + uint32_t r = ntohl(list->types[x - list->min]); + + if (r) { + fprintf(stderr, "%04x: %2d", x, (int)(r & 0xff)); + + fprintf(stderr, " %4s", (r & _CTYPE_A) ? "alph" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_C) ? "ctrl" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_D) ? "dig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_G) ? "graf" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_L) ? "low" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_P) ? "punc" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_S) ? "spac" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_U) ? "upp" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_X) ? "xdig" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_B) ? "blnk" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_R) ? "prnt" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_I) ? "ideo" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_T) ? "spec" : ""); + fprintf(stderr, " %4s", (r & _CTYPE_Q) ? "phon" : ""); + fprintf(stderr, "\n"); + } + } + } +} |