Annotation of embedaddon/php/ext/mbstring/ucgendat/ucgendat.c, revision 1.1.1.2
1.1 misho 1: /* Further modified for PHP */
1.1.1.2 ! misho 2: /* $Id$ */
1.1 misho 3:
4: /* $OpenLDAP: pkg/ldap/libraries/liblunicode/ucdata/ucgendat.c,v 1.36.2.4 2007/01/02 21:43:51 kurt Exp $ */
5: /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
6: *
7: * Copyright 1998-2007 The OpenLDAP Foundation.
8: * All rights reserved.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted only as authorized by the OpenLDAP
12: * Public License.
13: *
14: * A copy of this license is available at
15: * <http://www.OpenLDAP.org/license.html>.
16: */
17:
18: /* Copyright 2001 Computing Research Labs, New Mexico State University
19: *
20: * Permission is hereby granted, free of charge, to any person obtaining a
21: * copy of this software and associated documentation files (the "Software"),
22: * to deal in the Software without restriction, including without limitation
23: * the rights to use, copy, modify, merge, publish, distribute, sublicense,
24: * and/or sell copies of the Software, and to permit persons to whom the
25: * Software is furnished to do so, subject to the following conditions:
26: *
27: * The above copyright notice and this permission notice shall be included in
28: * all copies or substantial portions of the Software.
29: *
30: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
31: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
32: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
33: * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
34: * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
35: * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
36: * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37: */
38: /* orig Id: ucgendat.c,v 1.4 2001/01/02 18:46:20 mleisher Exp $" */
39:
40: #include <stdio.h>
41: #include <ctype.h>
42: #include <stdlib.h>
43: #include <string.h>
44: #include <unistd.h>
45:
46: #define ac_uint2 unsigned short
47: #define ac_uint4 unsigned int
48: #define LDAP_DIRSEP "/"
49: #define AC_MEMCPY memcpy
50:
51: #ifndef HARDCODE_DATA
52: #define HARDCODE_DATA 1
53: #endif
54:
55: #undef ishdigit
56: #define ishdigit(cc) (((cc) >= '0' && (cc) <= '9') ||\
57: ((cc) >= 'A' && (cc) <= 'F') ||\
58: ((cc) >= 'a' && (cc) <= 'f'))
59:
60: /*
61: * A header written to the output file with the byte-order-mark and the number
62: * of property nodes.
63: */
64: static ac_uint2 hdr[2] = {0xfeff, 0};
65:
66: #define NUMPROPS 50
67: #define NEEDPROPS (NUMPROPS + (4 - (NUMPROPS & 3)))
68:
69: typedef struct {
70: char *name;
71: int len;
72: } _prop_t;
73:
74: /*
75: * List of properties expected to be found in the Unicode Character Database
76: * including some implementation specific properties.
77: *
78: * The implementation specific properties are:
79: * Cm = Composed (can be decomposed)
80: * Nb = Non-breaking
81: * Sy = Symmetric (has left and right forms)
82: * Hd = Hex digit
83: * Qm = Quote marks
84: * Mr = Mirroring
85: * Ss = Space, other
86: * Cp = Defined character
87: */
88: static _prop_t props[NUMPROPS] = {
89: {"Mn", 2}, {"Mc", 2}, {"Me", 2}, {"Nd", 2}, {"Nl", 2}, {"No", 2},
90: {"Zs", 2}, {"Zl", 2}, {"Zp", 2}, {"Cc", 2}, {"Cf", 2}, {"Cs", 2},
91: {"Co", 2}, {"Cn", 2}, {"Lu", 2}, {"Ll", 2}, {"Lt", 2}, {"Lm", 2},
92: {"Lo", 2}, {"Pc", 2}, {"Pd", 2}, {"Ps", 2}, {"Pe", 2}, {"Po", 2},
93: {"Sm", 2}, {"Sc", 2}, {"Sk", 2}, {"So", 2}, {"L", 1}, {"R", 1},
94: {"EN", 2}, {"ES", 2}, {"ET", 2}, {"AN", 2}, {"CS", 2}, {"B", 1},
95: {"S", 1}, {"WS", 2}, {"ON", 2},
96: {"Cm", 2}, {"Nb", 2}, {"Sy", 2}, {"Hd", 2}, {"Qm", 2}, {"Mr", 2},
97: {"Ss", 2}, {"Cp", 2}, {"Pi", 2}, {"Pf", 2}, {"AL", 2}
98: };
99:
100: typedef struct {
101: ac_uint4 *ranges;
102: ac_uint2 used;
103: ac_uint2 size;
104: } _ranges_t;
105:
106: static _ranges_t proptbl[NUMPROPS];
107:
108: /*
109: * Make sure this array is sized to be on a 4-byte boundary at compile time.
110: */
111: static ac_uint2 propcnt[NEEDPROPS];
112:
113: /*
114: * Array used to collect a decomposition before adding it to the decomposition
115: * table.
116: */
117: static ac_uint4 dectmp[64];
118: static ac_uint4 dectmp_size;
119:
120: typedef struct {
121: ac_uint4 code;
122: ac_uint2 size;
123: ac_uint2 used;
124: ac_uint4 *decomp;
125: } _decomp_t;
126:
127: /*
128: * List of decomposition. Created and expanded in order as the characters are
129: * encountered. First list contains canonical mappings, second also includes
130: * compatibility mappings.
131: */
132: static _decomp_t *decomps;
133: static ac_uint4 decomps_used;
134: static ac_uint4 decomps_size;
135:
136: static _decomp_t *kdecomps;
137: static ac_uint4 kdecomps_used;
138: static ac_uint4 kdecomps_size;
139:
140: /*
141: * Composition exclusion table stuff.
142: */
143: #define COMPEX_SET(c) (compexs[(c) >> 5] |= (1 << ((c) & 31)))
144: #define COMPEX_TEST(c) (compexs[(c) >> 5] & (1 << ((c) & 31)))
145: static ac_uint4 compexs[8192];
146:
147: /*
148: * Struct for holding a composition pair, and array of composition pairs
149: */
150: typedef struct {
151: ac_uint4 comp;
152: ac_uint4 count;
153: ac_uint4 code1;
154: ac_uint4 code2;
155: } _comp_t;
156:
157: #if 0
158: static _comp_t *comps;
159: #endif
160: static ac_uint4 comps_used;
161:
162: /*
163: * Types and lists for handling lists of case mappings.
164: */
165: typedef struct {
166: ac_uint4 key;
167: ac_uint4 other1;
168: ac_uint4 other2;
169: } _case_t;
170:
171: static _case_t *upper;
172: static _case_t *lower;
173: static _case_t *title;
174: static ac_uint4 upper_used;
175: static ac_uint4 upper_size;
176: static ac_uint4 lower_used;
177: static ac_uint4 lower_size;
178: static ac_uint4 title_used;
179: static ac_uint4 title_size;
180:
181: /*
182: * Array used to collect case mappings before adding them to a list.
183: */
184: static ac_uint4 cases[3];
185:
186: /*
187: * An array to hold ranges for combining classes.
188: */
189: static ac_uint4 *ccl;
190: static ac_uint4 ccl_used;
191: static ac_uint4 ccl_size;
192:
193: /*
194: * Structures for handling numbers.
195: */
196: typedef struct {
197: ac_uint4 code;
198: ac_uint4 idx;
199: } _codeidx_t;
200:
201: typedef struct {
202: short numerator;
203: short denominator;
204: } _num_t;
205:
206: /*
207: * Arrays to hold the mapping of codes to numbers.
208: */
209: static _codeidx_t *ncodes;
210: static ac_uint4 ncodes_used;
211: static ac_uint4 ncodes_size;
212:
213: static _num_t *nums;
214: static ac_uint4 nums_used;
215: static ac_uint4 nums_size;
216:
217: /*
218: * Array for holding numbers.
219: */
220: static _num_t *nums;
221: static ac_uint4 nums_used;
222: static ac_uint4 nums_size;
223:
224: static void
225: add_range(ac_uint4 start, ac_uint4 end, char *p1, char *p2)
226: {
227: int i, j, k, len;
228: _ranges_t *rlp;
229: char *name;
230:
231: for (k = 0; k < 2; k++) {
232: if (k == 0) {
233: name = p1;
234: len = 2;
235: } else {
236: if (p2 == 0)
237: break;
238:
239: name = p2;
240: len = 1;
241: }
242:
243: for (i = 0; i < NUMPROPS; i++) {
244: if (props[i].len == len && memcmp(props[i].name, name, len) == 0)
245: break;
246: }
247:
248: if (i == NUMPROPS)
249: continue;
250:
251: rlp = &proptbl[i];
252:
253: /*
254: * Resize the range list if necessary.
255: */
256: if (rlp->used == rlp->size) {
257: if (rlp->size == 0)
258: rlp->ranges = (ac_uint4 *)
259: malloc(sizeof(ac_uint4) << 3);
260: else
261: rlp->ranges = (ac_uint4 *)
262: realloc((char *) rlp->ranges,
263: sizeof(ac_uint4) * (rlp->size + 8));
264: rlp->size += 8;
265: }
266:
267: /*
268: * If this is the first code for this property list, just add it
269: * and return.
270: */
271: if (rlp->used == 0) {
272: rlp->ranges[0] = start;
273: rlp->ranges[1] = end;
274: rlp->used += 2;
275: continue;
276: }
277:
278: /*
279: * Optimize the case of adding the range to the end.
280: */
281: j = rlp->used - 1;
282: if (start > rlp->ranges[j]) {
283: j = rlp->used;
284: rlp->ranges[j++] = start;
285: rlp->ranges[j++] = end;
286: rlp->used = j;
287: continue;
288: }
289:
290: /*
291: * Need to locate the insertion point.
292: */
293: for (i = 0;
294: i < rlp->used && start > rlp->ranges[i + 1] + 1; i += 2) ;
295:
296: /*
297: * If the start value lies in the current range, then simply set the
298: * new end point of the range to the end value passed as a parameter.
299: */
300: if (rlp->ranges[i] <= start && start <= rlp->ranges[i + 1] + 1) {
301: rlp->ranges[i + 1] = end;
302: return;
303: }
304:
305: /*
306: * Shift following values up by two.
307: */
308: for (j = rlp->used; j > i; j -= 2) {
309: rlp->ranges[j] = rlp->ranges[j - 2];
310: rlp->ranges[j + 1] = rlp->ranges[j - 1];
311: }
312:
313: /*
314: * Add the new range at the insertion point.
315: */
316: rlp->ranges[i] = start;
317: rlp->ranges[i + 1] = end;
318: rlp->used += 2;
319: }
320: }
321:
322: static void
323: ordered_range_insert(ac_uint4 c, char *name, int len)
324: {
325: int i, j;
326: ac_uint4 s, e;
327: _ranges_t *rlp;
328:
329: if (len == 0)
330: return;
331:
332: /*
333: * Deal with directionality codes introduced in Unicode 3.0.
334: */
335: if ((len == 2 && memcmp(name, "BN", 2) == 0) ||
336: (len == 3 &&
337: (memcmp(name, "NSM", 3) == 0 || memcmp(name, "PDF", 3) == 0 ||
338: memcmp(name, "LRE", 3) == 0 || memcmp(name, "LRO", 3) == 0 ||
339: memcmp(name, "RLE", 3) == 0 || memcmp(name, "RLO", 3) == 0))) {
340: /*
341: * Mark all of these as Other Neutral to preserve compatibility with
342: * older versions.
343: */
344: len = 2;
345: name = "ON";
346: }
347:
348: for (i = 0; i < NUMPROPS; i++) {
349: if (props[i].len == len && memcmp(props[i].name, name, len) == 0)
350: break;
351: }
352:
353: if (i == NUMPROPS)
354: return;
355:
356: /*
357: * Have a match, so insert the code in order.
358: */
359: rlp = &proptbl[i];
360:
361: /*
362: * Resize the range list if necessary.
363: */
364: if (rlp->used == rlp->size) {
365: if (rlp->size == 0)
366: rlp->ranges = (ac_uint4 *)
367: malloc(sizeof(ac_uint4) << 3);
368: else
369: rlp->ranges = (ac_uint4 *)
370: realloc((char *) rlp->ranges,
371: sizeof(ac_uint4) * (rlp->size + 8));
372: rlp->size += 8;
373: }
374:
375: /*
376: * If this is the first code for this property list, just add it
377: * and return.
378: */
379: if (rlp->used == 0) {
380: rlp->ranges[0] = rlp->ranges[1] = c;
381: rlp->used += 2;
382: return;
383: }
384:
385: /*
386: * Optimize the cases of extending the last range and adding new ranges to
387: * the end.
388: */
389: j = rlp->used - 1;
390: e = rlp->ranges[j];
391: s = rlp->ranges[j - 1];
392:
393: if (c == e + 1) {
394: /*
395: * Extend the last range.
396: */
397: rlp->ranges[j] = c;
398: return;
399: }
400:
401: if (c > e + 1) {
402: /*
403: * Start another range on the end.
404: */
405: j = rlp->used;
406: rlp->ranges[j] = rlp->ranges[j + 1] = c;
407: rlp->used += 2;
408: return;
409: }
410:
411: if (c >= s)
412: /*
413: * The code is a duplicate of a code in the last range, so just return.
414: */
415: return;
416:
417: /*
418: * The code should be inserted somewhere before the last range in the
419: * list. Locate the insertion point.
420: */
421: for (i = 0;
422: i < rlp->used && c > rlp->ranges[i + 1] + 1; i += 2) ;
423:
424: s = rlp->ranges[i];
425: e = rlp->ranges[i + 1];
426:
427: if (c == e + 1)
428: /*
429: * Simply extend the current range.
430: */
431: rlp->ranges[i + 1] = c;
432: else if (c < s) {
433: /*
434: * Add a new entry before the current location. Shift all entries
435: * before the current one up by one to make room.
436: */
437: for (j = rlp->used; j > i; j -= 2) {
438: rlp->ranges[j] = rlp->ranges[j - 2];
439: rlp->ranges[j + 1] = rlp->ranges[j - 1];
440: }
441: rlp->ranges[i] = rlp->ranges[i + 1] = c;
442:
443: rlp->used += 2;
444: }
445: }
446:
447: static void
448: add_decomp(ac_uint4 code, short compat)
449: {
450: ac_uint4 i, j, size;
451: _decomp_t **pdecomps;
452: ac_uint4 *pdecomps_used;
453: ac_uint4 *pdecomps_size;
454:
455: if (compat) {
456: pdecomps = &kdecomps;
457: pdecomps_used = &kdecomps_used;
458: pdecomps_size = &kdecomps_size;
459: } else {
460: pdecomps = &decomps;
461: pdecomps_used = &decomps_used;
462: pdecomps_size = &decomps_size;
463: }
464:
465: /*
466: * Add the code to the composite property.
467: */
468: if (!compat) {
469: ordered_range_insert(code, "Cm", 2);
470: }
471:
472: /*
473: * Locate the insertion point for the code.
474: */
475: for (i = 0; i < *pdecomps_used && code > (*pdecomps)[i].code; i++) ;
476:
477: /*
478: * Allocate space for a new decomposition.
479: */
480: if (*pdecomps_used == *pdecomps_size) {
481: if (*pdecomps_size == 0)
482: *pdecomps = (_decomp_t *) malloc(sizeof(_decomp_t) << 3);
483: else
484: *pdecomps = (_decomp_t *)
485: realloc((char *) *pdecomps,
486: sizeof(_decomp_t) * (*pdecomps_size + 8));
487: (void) memset((char *) (*pdecomps + *pdecomps_size), '\0',
488: sizeof(_decomp_t) << 3);
489: *pdecomps_size += 8;
490: }
491:
492: if (i < *pdecomps_used && code != (*pdecomps)[i].code) {
493: /*
494: * Shift the decomps up by one if the codes don't match.
495: */
496: for (j = *pdecomps_used; j > i; j--)
497: (void) AC_MEMCPY((char *) &(*pdecomps)[j], (char *) &(*pdecomps)[j - 1],
498: sizeof(_decomp_t));
499: }
500:
501: /*
502: * Insert or replace a decomposition.
503: */
504: size = dectmp_size + (4 - (dectmp_size & 3));
505: if ((*pdecomps)[i].size < size) {
506: if ((*pdecomps)[i].size == 0)
507: (*pdecomps)[i].decomp = (ac_uint4 *)
508: malloc(sizeof(ac_uint4) * size);
509: else
510: (*pdecomps)[i].decomp = (ac_uint4 *)
511: realloc((char *) (*pdecomps)[i].decomp,
512: sizeof(ac_uint4) * size);
513: (*pdecomps)[i].size = size;
514: }
515:
516: if ((*pdecomps)[i].code != code)
517: (*pdecomps_used)++;
518:
519: (*pdecomps)[i].code = code;
520: (*pdecomps)[i].used = dectmp_size;
521: (void) AC_MEMCPY((char *) (*pdecomps)[i].decomp, (char *) dectmp,
522: sizeof(ac_uint4) * dectmp_size);
523:
524: /*
525: * NOTICE: This needs changing later so it is more general than simply
526: * pairs. This calculation is done here to simplify allocation elsewhere.
527: */
528: if (!compat && dectmp_size == 2)
529: comps_used++;
530: }
531:
532: static void
533: add_title(ac_uint4 code)
534: {
535: ac_uint4 i, j;
536:
537: /*
538: * Always map the code to itself.
539: */
540: cases[2] = code;
541:
542: if (title_used == title_size) {
543: if (title_size == 0)
544: title = (_case_t *) malloc(sizeof(_case_t) << 3);
545: else
546: title = (_case_t *) realloc((char *) title,
547: sizeof(_case_t) * (title_size + 8));
548: title_size += 8;
549: }
550:
551: /*
552: * Locate the insertion point.
553: */
554: for (i = 0; i < title_used && code > title[i].key; i++) ;
555:
556: if (i < title_used) {
557: /*
558: * Shift the array up by one.
559: */
560: for (j = title_used; j > i; j--)
561: (void) AC_MEMCPY((char *) &title[j], (char *) &title[j - 1],
562: sizeof(_case_t));
563: }
564:
565: title[i].key = cases[2]; /* Title */
566: title[i].other1 = cases[0]; /* Upper */
567: title[i].other2 = cases[1]; /* Lower */
568:
569: title_used++;
570: }
571:
572: static void
573: add_upper(ac_uint4 code)
574: {
575: ac_uint4 i, j;
576:
577: /*
578: * Always map the code to itself.
579: */
580: cases[0] = code;
581:
582: /*
583: * If the title case character is not present, then make it the same as
584: * the upper case.
585: */
586: if (cases[2] == 0)
587: cases[2] = code;
588:
589: if (upper_used == upper_size) {
590: if (upper_size == 0)
591: upper = (_case_t *) malloc(sizeof(_case_t) << 3);
592: else
593: upper = (_case_t *) realloc((char *) upper,
594: sizeof(_case_t) * (upper_size + 8));
595: upper_size += 8;
596: }
597:
598: /*
599: * Locate the insertion point.
600: */
601: for (i = 0; i < upper_used && code > upper[i].key; i++) ;
602:
603: if (i < upper_used) {
604: /*
605: * Shift the array up by one.
606: */
607: for (j = upper_used; j > i; j--)
608: (void) AC_MEMCPY((char *) &upper[j], (char *) &upper[j - 1],
609: sizeof(_case_t));
610: }
611:
612: upper[i].key = cases[0]; /* Upper */
613: upper[i].other1 = cases[1]; /* Lower */
614: upper[i].other2 = cases[2]; /* Title */
615:
616: upper_used++;
617: }
618:
619: static void
620: add_lower(ac_uint4 code)
621: {
622: ac_uint4 i, j;
623:
624: /*
625: * Always map the code to itself.
626: */
627: cases[1] = code;
628:
629: /*
630: * If the title case character is empty, then make it the same as the
631: * upper case.
632: */
633: if (cases[2] == 0)
634: cases[2] = cases[0];
635:
636: if (lower_used == lower_size) {
637: if (lower_size == 0)
638: lower = (_case_t *) malloc(sizeof(_case_t) << 3);
639: else
640: lower = (_case_t *) realloc((char *) lower,
641: sizeof(_case_t) * (lower_size + 8));
642: lower_size += 8;
643: }
644:
645: /*
646: * Locate the insertion point.
647: */
648: for (i = 0; i < lower_used && code > lower[i].key; i++) ;
649:
650: if (i < lower_used) {
651: /*
652: * Shift the array up by one.
653: */
654: for (j = lower_used; j > i; j--)
655: (void) AC_MEMCPY((char *) &lower[j], (char *) &lower[j - 1],
656: sizeof(_case_t));
657: }
658:
659: lower[i].key = cases[1]; /* Lower */
660: lower[i].other1 = cases[0]; /* Upper */
661: lower[i].other2 = cases[2]; /* Title */
662:
663: lower_used++;
664: }
665:
666: static void
667: ordered_ccl_insert(ac_uint4 c, ac_uint4 ccl_code)
668: {
669: ac_uint4 i, j;
670:
671: if (ccl_used == ccl_size) {
672: if (ccl_size == 0)
673: ccl = (ac_uint4 *) malloc(sizeof(ac_uint4) * 24);
674: else
675: ccl = (ac_uint4 *)
676: realloc((char *) ccl, sizeof(ac_uint4) * (ccl_size + 24));
677: ccl_size += 24;
678: }
679:
680: /*
681: * Optimize adding the first item.
682: */
683: if (ccl_used == 0) {
684: ccl[0] = ccl[1] = c;
685: ccl[2] = ccl_code;
686: ccl_used += 3;
687: return;
688: }
689:
690: /*
691: * Handle the special case of extending the range on the end. This
692: * requires that the combining class codes are the same.
693: */
694: if (ccl_code == ccl[ccl_used - 1] && c == ccl[ccl_used - 2] + 1) {
695: ccl[ccl_used - 2] = c;
696: return;
697: }
698:
699: /*
700: * Handle the special case of adding another range on the end.
701: */
702: if (c > ccl[ccl_used - 2] + 1 ||
703: (c == ccl[ccl_used - 2] + 1 && ccl_code != ccl[ccl_used - 1])) {
704: ccl[ccl_used++] = c;
705: ccl[ccl_used++] = c;
706: ccl[ccl_used++] = ccl_code;
707: return;
708: }
709:
710: /*
711: * Locate either the insertion point or range for the code.
712: */
713: for (i = 0; i < ccl_used && c > ccl[i + 1] + 1; i += 3) ;
714:
715: if (ccl_code == ccl[i + 2] && c == ccl[i + 1] + 1) {
716: /*
717: * Extend an existing range.
718: */
719: ccl[i + 1] = c;
720: return;
721: } else if (c < ccl[i]) {
722: /*
723: * Start a new range before the current location.
724: */
725: for (j = ccl_used; j > i; j -= 3) {
726: ccl[j] = ccl[j - 3];
727: ccl[j - 1] = ccl[j - 4];
728: ccl[j - 2] = ccl[j - 5];
729: }
730: ccl[i] = ccl[i + 1] = c;
731: ccl[i + 2] = ccl_code;
732: }
733: }
734:
735: /*
736: * Adds a number if it does not already exist and returns an index value
737: * multiplied by 2.
738: */
739: static ac_uint4
740: make_number(short num, short denom)
741: {
742: ac_uint4 n;
743:
744: /*
745: * Determine if the number already exists.
746: */
747: for (n = 0; n < nums_used; n++) {
748: if (nums[n].numerator == num && nums[n].denominator == denom)
749: return n << 1;
750: }
751:
752: if (nums_used == nums_size) {
753: if (nums_size == 0)
754: nums = (_num_t *) malloc(sizeof(_num_t) << 3);
755: else
756: nums = (_num_t *) realloc((char *) nums,
757: sizeof(_num_t) * (nums_size + 8));
758: nums_size += 8;
759: }
760:
761: n = nums_used++;
762: nums[n].numerator = num;
763: nums[n].denominator = denom;
764:
765: return n << 1;
766: }
767:
768: static void
769: add_number(ac_uint4 code, short num, short denom)
770: {
771: ac_uint4 i, j;
772:
773: /*
774: * Insert the code in order.
775: */
776: for (i = 0; i < ncodes_used && code > ncodes[i].code; i++) ;
777:
778: /*
779: * Handle the case of the codes matching and simply replace the number
780: * that was there before.
781: */
782: if (i < ncodes_used && code == ncodes[i].code) {
783: ncodes[i].idx = make_number(num, denom);
784: return;
785: }
786:
787: /*
788: * Resize the array if necessary.
789: */
790: if (ncodes_used == ncodes_size) {
791: if (ncodes_size == 0)
792: ncodes = (_codeidx_t *) malloc(sizeof(_codeidx_t) << 3);
793: else
794: ncodes = (_codeidx_t *)
795: realloc((char *) ncodes, sizeof(_codeidx_t) * (ncodes_size + 8));
796:
797: ncodes_size += 8;
798: }
799:
800: /*
801: * Shift things around to insert the code if necessary.
802: */
803: if (i < ncodes_used) {
804: for (j = ncodes_used; j > i; j--) {
805: ncodes[j].code = ncodes[j - 1].code;
806: ncodes[j].idx = ncodes[j - 1].idx;
807: }
808: }
809: ncodes[i].code = code;
810: ncodes[i].idx = make_number(num, denom);
811:
812: ncodes_used++;
813: }
814:
815: /*
816: * This routine assumes that the line is a valid Unicode Character Database
817: * entry.
818: */
819: static void
820: read_cdata(FILE *in)
821: {
822: ac_uint4 i, lineno, skip, code, ccl_code;
823: short wnum, neg, number[2], compat;
824: char line[512], *s, *e;
825:
826: lineno = skip = 0;
827: while (fgets(line, sizeof(line), in)) {
828: if( (s=strchr(line, '\n')) ) *s = '\0';
829: lineno++;
830:
831: /*
832: * Skip blank lines and lines that start with a '#'.
833: */
834: if (line[0] == 0 || line[0] == '#')
835: continue;
836:
837: /*
838: * If lines need to be skipped, do it here.
839: */
840: if (skip) {
841: skip--;
842: continue;
843: }
844:
845: /*
846: * Collect the code. The code can be up to 6 hex digits in length to
847: * allow surrogates to be specified.
848: */
849: for (s = line, i = code = 0; *s != ';' && i < 6; i++, s++) {
850: code <<= 4;
851: if (*s >= '0' && *s <= '9')
852: code += *s - '0';
853: else if (*s >= 'A' && *s <= 'F')
854: code += (*s - 'A') + 10;
855: else if (*s >= 'a' && *s <= 'f')
856: code += (*s - 'a') + 10;
857: }
858:
859: /*
860: * Handle the following special cases:
861: * 1. 4E00-9FA5 CJK Ideographs.
862: * 2. AC00-D7A3 Hangul Syllables.
863: * 3. D800-DFFF Surrogates.
864: * 4. E000-F8FF Private Use Area.
865: * 5. F900-FA2D Han compatibility.
866: * ...Plus additional ranges in newer Unicode versions...
867: */
868: switch (code) {
869: case 0x3400:
870: /* CJK Ideograph Extension A */
871: add_range(0x3400, 0x4db5, "Lo", "L");
872:
873: add_range(0x3400, 0x4db5, "Cp", 0);
874:
875: skip = 1;
876: break;
877: case 0x4e00:
878: /*
879: * The Han ideographs.
880: */
881: add_range(0x4e00, 0x9fff, "Lo", "L");
882:
883: /*
884: * Add the characters to the defined category.
885: */
886: add_range(0x4e00, 0x9fa5, "Cp", 0);
887:
888: skip = 1;
889: break;
890: case 0xac00:
891: /*
892: * The Hangul syllables.
893: */
894: add_range(0xac00, 0xd7a3, "Lo", "L");
895:
896: /*
897: * Add the characters to the defined category.
898: */
899: add_range(0xac00, 0xd7a3, "Cp", 0);
900:
901: skip = 1;
902: break;
903: case 0xd800:
904: /*
905: * Make a range of all surrogates and assume some default
906: * properties.
907: */
908: add_range(0x010000, 0x10ffff, "Cs", "L");
909: skip = 5;
910: break;
911: case 0xe000:
912: /*
913: * The Private Use area. Add with a default set of properties.
914: */
915: add_range(0xe000, 0xf8ff, "Co", "L");
916: skip = 1;
917: break;
918: case 0xf900:
919: /*
920: * The CJK compatibility area.
921: */
922: add_range(0xf900, 0xfaff, "Lo", "L");
923:
924: /*
925: * Add the characters to the defined category.
926: */
927: add_range(0xf900, 0xfaff, "Cp", 0);
928:
929: skip = 1;
930: break;
931: case 0x20000:
932: /* CJK Ideograph Extension B */
933: add_range(0x20000, 0x2a6d6, "Lo", "L");
934:
935: add_range(0x20000, 0x2a6d6, "Cp", 0);
936:
937: skip = 1;
938: break;
939: case 0xf0000:
940: /* Plane 15 private use */
941: add_range(0xf0000, 0xffffd, "Co", "L");
942: skip = 1;
943: break;
944:
945: case 0x100000:
946: /* Plane 16 private use */
947: add_range(0x100000, 0x10fffd, "Co", "L");
948: skip = 1;
949: break;
950: }
951:
952: if (skip)
953: continue;
954:
955: /*
956: * Add the code to the defined category.
957: */
958: ordered_range_insert(code, "Cp", 2);
959:
960: /*
961: * Locate the first character property field.
962: */
963: for (i = 0; *s != 0 && i < 2; s++) {
964: if (*s == ';')
965: i++;
966: }
967: for (e = s; *e && *e != ';'; e++) ;
968:
969: ordered_range_insert(code, s, e - s);
970:
971: /*
972: * Locate the combining class code.
973: */
974: for (s = e; *s != 0 && i < 3; s++) {
975: if (*s == ';')
976: i++;
977: }
978:
979: /*
980: * Convert the combining class code from decimal.
981: */
982: for (ccl_code = 0, e = s; *e && *e != ';'; e++)
983: ccl_code = (ccl_code * 10) + (*e - '0');
984:
985: /*
986: * Add the code if it not 0.
987: */
988: if (ccl_code != 0)
989: ordered_ccl_insert(code, ccl_code);
990:
991: /*
992: * Locate the second character property field.
993: */
994: for (s = e; *s != 0 && i < 4; s++) {
995: if (*s == ';')
996: i++;
997: }
998: for (e = s; *e && *e != ';'; e++) ;
999:
1000: ordered_range_insert(code, s, e - s);
1001:
1002: /*
1003: * Check for a decomposition.
1004: */
1005: s = ++e;
1006: if (*s != ';') {
1007: compat = *s == '<';
1008: if (compat) {
1009: /*
1010: * Skip compatibility formatting tag.
1011: */
1012: while (*s++ != '>');
1013: }
1014: /*
1015: * Collect the codes of the decomposition.
1016: */
1017: for (dectmp_size = 0; *s != ';'; ) {
1018: /*
1019: * Skip all leading non-hex digits.
1020: */
1021: while (!ishdigit(*s))
1022: s++;
1023:
1024: for (dectmp[dectmp_size] = 0; ishdigit(*s); s++) {
1025: dectmp[dectmp_size] <<= 4;
1026: if (*s >= '0' && *s <= '9')
1027: dectmp[dectmp_size] += *s - '0';
1028: else if (*s >= 'A' && *s <= 'F')
1029: dectmp[dectmp_size] += (*s - 'A') + 10;
1030: else if (*s >= 'a' && *s <= 'f')
1031: dectmp[dectmp_size] += (*s - 'a') + 10;
1032: }
1033: dectmp_size++;
1034: }
1035:
1036: /*
1037: * If there are any codes in the temporary decomposition array,
1038: * then add the character with its decomposition.
1039: */
1040: if (dectmp_size > 0) {
1041: if (!compat) {
1042: add_decomp(code, 0);
1043: }
1044: add_decomp(code, 1);
1045: }
1046: }
1047:
1048: /*
1049: * Skip to the number field.
1050: */
1051: for (i = 0; i < 3 && *s; s++) {
1052: if (*s == ';')
1053: i++;
1054: }
1055:
1056: /*
1057: * Scan the number in.
1058: */
1059: number[0] = number[1] = 0;
1060: for (e = s, neg = wnum = 0; *e && *e != ';'; e++) {
1061: if (*e == '-') {
1062: neg = 1;
1063: continue;
1064: }
1065:
1066: if (*e == '/') {
1067: /*
1068: * Move the the denominator of the fraction.
1069: */
1070: if (neg)
1071: number[wnum] *= -1;
1072: neg = 0;
1073: e++;
1074: wnum++;
1075: }
1076: number[wnum] = (number[wnum] * 10) + (*e - '0');
1077: }
1078:
1079: if (e > s) {
1080: /*
1081: * Adjust the denominator in case of integers and add the number.
1082: */
1083: if (wnum == 0)
1084: number[1] = 1;
1085:
1086: add_number(code, number[0], number[1]);
1087: }
1088:
1089: /*
1090: * Skip to the start of the possible case mappings.
1091: */
1092: for (s = e, i = 0; i < 4 && *s; s++) {
1093: if (*s == ';')
1094: i++;
1095: }
1096:
1097: /*
1098: * Collect the case mappings.
1099: */
1100: cases[0] = cases[1] = cases[2] = 0;
1101: for (i = 0; i < 3; i++) {
1102: while (ishdigit(*s)) {
1103: cases[i] <<= 4;
1104: if (*s >= '0' && *s <= '9')
1105: cases[i] += *s - '0';
1106: else if (*s >= 'A' && *s <= 'F')
1107: cases[i] += (*s - 'A') + 10;
1108: else if (*s >= 'a' && *s <= 'f')
1109: cases[i] += (*s - 'a') + 10;
1110: s++;
1111: }
1112: if (*s == ';')
1113: s++;
1114: }
1115: if (cases[0] && cases[1])
1116: /*
1117: * Add the upper and lower mappings for a title case character.
1118: */
1119: add_title(code);
1120: else if (cases[1])
1121: /*
1122: * Add the lower and title case mappings for the upper case
1123: * character.
1124: */
1125: add_upper(code);
1126: else if (cases[0])
1127: /*
1128: * Add the upper and title case mappings for the lower case
1129: * character.
1130: */
1131: add_lower(code);
1132: }
1133: }
1134:
1135: #if 0
1136:
1137: static _decomp_t *
1138: find_decomp(ac_uint4 code, short compat)
1139: {
1140: long l, r, m;
1141: _decomp_t *decs;
1142:
1143: l = 0;
1144: r = (compat ? kdecomps_used : decomps_used) - 1;
1145: decs = compat ? kdecomps : decomps;
1146: while (l <= r) {
1147: m = (l + r) >> 1;
1148: if (code > decs[m].code)
1149: l = m + 1;
1150: else if (code < decs[m].code)
1151: r = m - 1;
1152: else
1153: return &decs[m];
1154: }
1155: return 0;
1156: }
1157:
1158: static void
1159: decomp_it(_decomp_t *d, short compat)
1160: {
1161: ac_uint4 i;
1162: _decomp_t *dp;
1163:
1164: for (i = 0; i < d->used; i++) {
1165: if ((dp = find_decomp(d->decomp[i], compat)) != 0)
1166: decomp_it(dp, compat);
1167: else
1168: dectmp[dectmp_size++] = d->decomp[i];
1169: }
1170: }
1171:
1172:
1173: /*
1174: * Expand all decompositions by recursively decomposing each character
1175: * in the decomposition.
1176: */
1177: static void
1178: expand_decomp(void)
1179: {
1180: ac_uint4 i;
1181:
1182: for (i = 0; i < decomps_used; i++) {
1183: dectmp_size = 0;
1184: decomp_it(&decomps[i], 0);
1185: if (dectmp_size > 0)
1186: add_decomp(decomps[i].code, 0);
1187: }
1188:
1189: for (i = 0; i < kdecomps_used; i++) {
1190: dectmp_size = 0;
1191: decomp_it(&kdecomps[i], 1);
1192: if (dectmp_size > 0)
1193: add_decomp(kdecomps[i].code, 1);
1194: }
1195: }
1196:
1197: static int
1198: cmpcomps(const void *v_comp1, const void *v_comp2)
1199: {
1200: const _comp_t *comp1 = v_comp1, *comp2 = v_comp2;
1201: long diff = comp1->code1 - comp2->code1;
1202:
1203: if (!diff)
1204: diff = comp1->code2 - comp2->code2;
1205: return (int) diff;
1206: }
1207:
1208: #endif
1209:
1210: /*
1211: * Load composition exclusion data
1212: */
1213: static void
1214: read_compexdata(FILE *in)
1215: {
1216: ac_uint2 i;
1217: ac_uint4 code;
1218: char line[512], *s;
1219:
1220: (void) memset((char *) compexs, 0, sizeof(compexs));
1221:
1222: while (fgets(line, sizeof(line), in)) {
1223: if( (s=strchr(line, '\n')) ) *s = '\0';
1224: /*
1225: * Skip blank lines and lines that start with a '#'.
1226: */
1227: if (line[0] == 0 || line[0] == '#')
1228: continue;
1229:
1230: /*
1231: * Collect the code. Assume max 6 digits
1232: */
1233:
1234: for (s = line, i = code = 0; *s != '#' && i < 6; i++, s++) {
1235: if (isspace((unsigned char)*s)) break;
1236: code <<= 4;
1237: if (*s >= '0' && *s <= '9')
1238: code += *s - '0';
1239: else if (*s >= 'A' && *s <= 'F')
1240: code += (*s - 'A') + 10;
1241: else if (*s >= 'a' && *s <= 'f')
1242: code += (*s - 'a') + 10;
1243: }
1244: COMPEX_SET(code);
1245: }
1246: }
1247:
1248: #if 0
1249:
1250: /*
1251: * Creates array of compositions from decomposition array
1252: */
1253: static void
1254: create_comps(void)
1255: {
1256: ac_uint4 i, cu;
1257:
1258: comps = (_comp_t *) malloc(comps_used * sizeof(_comp_t));
1259:
1260: for (i = cu = 0; i < decomps_used; i++) {
1261: if (decomps[i].used != 2 || COMPEX_TEST(decomps[i].code))
1262: continue;
1263: comps[cu].comp = decomps[i].code;
1264: comps[cu].count = 2;
1265: comps[cu].code1 = decomps[i].decomp[0];
1266: comps[cu].code2 = decomps[i].decomp[1];
1267: cu++;
1268: }
1269: comps_used = cu;
1270: qsort(comps, comps_used, sizeof(_comp_t), cmpcomps);
1271: }
1272:
1273: #endif
1274:
1275: #if HARDCODE_DATA
1276: static void
1277: write_case(FILE *out, _case_t *tab, int num, int first)
1278: {
1279: int i;
1280:
1281: for (i=0; i<num; i++) {
1282: if (first) first = 0;
1283: else fprintf(out, ",");
1284: fprintf(out, "\n\t0x%08lx, 0x%08lx, 0x%08lx",
1285: (unsigned long) tab[i].key, (unsigned long) tab[i].other1,
1286: (unsigned long) tab[i].other2);
1287: }
1288: }
1289:
1290: #define PREF "static const "
1291:
1292: #endif
1293:
1294: static void
1295: write_cdata(char *opath)
1296: {
1297: FILE *out;
1298: ac_uint4 bytes;
1299: ac_uint4 i, idx, nprops;
1300: #if !(HARDCODE_DATA)
1301: ac_uint2 casecnt[2];
1302: #endif
1303: char path[BUFSIZ];
1304: #if HARDCODE_DATA
1305: int j, k;
1306:
1307: /*****************************************************************
1308: *
1309: * Generate the ctype data.
1310: *
1311: *****************************************************************/
1312:
1313: /*
1314: * Open the output file.
1315: */
1316: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "uctable.h", opath);
1317: if ((out = fopen(path, "w")) == 0)
1318: return;
1319: #else
1320: /*
1321: * Open the ctype.dat file.
1322: */
1323: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "ctype.dat", opath);
1324: if ((out = fopen(path, "wb")) == 0)
1325: return;
1326: #endif
1327:
1328: /*
1329: * Collect the offsets for the properties. The offsets array is
1330: * on a 4-byte boundary to keep things efficient for architectures
1331: * that need such a thing.
1332: */
1333: for (i = idx = 0; i < NUMPROPS; i++) {
1334: propcnt[i] = (proptbl[i].used != 0) ? idx : 0xffff;
1335: idx += proptbl[i].used;
1336: }
1337:
1338: /*
1339: * Add the sentinel index which is used by the binary search as the upper
1340: * bound for a search.
1341: */
1342: propcnt[i] = idx;
1343:
1344: /*
1345: * Record the actual number of property lists. This may be different than
1346: * the number of offsets actually written because of aligning on a 4-byte
1347: * boundary.
1348: */
1349: hdr[1] = NUMPROPS;
1350:
1351: /*
1352: * Calculate the byte count needed and pad the property counts array to a
1353: * 4-byte boundary.
1354: */
1355: if ((bytes = sizeof(ac_uint2) * (NUMPROPS + 1)) & 3)
1356: bytes += 4 - (bytes & 3);
1357: nprops = bytes / sizeof(ac_uint2);
1358: bytes += sizeof(ac_uint4) * idx;
1359:
1360: #if HARDCODE_DATA
1361: fprintf(out,
1362: "/* This file was generated from a modified version UCData's ucgendat.\n"
1363: " *\n"
1364: " * DO NOT EDIT THIS FILE!\n"
1365: " * \n"
1366: " * Instead, compile ucgendat.c (bundled with PHP in ext/mbstring), download\n"
1367: " * the appropriate UnicodeData-x.x.x.txt and CompositionExclusions-x.x.x.txt\n"
1368: " * files from http://www.unicode.org/Public/ and run this program.\n"
1369: " *\n"
1370: " * More information can be found in the UCData package. Unfortunately,\n"
1371: " * the project's page doesn't seem to be live anymore, so you can use\n"
1372: " * OpenLDAPs modified copy (look in libraries/liblunicode/ucdata) */\n\n");
1373:
1374: fprintf(out, PREF "unsigned short _ucprop_size = %d;\n\n", NUMPROPS);
1375:
1376: fprintf(out, PREF "unsigned short _ucprop_offsets[] = {");
1377:
1378: for (i = 0; i<nprops; i++) {
1379: if (i) fprintf(out, ",");
1380: if (!(i&7)) fprintf(out, "\n\t");
1381: else fprintf(out, " ");
1382: fprintf(out, "0x%04x", propcnt[i]);
1383: }
1384: fprintf(out, "\n};\n\n");
1385:
1386: fprintf(out, PREF "unsigned int _ucprop_ranges[] = {");
1387:
1388: k = 0;
1389: for (i = 0; i < NUMPROPS; i++) {
1390: if (proptbl[i].used > 0) {
1391: for (j=0; j<proptbl[i].used; j++) {
1392: if (k) fprintf(out, ",");
1393: if (!(k&3)) fprintf(out,"\n\t");
1394: else fprintf(out, " ");
1395: k++;
1396: fprintf(out, "0x%08lx", (unsigned long) proptbl[i].ranges[j]);
1397: }
1398: }
1399: }
1400: fprintf(out, "\n};\n\n");
1401: #else
1402: /*
1403: * Write the header.
1404: */
1405: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1406:
1407: /*
1408: * Write the byte count.
1409: */
1410: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1411:
1412: /*
1413: * Write the property list counts.
1414: */
1415: fwrite((char *) propcnt, sizeof(ac_uint2), nprops, out);
1416:
1417: /*
1418: * Write the property lists.
1419: */
1420: for (i = 0; i < NUMPROPS; i++) {
1421: if (proptbl[i].used > 0)
1422: fwrite((char *) proptbl[i].ranges, sizeof(ac_uint4),
1423: proptbl[i].used, out);
1424: }
1425:
1426: fclose(out);
1427: #endif
1428:
1429: /*****************************************************************
1430: *
1431: * Generate the case mapping data.
1432: *
1433: *****************************************************************/
1434:
1435: #if HARDCODE_DATA
1436: fprintf(out, PREF "unsigned int _uccase_size = %ld;\n\n",
1437: (long) (upper_used + lower_used + title_used));
1438:
1439: fprintf(out,
1440: "/* Starting indexes of the case tables\n"
1441: " * UpperIndex = 0\n"
1442: " * LowerIndex = _uccase_len[0]\n"
1443: " * TitleIndex = LowerIndex + _uccase_len[1] */\n\n");
1444: fprintf(out, PREF "unsigned short _uccase_len[2] = {%ld, %ld};\n\n",
1445: (long) upper_used * 3, (long) lower_used * 3);
1446: fprintf(out, PREF "unsigned int _uccase_map[] = {");
1447:
1448: if (upper_used > 0)
1449: /*
1450: * Write the upper case table.
1451: */
1452: write_case(out, upper, upper_used, 1);
1453:
1454: if (lower_used > 0)
1455: /*
1456: * Write the lower case table.
1457: */
1458: write_case(out, lower, lower_used, !upper_used);
1459:
1460: if (title_used > 0)
1461: /*
1462: * Write the title case table.
1463: */
1464: write_case(out, title, title_used, !(upper_used||lower_used));
1465:
1466: if (!(upper_used || lower_used || title_used))
1467: fprintf(out, "\t0");
1468:
1469: fprintf(out, "\n};\n\n");
1470: #else
1471: /*
1472: * Open the case.dat file.
1473: */
1474: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "case.dat", opath);
1475: if ((out = fopen(path, "wb")) == 0)
1476: return;
1477:
1478: /*
1479: * Write the case mapping tables.
1480: */
1481: hdr[1] = upper_used + lower_used + title_used;
1482: casecnt[0] = upper_used;
1483: casecnt[1] = lower_used;
1484:
1485: /*
1486: * Write the header.
1487: */
1488: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1489:
1490: /*
1491: * Write the upper and lower case table sizes.
1492: */
1493: fwrite((char *) casecnt, sizeof(ac_uint2), 2, out);
1494:
1495: if (upper_used > 0)
1496: /*
1497: * Write the upper case table.
1498: */
1499: fwrite((char *) upper, sizeof(_case_t), upper_used, out);
1500:
1501: if (lower_used > 0)
1502: /*
1503: * Write the lower case table.
1504: */
1505: fwrite((char *) lower, sizeof(_case_t), lower_used, out);
1506:
1507: if (title_used > 0)
1508: /*
1509: * Write the title case table.
1510: */
1511: fwrite((char *) title, sizeof(_case_t), title_used, out);
1512:
1513: fclose(out);
1514: #endif
1515:
1516: #if 0
1517:
1518: /*****************************************************************
1519: *
1520: * Generate the composition data.
1521: *
1522: *****************************************************************/
1523:
1524: /*
1525: * Create compositions from decomposition data
1526: */
1527: create_comps();
1528:
1529: #if HARDCODE_DATA
1530: fprintf(out, PREF "ac_uint4 _uccomp_size = %ld;\n\n",
1531: comps_used * 4L);
1532:
1533: fprintf(out, PREF "ac_uint4 _uccomp_data[] = {");
1534:
1535: /*
1536: * Now, if comps exist, write them out.
1537: */
1538: if (comps_used > 0) {
1539: for (i=0; i<comps_used; i++) {
1540: if (i) fprintf(out, ",");
1541: fprintf(out, "\n\t0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx",
1542: (unsigned long) comps[i].comp, (unsigned long) comps[i].count,
1543: (unsigned long) comps[i].code1, (unsigned long) comps[i].code2);
1544: }
1545: } else {
1546: fprintf(out, "\t0");
1547: }
1548: fprintf(out, "\n};\n\n");
1549: #else
1550: /*
1551: * Open the comp.dat file.
1552: */
1553: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "comp.dat", opath);
1554: if ((out = fopen(path, "wb")) == 0)
1555: return;
1556:
1557: /*
1558: * Write the header.
1559: */
1560: hdr[1] = (ac_uint2) comps_used * 4;
1561: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1562:
1563: /*
1564: * Write out the byte count to maintain header size.
1565: */
1566: bytes = comps_used * sizeof(_comp_t);
1567: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1568:
1569: /*
1570: * Now, if comps exist, write them out.
1571: */
1572: if (comps_used > 0)
1573: fwrite((char *) comps, sizeof(_comp_t), comps_used, out);
1574:
1575: fclose(out);
1576: #endif
1577:
1578: /*****************************************************************
1579: *
1580: * Generate the decomposition data.
1581: *
1582: *****************************************************************/
1583:
1584: /*
1585: * Fully expand all decompositions before generating the output file.
1586: */
1587: expand_decomp();
1588:
1589: #if HARDCODE_DATA
1590: fprintf(out, PREF "ac_uint4 _ucdcmp_size = %ld;\n\n",
1591: decomps_used * 2L);
1592:
1593: fprintf(out, PREF "ac_uint4 _ucdcmp_nodes[] = {");
1594:
1595: if (decomps_used) {
1596: /*
1597: * Write the list of decomp nodes.
1598: */
1599: for (i = idx = 0; i < decomps_used; i++) {
1600: fprintf(out, "\n\t0x%08lx, 0x%08lx,",
1601: (unsigned long) decomps[i].code, (unsigned long) idx);
1602: idx += decomps[i].used;
1603: }
1604:
1605: /*
1606: * Write the sentinel index as the last decomp node.
1607: */
1608: fprintf(out, "\n\t0x%08lx\n};\n\n", (unsigned long) idx);
1609:
1610: fprintf(out, PREF "ac_uint4 _ucdcmp_decomp[] = {");
1611: /*
1612: * Write the decompositions themselves.
1613: */
1614: k = 0;
1615: for (i = 0; i < decomps_used; i++)
1616: for (j=0; j<decomps[i].used; j++) {
1617: if (k) fprintf(out, ",");
1618: if (!(k&3)) fprintf(out,"\n\t");
1619: else fprintf(out, " ");
1620: k++;
1621: fprintf(out, "0x%08lx", (unsigned long) decomps[i].decomp[j]);
1622: }
1623: fprintf(out, "\n};\n\n");
1624: }
1625: #else
1626: /*
1627: * Open the decomp.dat file.
1628: */
1629: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "decomp.dat", opath);
1630: if ((out = fopen(path, "wb")) == 0)
1631: return;
1632:
1633: hdr[1] = decomps_used;
1634:
1635: /*
1636: * Write the header.
1637: */
1638: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1639:
1640: /*
1641: * Write a temporary byte count which will be calculated as the
1642: * decompositions are written out.
1643: */
1644: bytes = 0;
1645: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1646:
1647: if (decomps_used) {
1648: /*
1649: * Write the list of decomp nodes.
1650: */
1651: for (i = idx = 0; i < decomps_used; i++) {
1652: fwrite((char *) &decomps[i].code, sizeof(ac_uint4), 1, out);
1653: fwrite((char *) &idx, sizeof(ac_uint4), 1, out);
1654: idx += decomps[i].used;
1655: }
1656:
1657: /*
1658: * Write the sentinel index as the last decomp node.
1659: */
1660: fwrite((char *) &idx, sizeof(ac_uint4), 1, out);
1661:
1662: /*
1663: * Write the decompositions themselves.
1664: */
1665: for (i = 0; i < decomps_used; i++)
1666: fwrite((char *) decomps[i].decomp, sizeof(ac_uint4),
1667: decomps[i].used, out);
1668:
1669: /*
1670: * Seek back to the beginning and write the byte count.
1671: */
1672: bytes = (sizeof(ac_uint4) * idx) +
1673: (sizeof(ac_uint4) * ((hdr[1] << 1) + 1));
1674: fseek(out, sizeof(ac_uint2) << 1, 0L);
1675: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1676:
1677: fclose(out);
1678: }
1679: #endif
1680:
1681: #ifdef HARDCODE_DATA
1682: fprintf(out, PREF "ac_uint4 _uckdcmp_size = %ld;\n\n",
1683: kdecomps_used * 2L);
1684:
1685: fprintf(out, PREF "ac_uint4 _uckdcmp_nodes[] = {");
1686:
1687: if (kdecomps_used) {
1688: /*
1689: * Write the list of kdecomp nodes.
1690: */
1691: for (i = idx = 0; i < kdecomps_used; i++) {
1692: fprintf(out, "\n\t0x%08lx, 0x%08lx,",
1693: (unsigned long) kdecomps[i].code, (unsigned long) idx);
1694: idx += kdecomps[i].used;
1695: }
1696:
1697: /*
1698: * Write the sentinel index as the last decomp node.
1699: */
1700: fprintf(out, "\n\t0x%08lx\n};\n\n", (unsigned long) idx);
1701:
1702: fprintf(out, PREF "ac_uint4 _uckdcmp_decomp[] = {");
1703:
1704: /*
1705: * Write the decompositions themselves.
1706: */
1707: k = 0;
1708: for (i = 0; i < kdecomps_used; i++)
1709: for (j=0; j<kdecomps[i].used; j++) {
1710: if (k) fprintf(out, ",");
1711: if (!(k&3)) fprintf(out,"\n\t");
1712: else fprintf(out, " ");
1713: k++;
1714: fprintf(out, "0x%08lx", (unsigned long) kdecomps[i].decomp[j]);
1715: }
1716: fprintf(out, "\n};\n\n");
1717: }
1718: #else
1719: /*
1720: * Open the kdecomp.dat file.
1721: */
1722: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "kdecomp.dat", opath);
1723: if ((out = fopen(path, "wb")) == 0)
1724: return;
1725:
1726: hdr[1] = kdecomps_used;
1727:
1728: /*
1729: * Write the header.
1730: */
1731: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1732:
1733: /*
1734: * Write a temporary byte count which will be calculated as the
1735: * decompositions are written out.
1736: */
1737: bytes = 0;
1738: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1739:
1740: if (kdecomps_used) {
1741: /*
1742: * Write the list of kdecomp nodes.
1743: */
1744: for (i = idx = 0; i < kdecomps_used; i++) {
1745: fwrite((char *) &kdecomps[i].code, sizeof(ac_uint4), 1, out);
1746: fwrite((char *) &idx, sizeof(ac_uint4), 1, out);
1747: idx += kdecomps[i].used;
1748: }
1749:
1750: /*
1751: * Write the sentinel index as the last decomp node.
1752: */
1753: fwrite((char *) &idx, sizeof(ac_uint4), 1, out);
1754:
1755: /*
1756: * Write the decompositions themselves.
1757: */
1758: for (i = 0; i < kdecomps_used; i++)
1759: fwrite((char *) kdecomps[i].decomp, sizeof(ac_uint4),
1760: kdecomps[i].used, out);
1761:
1762: /*
1763: * Seek back to the beginning and write the byte count.
1764: */
1765: bytes = (sizeof(ac_uint4) * idx) +
1766: (sizeof(ac_uint4) * ((hdr[1] << 1) + 1));
1767: fseek(out, sizeof(ac_uint2) << 1, 0L);
1768: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1769:
1770: fclose(out);
1771: }
1772: #endif
1773:
1774: /*****************************************************************
1775: *
1776: * Generate the combining class data.
1777: *
1778: *****************************************************************/
1779: #ifdef HARDCODE_DATA
1780: fprintf(out, PREF "ac_uint4 _uccmcl_size = %ld;\n\n", (long) ccl_used);
1781:
1782: fprintf(out, PREF "ac_uint4 _uccmcl_nodes[] = {");
1783:
1784: if (ccl_used > 0) {
1785: /*
1786: * Write the combining class ranges out.
1787: */
1788: for (i = 0; i<ccl_used; i++) {
1789: if (i) fprintf(out, ",");
1790: if (!(i&3)) fprintf(out, "\n\t");
1791: else fprintf(out, " ");
1792: fprintf(out, "0x%08lx", (unsigned long) ccl[i]);
1793: }
1794: } else {
1795: fprintf(out, "\t0");
1796: }
1797: fprintf(out, "\n};\n\n");
1798: #else
1799: /*
1800: * Open the cmbcl.dat file.
1801: */
1802: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "cmbcl.dat", opath);
1803: if ((out = fopen(path, "wb")) == 0)
1804: return;
1805:
1806: /*
1807: * Set the number of ranges used. Each range has a combining class which
1808: * means each entry is a 3-tuple.
1809: */
1810: hdr[1] = ccl_used / 3;
1811:
1812: /*
1813: * Write the header.
1814: */
1815: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1816:
1817: /*
1818: * Write out the byte count to maintain header size.
1819: */
1820: bytes = ccl_used * sizeof(ac_uint4);
1821: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1822:
1823: if (ccl_used > 0)
1824: /*
1825: * Write the combining class ranges out.
1826: */
1827: fwrite((char *) ccl, sizeof(ac_uint4), ccl_used, out);
1828:
1829: fclose(out);
1830: #endif
1831:
1832: /*****************************************************************
1833: *
1834: * Generate the number data.
1835: *
1836: *****************************************************************/
1837:
1838: #if HARDCODE_DATA
1839: fprintf(out, PREF "ac_uint4 _ucnum_size = %lu;\n\n",
1840: (unsigned long)ncodes_used<<1);
1841:
1842: fprintf(out, PREF "ac_uint4 _ucnum_nodes[] = {");
1843:
1844: /*
1845: * Now, if number mappings exist, write them out.
1846: */
1847: if (ncodes_used > 0) {
1848: for (i = 0; i<ncodes_used; i++) {
1849: if (i) fprintf(out, ",");
1850: if (!(i&1)) fprintf(out, "\n\t");
1851: else fprintf(out, " ");
1852: fprintf(out, "0x%08lx, 0x%08lx",
1853: (unsigned long) ncodes[i].code, (unsigned long) ncodes[i].idx);
1854: }
1855: fprintf(out, "\n};\n\n");
1856:
1857: fprintf(out, PREF "short _ucnum_vals[] = {");
1858: for (i = 0; i<nums_used; i++) {
1859: if (i) fprintf(out, ",");
1860: if (!(i&3)) fprintf(out, "\n\t");
1861: else fprintf(out, " ");
1862: if (nums[i].numerator < 0) {
1863: fprintf(out, "%6d, 0x%04x",
1864: nums[i].numerator, nums[i].denominator);
1865: } else {
1866: fprintf(out, "0x%04x, 0x%04x",
1867: nums[i].numerator, nums[i].denominator);
1868: }
1869: }
1870: fprintf(out, "\n};\n\n");
1871: }
1872: #else
1873: /*
1874: * Open the num.dat file.
1875: */
1876: snprintf(path, sizeof path, "%s" LDAP_DIRSEP "num.dat", opath);
1877: if ((out = fopen(path, "wb")) == 0)
1878: return;
1879:
1880: /*
1881: * The count part of the header will be the total number of codes that
1882: * have numbers.
1883: */
1884: hdr[1] = (ac_uint2) (ncodes_used << 1);
1885: bytes = (ncodes_used * sizeof(_codeidx_t)) + (nums_used * sizeof(_num_t));
1886:
1887: /*
1888: * Write the header.
1889: */
1890: fwrite((char *) hdr, sizeof(ac_uint2), 2, out);
1891:
1892: /*
1893: * Write out the byte count to maintain header size.
1894: */
1895: fwrite((char *) &bytes, sizeof(ac_uint4), 1, out);
1896:
1897: /*
1898: * Now, if number mappings exist, write them out.
1899: */
1900: if (ncodes_used > 0) {
1901: fwrite((char *) ncodes, sizeof(_codeidx_t), ncodes_used, out);
1902: fwrite((char *) nums, sizeof(_num_t), nums_used, out);
1903: }
1904: #endif
1905:
1906: #endif
1907:
1908: fclose(out);
1909: }
1910:
1911: static void
1912: usage(char *prog)
1913: {
1914: fprintf(stderr,
1915: "Usage: %s [-o output-directory|-x composition-exclusions]", prog);
1916: fprintf(stderr, " datafile1 datafile2 ...\n\n");
1917: fprintf(stderr,
1918: "-o output-directory\n\t\tWrite the output files to a different");
1919: fprintf(stderr, " directory (default: .).\n");
1920: fprintf(stderr,
1921: "-x composition-exclusion\n\t\tFile of composition codes");
1922: fprintf(stderr, " that should be excluded.\n");
1923: exit(1);
1924: }
1925:
1926: int
1927: main(int argc, char *argv[])
1928: {
1929: FILE *in;
1930: char *prog, *opath;
1931:
1932: prog = argv[1];
1933:
1934: opath = 0;
1935: in = stdin;
1936:
1937: argc--;
1938: argv++;
1939:
1940: while (argc > 0) {
1941: if (argv[0][0] == '-') {
1942: switch (argv[0][1]) {
1943: case 'o':
1944: argc--;
1945: argv++;
1946: opath = argv[0];
1947: break;
1948: case 'x':
1949: argc--;
1950: argv++;
1951: if ((in = fopen(argv[0], "r")) == 0)
1952: fprintf(stderr,
1953: "%s: unable to open composition exclusion file %s\n",
1954: prog, argv[0]);
1955: else {
1956: read_compexdata(in);
1957: fclose(in);
1958: in = 0;
1959: }
1960: break;
1961: default:
1962: usage(prog);
1963: }
1964: } else {
1965: if (in != stdin && in != NULL)
1966: fclose(in);
1967: if ((in = fopen(argv[0], "r")) == 0)
1968: fprintf(stderr, "%s: unable to open ctype file %s\n",
1969: prog, argv[0]);
1970: else {
1971: read_cdata(in);
1972: fclose(in);
1973: in = 0;
1974: }
1975: }
1976: argc--;
1977: argv++;
1978: }
1979:
1980: if (opath == 0)
1981: opath = ".";
1982: write_cdata(opath);
1983:
1984: return 0;
1985: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ucgendat.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / ucgendat