Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/scripts/conmakehash.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 6130 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 6130 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | /* |
2 | * conmakehash.c |
3 | * |
4 | * Create arrays for initializing the kernel folded tables (using a hash |
5 | * table turned out to be to limiting...) Unfortunately we can't simply |
6 | * preinitialize the tables at compile time since kfree() cannot accept |
7 | * memory not allocated by kmalloc(), and doing our own memory management |
8 | * just for this seems like massive overkill. |
9 | * |
10 | * Copyright (C) 1995-1997 H. Peter Anvin |
11 | * |
12 | * This program is a part of the Linux kernel, and may be freely |
13 | * copied under the terms of the GNU General Public License (GPL), |
14 | * version 2, or at your option any later version. |
15 | */ |
16 | |
17 | #include <stdio.h> |
18 | #include <stdlib.h> |
19 | #include <sysexits.h> |
20 | #include <string.h> |
21 | #include <ctype.h> |
22 | |
23 | #define MAX_FONTLEN 256 |
24 | |
25 | typedef unsigned short unicode; |
26 | |
27 | void usage(char *argv0) |
28 | { |
29 | fprintf(stderr, "Usage: \n" |
30 | " %s chartable [hashsize] [hashstep] [maxhashlevel]\n", argv0); |
31 | exit(EX_USAGE); |
32 | } |
33 | |
34 | int getunicode(char **p0) |
35 | { |
36 | unsigned char *p = *p0; |
37 | |
38 | while (*p == ' ' || *p == '\t') |
39 | p++; |
40 | if (*p != 'U' || p[1] != '+' || |
41 | !isxdigit(p[2]) || !isxdigit(p[3]) || !isxdigit(p[4]) || |
42 | !isxdigit(p[5]) || isxdigit(p[6])) |
43 | return -1; |
44 | *p0 = p+6; |
45 | return strtol(p+2,0,16); |
46 | } |
47 | |
48 | unicode unitable[MAX_FONTLEN][255]; |
49 | /* Massive overkill, but who cares? */ |
50 | int unicount[MAX_FONTLEN]; |
51 | |
52 | void addpair(int fp, int un) |
53 | { |
54 | int i; |
55 | |
56 | if ( un <= 0xfffe ) |
57 | { |
58 | /* Check it isn't a duplicate */ |
59 | |
60 | for ( i = 0 ; i < unicount[fp] ; i++ ) |
61 | if ( unitable[fp][i] == un ) |
62 | return; |
63 | |
64 | /* Add to list */ |
65 | |
66 | if ( unicount[fp] > 254 ) |
67 | { |
68 | fprintf(stderr, "ERROR: Only 255 unicodes/glyph permitted!\n"); |
69 | exit(EX_DATAERR); |
70 | } |
71 | |
72 | unitable[fp][unicount[fp]] = un; |
73 | unicount[fp]++; |
74 | } |
75 | |
76 | /* otherwise: ignore */ |
77 | } |
78 | |
79 | int main(int argc, char *argv[]) |
80 | { |
81 | FILE *ctbl; |
82 | char *tblname; |
83 | char buffer[65536]; |
84 | int fontlen; |
85 | int i, nuni, nent; |
86 | int fp0, fp1, un0, un1; |
87 | char *p, *p1; |
88 | |
89 | if ( argc < 2 || argc > 5 ) |
90 | usage(argv[0]); |
91 | |
92 | if ( !strcmp(argv[1],"-") ) |
93 | { |
94 | ctbl = stdin; |
95 | tblname = "stdin"; |
96 | } |
97 | else |
98 | { |
99 | ctbl = fopen(tblname = argv[1], "r"); |
100 | if ( !ctbl ) |
101 | { |
102 | perror(tblname); |
103 | exit(EX_NOINPUT); |
104 | } |
105 | } |
106 | |
107 | /* For now we assume the default font is always 256 characters. */ |
108 | fontlen = 256; |
109 | |
110 | /* Initialize table */ |
111 | |
112 | for ( i = 0 ; i < fontlen ; i++ ) |
113 | unicount[i] = 0; |
114 | |
115 | /* Now we come to the tricky part. Parse the input table. */ |
116 | |
117 | while ( fgets(buffer, sizeof(buffer), ctbl) != NULL ) |
118 | { |
119 | if ( (p = strchr(buffer, '\n')) != NULL ) |
120 | *p = '\0'; |
121 | else |
122 | fprintf(stderr, "%s: Warning: line too long\n", tblname); |
123 | |
124 | p = buffer; |
125 | |
126 | /* |
127 | * Syntax accepted: |
128 | * <fontpos> <unicode> <unicode> ... |
129 | * <range> idem |
130 | * <range> <unicode range> |
131 | * |
132 | * where <range> ::= <fontpos>-<fontpos> |
133 | * and <unicode> ::= U+<h><h><h><h> |
134 | * and <h> ::= <hexadecimal digit> |
135 | */ |
136 | |
137 | while (*p == ' ' || *p == '\t') |
138 | p++; |
139 | if (!*p || *p == '#') |
140 | continue; /* skip comment or blank line */ |
141 | |
142 | fp0 = strtol(p, &p1, 0); |
143 | if (p1 == p) |
144 | { |
145 | fprintf(stderr, "Bad input line: %s\n", buffer); |
146 | exit(EX_DATAERR); |
147 | } |
148 | p = p1; |
149 | |
150 | while (*p == ' ' || *p == '\t') |
151 | p++; |
152 | if (*p == '-') |
153 | { |
154 | p++; |
155 | fp1 = strtol(p, &p1, 0); |
156 | if (p1 == p) |
157 | { |
158 | fprintf(stderr, "Bad input line: %s\n", buffer); |
159 | exit(EX_DATAERR); |
160 | } |
161 | p = p1; |
162 | } |
163 | else |
164 | fp1 = 0; |
165 | |
166 | if ( fp0 < 0 || fp0 >= fontlen ) |
167 | { |
168 | fprintf(stderr, |
169 | "%s: Glyph number (0x%x) larger than font length\n", |
170 | tblname, fp0); |
171 | exit(EX_DATAERR); |
172 | } |
173 | if ( fp1 && (fp1 < fp0 || fp1 >= fontlen) ) |
174 | { |
175 | fprintf(stderr, |
176 | "%s: Bad end of range (0x%x)\n", |
177 | tblname, fp1); |
178 | exit(EX_DATAERR); |
179 | } |
180 | |
181 | if (fp1) |
182 | { |
183 | /* we have a range; expect the word "idem" or a Unicode range of the |
184 | same length */ |
185 | while (*p == ' ' || *p == '\t') |
186 | p++; |
187 | if (!strncmp(p, "idem", 4)) |
188 | { |
189 | for (i=fp0; i<=fp1; i++) |
190 | addpair(i,i); |
191 | p += 4; |
192 | } |
193 | else |
194 | { |
195 | un0 = getunicode(&p); |
196 | while (*p == ' ' || *p == '\t') |
197 | p++; |
198 | if (*p != '-') |
199 | { |
200 | fprintf(stderr, |
201 | "%s: Corresponding to a range of font positions, there should be a Unicode range\n", |
202 | tblname); |
203 | exit(EX_DATAERR); |
204 | } |
205 | p++; |
206 | un1 = getunicode(&p); |
207 | if (un0 < 0 || un1 < 0) |
208 | { |
209 | fprintf(stderr, |
210 | "%s: Bad Unicode range corresponding to font position range 0x%x-0x%x\n", |
211 | tblname, fp0, fp1); |
212 | exit(EX_DATAERR); |
213 | } |
214 | if (un1 - un0 != fp1 - fp0) |
215 | { |
216 | fprintf(stderr, |
217 | "%s: Unicode range U+%x-U+%x not of the same length as font position range 0x%x-0x%x\n", |
218 | tblname, un0, un1, fp0, fp1); |
219 | exit(EX_DATAERR); |
220 | } |
221 | for(i=fp0; i<=fp1; i++) |
222 | addpair(i,un0-fp0+i); |
223 | } |
224 | } |
225 | else |
226 | { |
227 | /* no range; expect a list of unicode values for a single font position */ |
228 | |
229 | while ( (un0 = getunicode(&p)) >= 0 ) |
230 | addpair(fp0, un0); |
231 | } |
232 | while (*p == ' ' || *p == '\t') |
233 | p++; |
234 | if (*p && *p != '#') |
235 | fprintf(stderr, "%s: trailing junk (%s) ignored\n", tblname, p); |
236 | } |
237 | |
238 | /* Okay, we hit EOF, now output hash table */ |
239 | |
240 | fclose(ctbl); |
241 | |
242 | |
243 | /* Compute total size of Unicode list */ |
244 | nuni = 0; |
245 | for ( i = 0 ; i < fontlen ; i++ ) |
246 | nuni += unicount[i]; |
247 | |
248 | printf("\ |
249 | /*\n\ |
250 | * Do not edit this file; it was automatically generated by\n\ |
251 | *\n\ |
252 | * conmakehash %s > [this file]\n\ |
253 | *\n\ |
254 | */\n\ |
255 | \n\ |
256 | #include <linux/types.h>\n\ |
257 | \n\ |
258 | u8 dfont_unicount[%d] = \n\ |
259 | {\n\t", argv[1], fontlen); |
260 | |
261 | for ( i = 0 ; i < fontlen ; i++ ) |
262 | { |
263 | printf("%3d", unicount[i]); |
264 | if ( i == fontlen-1 ) |
265 | printf("\n};\n"); |
266 | else if ( i % 8 == 7 ) |
267 | printf(",\n\t"); |
268 | else |
269 | printf(", "); |
270 | } |
271 | |
272 | printf("\nu16 dfont_unitable[%d] = \n{\n\t", nuni); |
273 | |
274 | fp0 = 0; |
275 | nent = 0; |
276 | for ( i = 0 ; i < nuni ; i++ ) |
277 | { |
278 | while ( nent >= unicount[fp0] ) |
279 | { |
280 | fp0++; |
281 | nent = 0; |
282 | } |
283 | printf("0x%04x", unitable[fp0][nent++]); |
284 | if ( i == nuni-1 ) |
285 | printf("\n};\n"); |
286 | else if ( i % 8 == 7 ) |
287 | printf(",\n\t"); |
288 | else |
289 | printf(", "); |
290 | } |
291 | |
292 | exit(EX_OK); |
293 | } |