Annotation of src/usr.bin/mklocale/yacc.y, Revision 1.2
1.1 espie 1: /* $NetBSD: yacc.y,v 1.24 2004/01/05 23:23:36 jmmv Exp $ */
2:
3: %{
4: /*-
5: * Copyright (c) 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * This code is derived from software contributed to Berkeley by
9: * Paul Borman at Krystal Technologies.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. Neither the name of the University nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: */
35:
36: #include <sys/cdefs.h>
37:
38: #include <sys/types.h>
39: #include <netinet/in.h> /* Needed by <arpa/inet.h> on NetBSD 1.5. */
40: #include <arpa/inet.h> /* Needed for htonl on POSIX systems. */
41:
42: #include <err.h>
43: #include "locale/runetype.h"
44: #include <stddef.h>
45: #include <stdio.h>
46: #include <stdlib.h>
47: #include <string.h>
48: #include <unistd.h>
49: #include <ctype.h>
50:
51: #include "ldef.h"
52:
53: const char *locale_file = "<stdout>";
54:
55: rune_map maplower = { { 0, }, };
56: rune_map mapupper = { { 0, }, };
57: rune_map types = { { 0, }, };
58:
59: _RuneLocale new_locale = { { 0, }, };
60:
61: rune_t charsetbits = (rune_t)0x00000000;
62: #if 0
63: rune_t charsetmask = (rune_t)0x0000007f;
64: #endif
65: rune_t charsetmask = (rune_t)0xffffffff;
66:
67: void set_map(rune_map *, rune_list *, u_int32_t);
68: void set_digitmap(rune_map *, rune_list *);
69: void add_map(rune_map *, rune_list *, u_int32_t);
70:
71: int main(int, char *[]);
72: int yyerror(const char *s);
73: void *xmalloc(size_t sz);
74: u_int32_t *xlalloc(size_t sz);
75: u_int32_t *xrelalloc(u_int32_t *old, size_t sz);
76: void dump_tables(void);
77: int yyparse(void);
78: extern int yylex(void);
79: %}
80:
81: %union {
82: rune_t rune;
83: int i;
84: char *str;
85:
86: rune_list *list;
87: }
88:
89: %token <rune> RUNE
90: %token LBRK
91: %token RBRK
92: %token THRU
93: %token MAPLOWER
94: %token MAPUPPER
95: %token DIGITMAP
96: %token <i> LIST
97: %token <str> VARIABLE
98: %token CHARSET
99: %token ENCODING
100: %token INVALID
101: %token <str> STRING
102:
103: %type <list> list
104: %type <list> map
105:
106:
107: %%
108:
109: locale : /* empty */
110: | table
111: { dump_tables(); }
112: ;
113:
114: table : entry
115: | table entry
116: ;
117:
118: entry : ENCODING STRING
119: { strncpy(new_locale.rl_encoding, $2, sizeof(new_locale.rl_encoding)); }
120: | VARIABLE
121: { new_locale.rl_variable_len = strlen($1) + 1;
122: new_locale.rl_variable = strdup($1);
123: }
124: | CHARSET RUNE
125: { charsetbits = $2; charsetmask = 0x0000007f; }
126: | CHARSET RUNE RUNE
127: { charsetbits = $2; charsetmask = $3; }
128: | CHARSET STRING
129: { int final = $2[strlen($2) - 1] & 0x7f;
130: charsetbits = final << 24;
131: if ($2[0] == '$') {
132: charsetmask = 0x00007f7f;
133: if (strchr(",-./", $2[1]))
134: charsetbits |= 0x80;
135: if (0xd0 <= final && final <= 0xdf)
136: charsetmask |= 0x007f0000;
137: } else {
138: charsetmask = 0x0000007f;
139: if (strchr(",-./", $2[0]))
140: charsetbits |= 0x80;
141: if (strlen($2) == 2 && $2[0] == '!')
142: charsetbits |= ((0x80 | $2[0]) << 16);
143: }
144:
145: /*
146: * special rules
147: */
148: if (charsetbits == ('B' << 24)
149: && charsetmask == 0x0000007f) {
150: /*ASCII: 94B*/
151: charsetbits = 0;
152: charsetmask = 0x0000007f;
153: } else if (charsetbits == (('A' << 24) | 0x80)
154: && charsetmask == 0x0000007f) {
155: /*Latin1: 96A*/
156: charsetbits = 0x80;
157: charsetmask = 0x0000007f;
158: }
159: }
160: | INVALID RUNE
161: { new_locale.rl_invalid_rune = $2; }
162: | LIST list
163: { set_map(&types, $2, $1); }
164: | MAPLOWER map
165: { set_map(&maplower, $2, 0); }
166: | MAPUPPER map
167: { set_map(&mapupper, $2, 0); }
168: | DIGITMAP map
169: { set_digitmap(&types, $2); }
170: ;
171:
172: list : RUNE
173: {
174: $$ = (rune_list *)malloc(sizeof(rune_list));
175: $$->min = ($1 & charsetmask) | charsetbits;
176: $$->max = ($1 & charsetmask) | charsetbits;
177: $$->next = 0;
178: }
179: | RUNE THRU RUNE
180: {
181: $$ = (rune_list *)malloc(sizeof(rune_list));
182: $$->min = ($1 & charsetmask) | charsetbits;
183: $$->max = ($3 & charsetmask) | charsetbits;
184: $$->next = 0;
185: }
186: | list RUNE
187: {
188: $$ = (rune_list *)malloc(sizeof(rune_list));
189: $$->min = ($2 & charsetmask) | charsetbits;
190: $$->max = ($2 & charsetmask) | charsetbits;
191: $$->next = $1;
192: }
193: | list RUNE THRU RUNE
194: {
195: $$ = (rune_list *)malloc(sizeof(rune_list));
196: $$->min = ($2 & charsetmask) | charsetbits;
197: $$->max = ($4 & charsetmask) | charsetbits;
198: $$->next = $1;
199: }
200: ;
201:
202: map : LBRK RUNE RUNE RBRK
203: {
204: $$ = (rune_list *)malloc(sizeof(rune_list));
205: $$->min = ($2 & charsetmask) | charsetbits;
206: $$->max = ($2 & charsetmask) | charsetbits;
207: $$->map = $3;
208: $$->next = 0;
209: }
210: | map LBRK RUNE RUNE RBRK
211: {
212: $$ = (rune_list *)malloc(sizeof(rune_list));
213: $$->min = ($3 & charsetmask) | charsetbits;
214: $$->max = ($3 & charsetmask) | charsetbits;
215: $$->map = $4;
216: $$->next = $1;
217: }
218: | LBRK RUNE THRU RUNE ':' RUNE RBRK
219: {
220: $$ = (rune_list *)malloc(sizeof(rune_list));
221: $$->min = ($2 & charsetmask) | charsetbits;
222: $$->max = ($4 & charsetmask) | charsetbits;
223: $$->map = $6;
224: $$->next = 0;
225: }
226: | map LBRK RUNE THRU RUNE ':' RUNE RBRK
227: {
228: $$ = (rune_list *)malloc(sizeof(rune_list));
229: $$->min = ($3 & charsetmask) | charsetbits;
230: $$->max = ($5 & charsetmask) | charsetbits;
231: $$->map = $7;
232: $$->next = $1;
233: }
234: ;
235: %%
236:
237: int debug = 0;
238: FILE *ofile;
239:
240: int
241: main(int ac, char *av[])
242: {
243: int x;
244:
245: extern char *optarg;
246: extern int optind;
247:
1.2 ! deraadt 248: while ((x = getopt(ac, av, "do:")) != -1) {
1.1 espie 249: switch(x) {
250: case 'd':
251: debug = 1;
252: break;
253: case 'o':
254: locale_file = optarg;
255: if ((ofile = fopen(locale_file, "w")) == 0)
256: err(1, "unable to open output file %s", locale_file);
257: break;
258: default:
259: usage:
260: fprintf(stderr, "usage: mklocale [-d] [-o output] [source]\n");
261: exit(1);
262: }
263: }
264:
265: switch (ac - optind) {
266: case 0:
267: break;
268: case 1:
269: if (freopen(av[optind], "r", stdin) == 0)
270: err(1, "unable to open input file %s", av[optind]);
271: break;
272: default:
273: goto usage;
274: }
275: for (x = 0; x < _CACHED_RUNES; ++x) {
276: mapupper.map[x] = x;
277: maplower.map[x] = x;
278: }
279: new_locale.rl_invalid_rune = _DEFAULT_INVALID_RUNE;
280: memcpy(new_locale.rl_magic, _RUNE_MAGIC_1, sizeof(new_locale.rl_magic));
281:
282: yyparse();
283:
284: return 0;
285: }
286:
287: int
288: yyerror(const char *s)
289: {
290: fprintf(stderr, "%s\n", s);
291:
292: return 0;
293: }
294:
295: void *
296: xmalloc(size_t sz)
297: {
298: void *r = malloc(sz);
299: if (!r) {
300: perror("xmalloc");
301: abort();
302: }
303: return(r);
304: }
305:
306: u_int32_t *
307: xlalloc(size_t sz)
308: {
309: u_int32_t *r = (u_int32_t *)malloc(sz * sizeof(u_int32_t));
310: if (!r) {
311: perror("xlalloc");
312: abort();
313: }
314: return(r);
315: }
316:
317: u_int32_t *
318: xrelalloc(u_int32_t *old, size_t sz)
319: {
320: u_int32_t *r = (u_int32_t *)realloc(old, sz * sizeof(u_int32_t));
321: if (!r) {
322: perror("xrelalloc");
323: abort();
324: }
325: return(r);
326: }
327:
328: void
329: set_map(rune_map *map, rune_list *list, u_int32_t flag)
330: {
331: list->map &= charsetmask;
332: list->map |= charsetbits;
333: while (list) {
334: rune_list *nlist = list->next;
335: add_map(map, list, flag);
336: list = nlist;
337: }
338: }
339:
340: void
341: set_digitmap(rune_map *map, rune_list *list)
342: {
343: rune_t i;
344:
345: while (list) {
346: rune_list *nlist = list->next;
347: for (i = list->min; i <= list->max; ++i) {
348: if (list->map + (i - list->min)) {
349: rune_list *tmp = (rune_list *)xmalloc(sizeof(rune_list));
350: tmp->min = i;
351: tmp->max = i;
352: add_map(map, tmp, list->map + (i - list->min));
353: }
354: }
355: free(list);
356: list = nlist;
357: }
358: }
359:
360: void
361: add_map(rune_map *map, rune_list *list, u_int32_t flag)
362: {
363: rune_t i;
364: rune_list *lr = 0;
365: rune_list *r;
366: rune_t run;
367:
368: while (list->min < _CACHED_RUNES && list->min <= list->max) {
369: if (flag)
370: map->map[list->min++] |= flag;
371: else
372: map->map[list->min++] = list->map++;
373: }
374:
375: if (list->min > list->max) {
376: free(list);
377: return;
378: }
379:
380: run = list->max - list->min + 1;
381:
382: if (!(r = map->root) || (list->max < r->min - 1)
383: || (!flag && list->max == r->min - 1)) {
384: if (flag) {
385: list->types = xlalloc(run);
386: for (i = 0; i < run; ++i)
387: list->types[i] = flag;
388: }
389: list->next = map->root;
390: map->root = list;
391: return;
392: }
393:
394: for (r = map->root; r && r->max + 1 < list->min; r = r->next)
395: lr = r;
396:
397: if (!r) {
398: /*
399: * We are off the end.
400: */
401: if (flag) {
402: list->types = xlalloc(run);
403: for (i = 0; i < run; ++i)
404: list->types[i] = flag;
405: }
406: list->next = 0;
407: lr->next = list;
408: return;
409: }
410:
411: if (list->max < r->min - 1) {
412: /*
413: * We come before this range and we do not intersect it.
414: * We are not before the root node, it was checked before the loop
415: */
416: if (flag) {
417: list->types = xlalloc(run);
418: for (i = 0; i < run; ++i)
419: list->types[i] = flag;
420: }
421: list->next = lr->next;
422: lr->next = list;
423: return;
424: }
425:
426: /*
427: * At this point we have found that we at least intersect with
428: * the range pointed to by `r', we might intersect with one or
429: * more ranges beyond `r' as well.
430: */
431:
432: if (!flag && list->map - list->min != r->map - r->min) {
433: /*
434: * There are only two cases when we are doing case maps and
435: * our maps needn't have the same offset. When we are adjoining
436: * but not intersecting.
437: */
438: if (list->max + 1 == r->min) {
439: lr->next = list;
440: list->next = r;
441: return;
442: }
443: if (list->min - 1 == r->max) {
444: list->next = r->next;
445: r->next = list;
446: return;
447: }
448: fprintf(stderr, "Error: conflicting map entries\n");
449: exit(1);
450: }
451:
452: if (list->min >= r->min && list->max <= r->max) {
453: /*
454: * Subset case.
455: */
456:
457: if (flag) {
458: for (i = list->min; i <= list->max; ++i)
459: r->types[i - r->min] |= flag;
460: }
461: free(list);
462: return;
463: }
464: if (list->min <= r->min && list->max >= r->max) {
465: /*
466: * Superset case. Make him big enough to hold us.
467: * We might need to merge with the guy after him.
468: */
469: if (flag) {
470: list->types = xlalloc(list->max - list->min + 1);
471:
472: for (i = list->min; i <= list->max; ++i)
473: list->types[i - list->min] = flag;
474:
475: for (i = r->min; i <= r->max; ++i)
476: list->types[i - list->min] |= r->types[i - r->min];
477:
478: free(r->types);
479: r->types = list->types;
480: } else {
481: r->map = list->map;
482: }
483: r->min = list->min;
484: r->max = list->max;
485: free(list);
486: } else if (list->min < r->min) {
487: /*
488: * Our tail intersects his head.
489: */
490: if (flag) {
491: list->types = xlalloc(r->max - list->min + 1);
492:
493: for (i = r->min; i <= r->max; ++i)
494: list->types[i - list->min] = r->types[i - r->min];
495:
496: for (i = list->min; i < r->min; ++i)
497: list->types[i - list->min] = flag;
498:
499: for (i = r->min; i <= list->max; ++i)
500: list->types[i - list->min] |= flag;
501:
502: free(r->types);
503: r->types = list->types;
504: } else {
505: r->map = list->map;
506: }
507: r->min = list->min;
508: free(list);
509: return;
510: } else {
511: /*
512: * Our head intersects his tail.
513: * We might need to merge with the guy after him.
514: */
515: if (flag) {
516: r->types = xrelalloc(r->types, list->max - r->min + 1);
517:
518: for (i = list->min; i <= r->max; ++i)
519: r->types[i - r->min] |= flag;
520:
521: for (i = r->max+1; i <= list->max; ++i)
522: r->types[i - r->min] = flag;
523: }
524: r->max = list->max;
525: free(list);
526: }
527:
528: /*
529: * Okay, check to see if we grew into the next guy(s)
530: */
531: while ((lr = r->next) && r->max >= lr->min) {
532: if (flag) {
533: if (r->max >= lr->max) {
534: /*
535: * Good, we consumed all of him.
536: */
537: for (i = lr->min; i <= lr->max; ++i)
538: r->types[i - r->min] |= lr->types[i - lr->min];
539: } else {
540: /*
541: * "append" him on to the end of us.
542: */
543: r->types = xrelalloc(r->types, lr->max - r->min + 1);
544:
545: for (i = lr->min; i <= r->max; ++i)
546: r->types[i - r->min] |= lr->types[i - lr->min];
547:
548: for (i = r->max+1; i <= lr->max; ++i)
549: r->types[i - r->min] = lr->types[i - lr->min];
550:
551: r->max = lr->max;
552: }
553: } else {
554: if (lr->max > r->max)
555: r->max = lr->max;
556: }
557:
558: r->next = lr->next;
559:
560: if (flag)
561: free(lr->types);
562: free(lr);
563: }
564: }
565:
566: void
567: dump_tables()
568: {
569: int x, n;
570: rune_list *list;
571: _FileRuneLocale file_new_locale;
572: FILE *fp = (ofile ? ofile : stdout);
573:
574: memset(&file_new_locale, 0, sizeof(file_new_locale));
575:
576: /*
577: * See if we can compress some of the istype arrays
578: */
579: for(list = types.root; list; list = list->next) {
580: list->map = list->types[0];
581: for (x = 1; x < list->max - list->min + 1; ++x) {
582: if (list->types[x] != list->map) {
583: list->map = 0;
584: break;
585: }
586: }
587: }
588:
589: memcpy(&file_new_locale.frl_magic, new_locale.rl_magic,
590: sizeof(file_new_locale.frl_magic));
591: memcpy(&file_new_locale.frl_encoding, new_locale.rl_encoding,
592: sizeof(file_new_locale.frl_encoding));
593:
594: file_new_locale.frl_invalid_rune = htonl(new_locale.rl_invalid_rune);
595:
596: /*
597: * Fill in our tables. Do this in network order so that
598: * diverse machines have a chance of sharing data.
599: * (Machines like Crays cannot share with little machines due to
600: * word size. Sigh. We tried.)
601: */
602: for (x = 0; x < _CACHED_RUNES; ++x) {
603: file_new_locale.frl_runetype[x] = htonl(types.map[x]);
604: file_new_locale.frl_maplower[x] = htonl(maplower.map[x]);
605: file_new_locale.frl_mapupper[x] = htonl(mapupper.map[x]);
606: }
607:
608: /*
609: * Count up how many ranges we will need for each of the extents.
610: */
611: list = types.root;
612:
613: while (list) {
614: new_locale.rl_runetype_ext.rr_nranges++;
615: list = list->next;
616: }
617: file_new_locale.frl_runetype_ext.frr_nranges =
618: htonl(new_locale.rl_runetype_ext.rr_nranges);
619:
620: list = maplower.root;
621:
622: while (list) {
623: new_locale.rl_maplower_ext.rr_nranges++;
624: list = list->next;
625: }
626: file_new_locale.frl_maplower_ext.frr_nranges =
627: htonl(new_locale.rl_maplower_ext.rr_nranges);
628:
629: list = mapupper.root;
630:
631: while (list) {
632: new_locale.rl_mapupper_ext.rr_nranges++;
633: list = list->next;
634: }
635: file_new_locale.frl_mapupper_ext.frr_nranges =
636: htonl(new_locale.rl_mapupper_ext.rr_nranges);
637:
638: file_new_locale.frl_variable_len = htonl(new_locale.rl_variable_len);
639:
640: /*
641: * Okay, we are now ready to write the new locale file.
642: */
643:
644: /*
645: * PART 1: The _RuneLocale structure
646: */
647: if (fwrite((char *)&file_new_locale, sizeof(file_new_locale), 1, fp) != 1)
648: err(1, "writing _RuneLocale to %s", locale_file);
649: /*
650: * PART 2: The runetype_ext structures (not the actual tables)
651: */
652: for (list = types.root, n = 0; list != NULL; list = list->next, n++) {
653: _FileRuneEntry re;
654:
655: memset(&re, 0, sizeof(re));
656: re.fre_min = htonl(list->min);
657: re.fre_max = htonl(list->max);
658: re.fre_map = htonl(list->map);
659:
660: if (fwrite((char *)&re, sizeof(re), 1, fp) != 1)
661: err(1, "writing runetype_ext #%d to %s", n, locale_file);
662: }
663: /*
664: * PART 3: The maplower_ext structures
665: */
666: for (list = maplower.root, n = 0; list != NULL; list = list->next, n++) {
667: _FileRuneEntry re;
668:
669: memset(&re, 0, sizeof(re));
670: re.fre_min = htonl(list->min);
671: re.fre_max = htonl(list->max);
672: re.fre_map = htonl(list->map);
673:
674: if (fwrite((char *)&re, sizeof(re), 1, fp) != 1)
675: err(1, "writing maplower_ext #%d to %s", n, locale_file);
676: }
677: /*
678: * PART 4: The mapupper_ext structures
679: */
680: for (list = mapupper.root, n = 0; list != NULL; list = list->next, n++) {
681: _FileRuneEntry re;
682:
683: memset(&re, 0, sizeof(re));
684: re.fre_min = htonl(list->min);
685: re.fre_max = htonl(list->max);
686: re.fre_map = htonl(list->map);
687:
688: if (fwrite((char *)&re, sizeof(re), 1, fp) != 1)
689: err(1, "writing mapupper_ext #%d to %s", n, locale_file);
690: }
691: /*
692: * PART 5: The runetype_ext tables
693: */
694: for (list = types.root, n = 0; list != NULL; list = list->next, n++) {
695: for (x = 0; x < list->max - list->min + 1; ++x)
696: list->types[x] = htonl(list->types[x]);
697:
698: if (!list->map) {
699: if (fwrite((char *)list->types,
700: (list->max - list->min + 1) * sizeof(u_int32_t),
701: 1, fp) != 1)
702: err(1, "writing runetype_ext table #%d to %s", n, locale_file);
703: }
704: }
705: /*
706: * PART 5: And finally the variable data
707: */
708: if (new_locale.rl_variable_len != 0 &&
709: fwrite((char *)new_locale.rl_variable,
710: new_locale.rl_variable_len, 1, fp) != 1)
711: err(1, "writing variable data to %s", locale_file);
712: fclose(fp);
713:
714: if (!debug)
715: return;
716:
717: if (new_locale.rl_encoding[0])
718: fprintf(stderr, "ENCODING %s\n", new_locale.rl_encoding);
719: if (new_locale.rl_variable)
720: fprintf(stderr, "VARIABLE %s\n",
721: (char *)new_locale.rl_variable);
722:
723: fprintf(stderr, "\nMAPLOWER:\n\n");
724:
725: for (x = 0; x < _CACHED_RUNES; ++x) {
726: if (isprint(maplower.map[x]))
727: fprintf(stderr, " '%c'", (int)maplower.map[x]);
728: else if (maplower.map[x])
729: fprintf(stderr, "%04x", maplower.map[x]);
730: else
731: fprintf(stderr, "%4x", 0);
732: if ((x & 0xf) == 0xf)
733: fprintf(stderr, "\n");
734: else
735: fprintf(stderr, " ");
736: }
737: fprintf(stderr, "\n");
738:
739: for (list = maplower.root; list; list = list->next)
740: fprintf(stderr, "\t%04x - %04x : %04x\n", list->min, list->max, list->map);
741:
742: fprintf(stderr, "\nMAPUPPER:\n\n");
743:
744: for (x = 0; x < _CACHED_RUNES; ++x) {
745: if (isprint(mapupper.map[x]))
746: fprintf(stderr, " '%c'", (int)mapupper.map[x]);
747: else if (mapupper.map[x])
748: fprintf(stderr, "%04x", mapupper.map[x]);
749: else
750: fprintf(stderr, "%4x", 0);
751: if ((x & 0xf) == 0xf)
752: fprintf(stderr, "\n");
753: else
754: fprintf(stderr, " ");
755: }
756: fprintf(stderr, "\n");
757:
758: for (list = mapupper.root; list; list = list->next)
759: fprintf(stderr, "\t%04x - %04x : %04x\n", list->min, list->max, list->map);
760:
761:
762: fprintf(stderr, "\nTYPES:\n\n");
763:
764: for (x = 0; x < _CACHED_RUNES; ++x) {
765: u_int32_t r = types.map[x];
766:
767: if (r) {
768: if (isprint(x))
769: fprintf(stderr, " '%c':%2d", x, (int)(r & 0xff));
770: else
771: fprintf(stderr, "%04x:%2d", x, (int)(r & 0xff));
772:
773: fprintf(stderr, " %4s", (r & _RUNETYPE_A) ? "alph" : "");
774: fprintf(stderr, " %4s", (r & _RUNETYPE_C) ? "ctrl" : "");
775: fprintf(stderr, " %4s", (r & _RUNETYPE_D) ? "dig" : "");
776: fprintf(stderr, " %4s", (r & _RUNETYPE_G) ? "graf" : "");
777: fprintf(stderr, " %4s", (r & _RUNETYPE_L) ? "low" : "");
778: fprintf(stderr, " %4s", (r & _RUNETYPE_P) ? "punc" : "");
779: fprintf(stderr, " %4s", (r & _RUNETYPE_S) ? "spac" : "");
780: fprintf(stderr, " %4s", (r & _RUNETYPE_U) ? "upp" : "");
781: fprintf(stderr, " %4s", (r & _RUNETYPE_X) ? "xdig" : "");
782: fprintf(stderr, " %4s", (r & _RUNETYPE_B) ? "blnk" : "");
783: fprintf(stderr, " %4s", (r & _RUNETYPE_R) ? "prnt" : "");
784: fprintf(stderr, " %4s", (r & _RUNETYPE_I) ? "ideo" : "");
785: fprintf(stderr, " %4s", (r & _RUNETYPE_T) ? "spec" : "");
786: fprintf(stderr, " %4s", (r & _RUNETYPE_Q) ? "phon" : "");
787: fprintf(stderr, "\n");
788: }
789: }
790:
791: for (list = types.root; list; list = list->next) {
792: if (list->map && list->min + 3 < list->max) {
793: u_int32_t r = list->map;
794:
795: fprintf(stderr, "%04x:%2d", list->min, r & 0xff);
796:
797: fprintf(stderr, " %4s", (r & _RUNETYPE_A) ? "alph" : "");
798: fprintf(stderr, " %4s", (r & _RUNETYPE_C) ? "ctrl" : "");
799: fprintf(stderr, " %4s", (r & _RUNETYPE_D) ? "dig" : "");
800: fprintf(stderr, " %4s", (r & _RUNETYPE_G) ? "graf" : "");
801: fprintf(stderr, " %4s", (r & _RUNETYPE_L) ? "low" : "");
802: fprintf(stderr, " %4s", (r & _RUNETYPE_P) ? "punc" : "");
803: fprintf(stderr, " %4s", (r & _RUNETYPE_S) ? "spac" : "");
804: fprintf(stderr, " %4s", (r & _RUNETYPE_U) ? "upp" : "");
805: fprintf(stderr, " %4s", (r & _RUNETYPE_X) ? "xdig" : "");
806: fprintf(stderr, " %4s", (r & _RUNETYPE_B) ? "blnk" : "");
807: fprintf(stderr, " %4s", (r & _RUNETYPE_R) ? "prnt" : "");
808: fprintf(stderr, " %4s", (r & _RUNETYPE_I) ? "ideo" : "");
809: fprintf(stderr, " %4s", (r & _RUNETYPE_T) ? "spec" : "");
810: fprintf(stderr, " %4s", (r & _RUNETYPE_Q) ? "phon" : "");
811: fprintf(stderr, "\n...\n");
812:
813: fprintf(stderr, "%04x:%2d", list->max, r & 0xff);
814:
815: fprintf(stderr, " %4s", (r & _RUNETYPE_A) ? "alph" : "");
816: fprintf(stderr, " %4s", (r & _RUNETYPE_C) ? "ctrl" : "");
817: fprintf(stderr, " %4s", (r & _RUNETYPE_D) ? "dig" : "");
818: fprintf(stderr, " %4s", (r & _RUNETYPE_G) ? "graf" : "");
819: fprintf(stderr, " %4s", (r & _RUNETYPE_L) ? "low" : "");
820: fprintf(stderr, " %4s", (r & _RUNETYPE_P) ? "punc" : "");
821: fprintf(stderr, " %4s", (r & _RUNETYPE_S) ? "spac" : "");
822: fprintf(stderr, " %4s", (r & _RUNETYPE_U) ? "upp" : "");
823: fprintf(stderr, " %4s", (r & _RUNETYPE_X) ? "xdig" : "");
824: fprintf(stderr, " %4s", (r & _RUNETYPE_B) ? "blnk" : "");
825: fprintf(stderr, " %4s", (r & _RUNETYPE_R) ? "prnt" : "");
826: fprintf(stderr, " %4s", (r & _RUNETYPE_I) ? "ideo" : "");
827: fprintf(stderr, " %4s", (r & _RUNETYPE_T) ? "spec" : "");
828: fprintf(stderr, " %4s", (r & _RUNETYPE_Q) ? "phon" : "");
829: fprintf(stderr, " %1u", (unsigned)((r & _RUNETYPE_SWM)>>_RUNETYPE_SWS));
830: fprintf(stderr, "\n");
831: } else
832: for (x = list->min; x <= list->max; ++x) {
833: u_int32_t r = ntohl(list->types[x - list->min]);
834:
835: if (r) {
836: fprintf(stderr, "%04x:%2d", x, (int)(r & 0xff));
837:
838: fprintf(stderr, " %4s", (r & _RUNETYPE_A) ? "alph" : "");
839: fprintf(stderr, " %4s", (r & _RUNETYPE_C) ? "ctrl" : "");
840: fprintf(stderr, " %4s", (r & _RUNETYPE_D) ? "dig" : "");
841: fprintf(stderr, " %4s", (r & _RUNETYPE_G) ? "graf" : "");
842: fprintf(stderr, " %4s", (r & _RUNETYPE_L) ? "low" : "");
843: fprintf(stderr, " %4s", (r & _RUNETYPE_P) ? "punc" : "");
844: fprintf(stderr, " %4s", (r & _RUNETYPE_S) ? "spac" : "");
845: fprintf(stderr, " %4s", (r & _RUNETYPE_U) ? "upp" : "");
846: fprintf(stderr, " %4s", (r & _RUNETYPE_X) ? "xdig" : "");
847: fprintf(stderr, " %4s", (r & _RUNETYPE_B) ? "blnk" : "");
848: fprintf(stderr, " %4s", (r & _RUNETYPE_R) ? "prnt" : "");
849: fprintf(stderr, " %4s", (r & _RUNETYPE_I) ? "ideo" : "");
850: fprintf(stderr, " %4s", (r & _RUNETYPE_T) ? "spec" : "");
851: fprintf(stderr, " %4s", (r & _RUNETYPE_Q) ? "phon" : "");
852: fprintf(stderr, " %1u", (unsigned)((r & _RUNETYPE_SWM)>>_RUNETYPE_SWS));
853: fprintf(stderr, "\n");
854: }
855: }
856: }
857: }
![[BACK]](/icons/back.gif){kind=icon}
Return to yacc.y CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mklocale