The Tor Browser / file comparison

comparison: intl/unicharutil/src/ucdata.c

intl/unicharutil/src/ucdata.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1a35d6d33f67
1 /*
2 * Copyright 1996, 1997, 1998 Computing Research Labs,
3 * New Mexico State University
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
19 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
20 * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23 #ifndef lint
24 #ifdef __GNUC__
25 static char rcsid[] __attribute__ ((unused)) = "$Id: ucdata.c,v 1.1 1999/01/08 00:19:11 ftang%netscape.com Exp $";
26 #else
27 static char rcsid[] = "$Id: ucdata.c,v 1.1 1999/01/08 00:19:11 ftang%netscape.com Exp $";
28 #endif
29 #endif
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #ifndef WIN32
35 #include <unistd.h>
36 #endif
37
38 #include "ucdata.h"
39
40 /**************************************************************************
41 *
42 * Miscellaneous types, data, and support functions.
43 *
44 **************************************************************************/
45
46 typedef struct {
47 unsigned short bom;
48 unsigned short cnt;
49 union {
50 unsigned long bytes;
51 unsigned short len[2];
52 } size;
53 } _ucheader_t;
54
55 /*
56 * A simple array of 32-bit masks for lookup.
57 */
58 static unsigned long masks32[32] = {
59 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020,
60 0x00000040, 0x00000080, 0x00000100, 0x00000200, 0x00000400, 0x00000800,
61 0x00001000, 0x00002000, 0x00004000, 0x00008000, 0x00010000, 0x00020000,
62 0x00040000, 0x00080000, 0x00100000, 0x00200000, 0x00400000, 0x00800000,
63 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000,
64 0x40000000, 0x80000000
65 };
66
67 #define endian_short(cc) (((cc) >> 8) | (((cc) & 0xff) << 8))
68 #define endian_long(cc) ((((cc) & 0xff) << 24)|((((cc) >> 8) & 0xff) << 16)|\
69 ((((cc) >> 16) & 0xff) << 8)|((cc) >> 24))
70
71 static FILE *
72 #ifdef __STDC__
73 _ucopenfile(char *paths, char *filename, char *mode)
74 #else
75 _ucopenfile(paths, filename, mode)
76 char *paths, *filename, *mode;
77 #endif
78 {
79 FILE *f;
80 char *fp, *dp, *pp, path[BUFSIZ];
81
82 if (filename == 0 || *filename == 0)
83 return 0;
84
85 dp = paths;
86 while (dp && *dp) {
87 pp = path;
88 while (*dp && *dp != ':')
89 *pp++ = *dp++;
90 *pp++ = '/';
91
92 fp = filename;
93 while (*fp)
94 *pp++ = *fp++;
95 *pp = 0;
96
97 if ((f = fopen(path, mode)) != 0)
98 return f;
99
100 if (*dp == ':')
101 dp++;
102 }
103
104 return 0;
105 }
106
107 /**************************************************************************
108 *
109 * Support for the character properties.
110 *
111 **************************************************************************/
112
113 static unsigned long _ucprop_size;
114 static unsigned short *_ucprop_offsets;
115 static unsigned long *_ucprop_ranges;
116
117 static void
118 #ifdef __STDC__
119 _ucprop_load(char *paths, int reload)
120 #else
121 _ucprop_load(paths, reload)
122 char *paths;
123 int reload;
124 #endif
125 {
126 FILE *in;
127 unsigned long size, i;
128 _ucheader_t hdr;
129
130 if (_ucprop_size > 0) {
131 if (!reload)
132 /*
133 * The character properties have already been loaded.
134 */
135 return;
136
137 /*
138 * Unload the current character property data in preparation for
139 * loading a new copy. Only the first array has to be deallocated
140 * because all the memory for the arrays is allocated as a single
141 * block.
142 */
143 free((char *) _ucprop_offsets);
144 _ucprop_size = 0;
145 }
146
147 if ((in = _ucopenfile(paths, "ctype.dat", "rb")) == 0)
148 return;
149
150 /*
151 * Load the header.
152 */
153 fread((char *) &hdr, sizeof(_ucheader_t), 1, in);
154
155 if (hdr.bom == 0xfffe) {
156 hdr.cnt = endian_short(hdr.cnt);
157 hdr.size.bytes = endian_long(hdr.size.bytes);
158 }
159
160 if ((_ucprop_size = hdr.cnt) == 0) {
161 fclose(in);
162 return;
163 }
164
165 /*
166 * Allocate all the storage needed for the lookup table.
167 */
168 _ucprop_offsets = (unsigned short *) malloc(hdr.size.bytes);
169
170 /*
171 * Calculate the offset into the storage for the ranges. The offsets
172 * array is on a 4-byte boundary and one larger than the value provided in
173 * the header count field. This means the offset to the ranges must be
174 * calculated after aligning the count to a 4-byte boundary.
175 */
176 if ((size = ((hdr.cnt + 1) * sizeof(unsigned short))) & 3)
177 size += 4 - (size & 3);
178 size >>= 1;
179 _ucprop_ranges = (unsigned long *) (_ucprop_offsets + size);
180
181 /*
182 * Load the offset array.
183 */
184 fread((char *) _ucprop_offsets, sizeof(unsigned short), size, in);
185
186 /*
187 * Do an endian swap if necessary. Don't forget there is an extra node on
188 * the end with the final index.
189 */
190 if (hdr.bom == 0xfffe) {
191 for (i = 0; i <= _ucprop_size; i++)
192 _ucprop_offsets[i] = endian_short(_ucprop_offsets[i]);
193 }
194
195 /*
196 * Load the ranges. The number of elements is in the last array position
197 * of the offsets.
198 */
199 fread((char *) _ucprop_ranges, sizeof(unsigned long),
200 _ucprop_offsets[_ucprop_size], in);
201
202 fclose(in);
203
204 /*
205 * Do an endian swap if necessary.
206 */
207 if (hdr.bom == 0xfffe) {
208 for (i = 0; i < _ucprop_offsets[_ucprop_size]; i++)
209 _ucprop_ranges[i] = endian_long(_ucprop_ranges[i]);
210 }
211 }
212
213 static void
214 #ifdef __STDC__
215 _ucprop_unload(void)
216 #else
217 _ucprop_unload()
218 #endif
219 {
220 if (_ucprop_size == 0)
221 return;
222
223 /*
224 * Only need to free the offsets because the memory is allocated as a
225 * single block.
226 */
227 free((char *) _ucprop_offsets);
228 _ucprop_size = 0;
229 }
230
231 static int
232 #ifdef __STDC__
233 _ucprop_lookup(unsigned long code, unsigned long n)
234 #else
235 _ucprop_lookup(code, n)
236 unsigned long code, n;
237 #endif
238 {
239 long l, r, m;
240
241 /*
242 * There is an extra node on the end of the offsets to allow this routine
243 * to work right. If the index is 0xffff, then there are no nodes for the
244 * property.
245 */
246 if ((l = _ucprop_offsets[n]) == 0xffff)
247 return 0;
248
249 /*
250 * Locate the next offset that is not 0xffff. The sentinel at the end of
251 * the array is the max index value.
252 */
253 for (m = 1;
254 n + m < _ucprop_size && _ucprop_offsets[n + m] == 0xffff; m++) ;
255
256 r = _ucprop_offsets[n + m] - 1;
257
258 while (l <= r) {
259 /*
260 * Determine a "mid" point and adjust to make sure the mid point is at
261 * the beginning of a range pair.
262 */
263 m = (l + r) >> 1;
264 m -= (m & 1);
265 if (code > _ucprop_ranges[m + 1])
266 l = m + 2;
267 else if (code < _ucprop_ranges[m])
268 r = m - 2;
269 else if (code >= _ucprop_ranges[m] && code <= _ucprop_ranges[m + 1])
270 return 1;
271 }
272 return 0;
273 }
274
275 int
276 #ifdef __STDC__
277 ucisprop(unsigned long code, unsigned long mask1, unsigned long mask2)
278 #else
279 ucisprop(code, mask1, mask2)
280 unsigned long code, mask1, mask2;
281 #endif
282 {
283 unsigned long i;
284
285 if (mask1 == 0 && mask2 == 0)
286 return 0;
287
288 for (i = 0; mask1 && i < 32; i++) {
289 if ((mask1 & masks32[i]) && _ucprop_lookup(code, i))
290 return 1;
291 }
292
293 for (i = 32; mask2 && i < _ucprop_size; i++) {
294 if ((mask2 & masks32[i & 31]) && _ucprop_lookup(code, i))
295 return 1;
296 }
297
298 return 0;
299 }
300
301 /**************************************************************************
302 *
303 * Support for case mapping.
304 *
305 **************************************************************************/
306
307 static unsigned long _uccase_size;
308 static unsigned short _uccase_len[2];
309 static unsigned long *_uccase_map;
310
311 static void
312 #ifdef __STDC__
313 _uccase_load(char *paths, int reload)
314 #else
315 _uccase_load(paths, reload)
316 char *paths;
317 int reload;
318 #endif
319 {
320 FILE *in;
321 unsigned long i;
322 _ucheader_t hdr;
323
324 if (_uccase_size > 0) {
325 if (!reload)
326 /*
327 * The case mappings have already been loaded.
328 */
329 return;
330
331 free((char *) _uccase_map);
332 _uccase_size = 0;
333 }
334
335 if ((in = _ucopenfile(paths, "case.dat", "rb")) == 0)
336 return;
337
338 /*
339 * Load the header.
340 */
341 fread((char *) &hdr, sizeof(_ucheader_t), 1, in);
342
343 if (hdr.bom == 0xfffe) {
344 hdr.cnt = endian_short(hdr.cnt);
345 hdr.size.len[0] = endian_short(hdr.size.len[0]);
346 hdr.size.len[1] = endian_short(hdr.size.len[1]);
347 }
348
349 /*
350 * Set the node count and lengths of the upper and lower case mapping
351 * tables.
352 */
353 _uccase_size = hdr.cnt * 3;
354 _uccase_len[0] = hdr.size.len[0] * 3;
355 _uccase_len[1] = hdr.size.len[1] * 3;
356
357 _uccase_map = (unsigned long *)
358 malloc(_uccase_size * sizeof(unsigned long));
359
360 /*
361 * Load the case mapping table.
362 */
363 fread((char *) _uccase_map, sizeof(unsigned long), _uccase_size, in);
364
365 /*
366 * Do an endian swap if necessary.
367 */
368 if (hdr.bom == 0xfffe) {
369 for (i = 0; i < _uccase_size; i++)
370 _uccase_map[i] = endian_long(_uccase_map[i]);
371 }
372 }
373
374 static void
375 #ifdef __STDC__
376 _uccase_unload(void)
377 #else
378 _uccase_unload()
379 #endif
380 {
381 if (_uccase_size == 0)
382 return;
383
384 free((char *) _uccase_map);
385 _uccase_size = 0;
386 }
387
388 static unsigned long
389 #ifdef __STDC__
390 _uccase_lookup(unsigned long code, long l, long r, int field)
391 #else
392 _uccase_lookup(code, l, r, field)
393 unsigned long code;
394 long l, r;
395 int field;
396 #endif
397 {
398 long m;
399
400 /*
401 * Do the binary search.
402 */
403 while (l <= r) {
404 /*
405 * Determine a "mid" point and adjust to make sure the mid point is at
406 * the beginning of a case mapping triple.
407 */
408 m = (l + r) >> 1;
409 m -= (m % 3);
410 if (code > _uccase_map[m])
411 l = m + 3;
412 else if (code < _uccase_map[m])
413 r = m - 3;
414 else if (code == _uccase_map[m])
415 return _uccase_map[m + field];
416 }
417
418 return code;
419 }
420
421 unsigned long
422 #ifdef __STDC__
423 uctoupper(unsigned long code)
424 #else
425 uctoupper(code)
426 unsigned long code;
427 #endif
428 {
429 int field;
430 long l, r;
431
432 if (ucisupper(code))
433 return code;
434
435 if (ucislower(code)) {
436 /*
437 * The character is lower case.
438 */
439 field = 1;
440 l = _uccase_len[0];
441 r = (l + _uccase_len[1]) - 1;
442 } else {
443 /*
444 * The character is title case.
445 */
446 field = 2;
447 l = _uccase_len[0] + _uccase_len[1];
448 r = _uccase_size - 1;
449 }
450 return _uccase_lookup(code, l, r, field);
451 }
452
453 unsigned long
454 #ifdef __STDC__
455 uctolower(unsigned long code)
456 #else
457 uctolower(code)
458 unsigned long code;
459 #endif
460 {
461 int field;
462 long l, r;
463
464 if (ucislower(code))
465 return code;
466
467 if (ucisupper(code)) {
468 /*
469 * The character is upper case.
470 */
471 field = 1;
472 l = 0;
473 r = _uccase_len[0] - 1;
474 } else {
475 /*
476 * The character is title case.
477 */
478 field = 2;
479 l = _uccase_len[0] + _uccase_len[1];
480 r = _uccase_size - 1;
481 }
482 return _uccase_lookup(code, l, r, field);
483 }
484
485 unsigned long
486 #ifdef __STDC__
487 uctotitle(unsigned long code)
488 #else
489 uctotitle(code)
490 unsigned long code;
491 #endif
492 {
493 int field;
494 long l, r;
495
496 if (ucistitle(code))
497 return code;
498
499 /*
500 * The offset will always be the same for converting to title case.
501 */
502 field = 2;
503
504 if (ucisupper(code)) {
505 /*
506 * The character is upper case.
507 */
508 l = 0;
509 r = _uccase_len[0] - 1;
510 } else {
511 /*
512 * The character is lower case.
513 */
514 l = _uccase_len[0];
515 r = (l + _uccase_len[1]) - 1;
516 }
517 return _uccase_lookup(code, l, r, field);
518 }
519
520 /**************************************************************************
521 *
522 * Support for decompositions.
523 *
524 **************************************************************************/
525
526 static unsigned long _ucdcmp_size;
527 static unsigned long *_ucdcmp_nodes;
528 static unsigned long *_ucdcmp_decomp;
529
530 static void
531 #ifdef __STDC__
532 _ucdcmp_load(char *paths, int reload)
533 #else
534 _ucdcmp_load(paths, reload)
535 char *paths;
536 int reload;
537 #endif
538 {
539 FILE *in;
540 unsigned long size, i;
541 _ucheader_t hdr;
542
543 if (_ucdcmp_size > 0) {
544 if (!reload)
545 /*
546 * The decompositions have already been loaded.
547 */
548 return;
549
550 free((char *) _ucdcmp_nodes);
551 _ucdcmp_size = 0;
552 }
553
554 if ((in = _ucopenfile(paths, "decomp.dat", "rb")) == 0)
555 return;
556
557 /*
558 * Load the header.
559 */
560 fread((char *) &hdr, sizeof(_ucheader_t), 1, in);
561
562 if (hdr.bom == 0xfffe) {
563 hdr.cnt = endian_short(hdr.cnt);
564 hdr.size.bytes = endian_long(hdr.size.bytes);
565 }
566
567 _ucdcmp_size = hdr.cnt << 1;
568 _ucdcmp_nodes = (unsigned long *) malloc(hdr.size.bytes);
569 _ucdcmp_decomp = _ucdcmp_nodes + (_ucdcmp_size + 1);
570
571 /*
572 * Read the decomposition data in.
573 */
574 size = hdr.size.bytes / sizeof(unsigned long);
575 fread((char *) _ucdcmp_nodes, sizeof(unsigned long), size, in);
576
577 /*
578 * Do an endian swap if necessary.
579 */
580 if (hdr.bom == 0xfffe) {
581 for (i = 0; i < size; i++)
582 _ucdcmp_nodes[i] = endian_long(_ucdcmp_nodes[i]);
583 }
584 }
585
586 static void
587 #ifdef __STDC__
588 _ucdcmp_unload(void)
589 #else
590 _ucdcmp_unload()
591 #endif
592 {
593 if (_ucdcmp_size == 0)
594 return;
595
596 /*
597 * Only need to free the offsets because the memory is allocated as a
598 * single block.
599 */
600 free((char *) _ucdcmp_nodes);
601 _ucdcmp_size = 0;
602 }
603
604 int
605 #ifdef __STDC__
606 ucdecomp(unsigned long code, unsigned long *num, unsigned long **decomp)
607 #else
608 ucdecomp(code, num, decomp)
609 unsigned long code, *num, **decomp;
610 #endif
611 {
612 long l, r, m;
613
614 l = 0;
615 r = _ucdcmp_nodes[_ucdcmp_size] - 1;
616
617 while (l <= r) {
618 /*
619 * Determine a "mid" point and adjust to make sure the mid point is at
620 * the beginning of a code+offset pair.
621 */
622 m = (l + r) >> 1;
623 m -= (m & 1);
624 if (code > _ucdcmp_nodes[m])
625 l = m + 2;
626 else if (code < _ucdcmp_nodes[m])
627 r = m - 2;
628 else if (code == _ucdcmp_nodes[m]) {
629 *num = _ucdcmp_nodes[m + 3] - _ucdcmp_nodes[m + 1];
630 *decomp = &_ucdcmp_decomp[_ucdcmp_nodes[m + 1]];
631 return 1;
632 }
633 }
634 return 0;
635 }
636
637 int
638 #ifdef __STDC__
639 ucdecomp_hangul(unsigned long code, unsigned long *num, unsigned long decomp[])
640 #else
641 ucdecomp_hangul(code, num, decomp)
642 unsigned long code, *num, decomp[];
643 #endif
644 {
645 if (!ucishangul(code))
646 return 0;
647
648 code -= 0xac00;
649 decomp[0] = 0x1100 + (unsigned long) (code / 588);
650 decomp[1] = 0x1161 + (unsigned long) ((code % 588) / 28);
651 decomp[2] = 0x11a7 + (unsigned long) (code % 28);
652 *num = (decomp[2] != 0x11a7) ? 3 : 2;
653
654 return 1;
655 }
656
657 /**************************************************************************
658 *
659 * Support for combining classes.
660 *
661 **************************************************************************/
662
663 static unsigned long _uccmcl_size;
664 static unsigned long *_uccmcl_nodes;
665
666 static void
667 #ifdef __STDC__
668 _uccmcl_load(char *paths, int reload)
669 #else
670 _uccmcl_load(paths, reload)
671 char *paths;
672 int reload;
673 #endif
674 {
675 FILE *in;
676 unsigned long i;
677 _ucheader_t hdr;
678
679 if (_uccmcl_size > 0) {
680 if (!reload)
681 /*
682 * The combining classes have already been loaded.
683 */
684 return;
685
686 free((char *) _uccmcl_nodes);
687 _uccmcl_size = 0;
688 }
689
690 if ((in = _ucopenfile(paths, "cmbcl.dat", "rb")) == 0)
691 return;
692
693 /*
694 * Load the header.
695 */
696 fread((char *) &hdr, sizeof(_ucheader_t), 1, in);
697
698 if (hdr.bom == 0xfffe) {
699 hdr.cnt = endian_short(hdr.cnt);
700 hdr.size.bytes = endian_long(hdr.size.bytes);
701 }
702
703 _uccmcl_size = hdr.cnt * 3;
704 _uccmcl_nodes = (unsigned long *) malloc(hdr.size.bytes);
705
706 /*
707 * Read the combining classes in.
708 */
709 fread((char *) _uccmcl_nodes, sizeof(unsigned long), _uccmcl_size, in);
710
711 /*
712 * Do an endian swap if necessary.
713 */
714 if (hdr.bom == 0xfffe) {
715 for (i = 0; i < _uccmcl_size; i++)
716 _uccmcl_nodes[i] = endian_long(_uccmcl_nodes[i]);
717 }
718 }
719
720 static void
721 #ifdef __STDC__
722 _uccmcl_unload(void)
723 #else
724 _uccmcl_unload()
725 #endif
726 {
727 if (_uccmcl_size == 0)
728 return;
729
730 free((char *) _uccmcl_nodes);
731 _uccmcl_size = 0;
732 }
733
734 unsigned long
735 #ifdef __STDC__
736 uccombining_class(unsigned long code)
737 #else
738 uccombining_class(code)
739 unsigned long code;
740 #endif
741 {
742 long l, r, m;
743
744 l = 0;
745 r = _uccmcl_size - 1;
746
747 while (l <= r) {
748 m = (l + r) >> 1;
749 m -= (m % 3);
750 if (code > _uccmcl_nodes[m + 1])
751 l = m + 3;
752 else if (code < _uccmcl_nodes[m])
753 r = m - 3;
754 else if (code >= _uccmcl_nodes[m] && code <= _uccmcl_nodes[m + 1])
755 return _uccmcl_nodes[m + 2];
756 }
757 return 0;
758 }
759
760 /**************************************************************************
761 *
762 * Support for numeric values.
763 *
764 **************************************************************************/
765
766 static unsigned long *_ucnum_nodes;
767 static unsigned long _ucnum_size;
768 static short *_ucnum_vals;
769
770 static void
771 #ifdef __STDC__
772 _ucnumb_load(char *paths, int reload)
773 #else
774 _ucnumb_load(paths, reload)
775 char *paths;
776 int reload;
777 #endif
778 {
779 FILE *in;
780 unsigned long size, i;
781 _ucheader_t hdr;
782
783 if (_ucnum_size > 0) {
784 if (!reload)
785 /*
786 * The numbers have already been loaded.
787 */
788 return;
789
790 free((char *) _ucnum_nodes);
791 _ucnum_size = 0;
792 }
793
794 if ((in = _ucopenfile(paths, "num.dat", "rb")) == 0)
795 return;
796
797 /*
798 * Load the header.
799 */
800 fread((char *) &hdr, sizeof(_ucheader_t), 1, in);
801
802 if (hdr.bom == 0xfffe) {
803 hdr.cnt = endian_short(hdr.cnt);
804 hdr.size.bytes = endian_long(hdr.size.bytes);
805 }
806
807 _ucnum_size = hdr.cnt;
808 _ucnum_nodes = (unsigned long *) malloc(hdr.size.bytes);
809 _ucnum_vals = (short *) (_ucnum_nodes + _ucnum_size);
810
811 /*
812 * Read the combining classes in.
813 */
814 fread((char *) _ucnum_nodes, sizeof(unsigned char), hdr.size.bytes, in);
815
816 /*
817 * Do an endian swap if necessary.
818 */
819 if (hdr.bom == 0xfffe) {
820 for (i = 0; i < _ucnum_size; i++)
821 _ucnum_nodes[i] = endian_long(_ucnum_nodes[i]);
822
823 /*
824 * Determine the number of values that have to be adjusted.
825 */
826 size = (hdr.size.bytes -
827 (_ucnum_size * (sizeof(unsigned long) << 1))) /
828 sizeof(short);
829
830 for (i = 0; i < size; i++)
831 _ucnum_vals[i] = endian_short(_ucnum_vals[i]);
832 }
833 }
834
835 static void
836 #ifdef __STDC__
837 _ucnumb_unload(void)
838 #else
839 _ucnumb_unload()
840 #endif
841 {
842 if (_ucnum_size == 0)
843 return;
844
845 free((char *) _ucnum_nodes);
846 _ucnum_size = 0;
847 }
848
849 int
850 #ifdef __STDC__
851 ucnumber_lookup(unsigned long code, struct ucnumber *num)
852 #else
853 ucnumber_lookup(code, num)
854 unsigned long code;
855 struct ucnumber *num;
856 #endif
857 {
858 long l, r, m;
859 short *vp;
860
861 l = 0;
862 r = _ucnum_size - 1;
863 while (l <= r) {
864 /*
865 * Determine a "mid" point and adjust to make sure the mid point is at
866 * the beginning of a code+offset pair.
867 */
868 m = (l + r) >> 1;
869 m -= (m & 1);
870 if (code > _ucnum_nodes[m])
871 l = m + 2;
872 else if (code < _ucnum_nodes[m])
873 r = m - 2;
874 else {
875 vp = _ucnum_vals + _ucnum_nodes[m + 1];
876 num->numerator = (int) *vp++;
877 num->denominator = (int) *vp;
878 return 1;
879 }
880 }
881 return 0;
882 }
883
884 int
885 #ifdef __STDC__
886 ucdigit_lookup(unsigned long code, int *digit)
887 #else
888 ucdigit_lookup(code, digit)
889 unsigned long code;
890 int *digit;
891 #endif
892 {
893 long l, r, m;
894 short *vp;
895
896 l = 0;
897 r = _ucnum_size - 1;
898 while (l <= r) {
899 /*
900 * Determine a "mid" point and adjust to make sure the mid point is at
901 * the beginning of a code+offset pair.
902 */
903 m = (l + r) >> 1;
904 m -= (m & 1);
905 if (code > _ucnum_nodes[m])
906 l = m + 2;
907 else if (code < _ucnum_nodes[m])
908 r = m - 2;
909 else {
910 vp = _ucnum_vals + _ucnum_nodes[m + 1];
911 if (*vp == *(vp + 1)) {
912 *digit = *vp;
913 return 1;
914 }
915 return 0;
916 }
917 }
918 return 0;
919 }
920
921 struct ucnumber
922 #ifdef __STDC__
923 ucgetnumber(unsigned long code)
924 #else
925 ucgetnumber(code)
926 unsigned long code;
927 #endif
928 {
929 struct ucnumber num;
930
931 /*
932 * Initialize with some arbitrary value, because the caller simply cannot
933 * tell for sure if the code is a number without calling the ucisnumber()
934 * macro before calling this function.
935 */
936 num.numerator = num.denominator = -111;
937
938 (void) ucnumber_lookup(code, &num);
939
940 return num;
941 }
942
943 int
944 #ifdef __STDC__
945 ucgetdigit(unsigned long code)
946 #else
947 ucgetdigit(code)
948 unsigned long code;
949 #endif
950 {
951 int dig;
952
953 /*
954 * Initialize with some arbitrary value, because the caller simply cannot
955 * tell for sure if the code is a number without calling the ucisdigit()
956 * macro before calling this function.
957 */
958 dig = -111;
959
960 (void) ucdigit_lookup(code, &dig);
961
962 return dig;
963 }
964
965 /**************************************************************************
966 *
967 * Setup and cleanup routines.
968 *
969 **************************************************************************/
970
971 void
972 #ifdef __STDC__
973 ucdata_load(char *paths, int masks)
974 #else
975 ucdata_load(paths, masks)
976 char *paths;
977 int masks;
978 #endif
979 {
980 if (masks & UCDATA_CTYPE)
981 _ucprop_load(paths, 0);
982 if (masks & UCDATA_CASE)
983 _uccase_load(paths, 0);
984 if (masks & UCDATA_DECOMP)
985 _ucdcmp_load(paths, 0);
986 if (masks & UCDATA_CMBCL)
987 _uccmcl_load(paths, 0);
988 if (masks & UCDATA_NUM)
989 _ucnumb_load(paths, 0);
990 }
991
992 void
993 #ifdef __STDC__
994 ucdata_unload(int masks)
995 #else
996 ucdata_unload(masks)
997 int masks;
998 #endif
999 {
1000 if (masks & UCDATA_CTYPE)
1001 _ucprop_unload();
1002 if (masks & UCDATA_CASE)
1003 _uccase_unload();
1004 if (masks & UCDATA_DECOMP)
1005 _ucdcmp_unload();
1006 if (masks & UCDATA_CMBCL)
1007 _uccmcl_unload();
1008 if (masks & UCDATA_NUM)
1009 _ucnumb_unload();
1010 }
1011
1012 void
1013 #ifdef __STDC__
1014 ucdata_reload(char *paths, int masks)
1015 #else
1016 ucdata_reload(paths, masks)
1017 char *paths;
1018 int masks;
1019 #endif
1020 {
1021 if (masks & UCDATA_CTYPE)
1022 _ucprop_load(paths, 1);
1023 if (masks & UCDATA_CASE)
1024 _uccase_load(paths, 1);
1025 if (masks & UCDATA_DECOMP)
1026 _ucdcmp_load(paths, 1);
1027 if (masks & UCDATA_CMBCL)
1028 _uccmcl_load(paths, 1);
1029 if (masks & UCDATA_NUM)
1030 _ucnumb_load(paths, 1);
1031 }
1032
1033 #ifdef TEST
1034
1035 void
1036 #ifdef __STDC__
1037 main(void)
1038 #else
1039 main()
1040 #endif
1041 {
1042 int dig;
1043 unsigned long i, lo, *dec;
1044 struct ucnumber num;
1045
1046 ucdata_setup(".");
1047
1048 if (ucisweak(0x30))
1049 printf("WEAK\n");
1050 else
1051 printf("NOT WEAK\n");
1052
1053 printf("LOWER 0x%04lX\n", uctolower(0xff3a));
1054 printf("UPPER 0x%04lX\n", uctoupper(0xff5a));
1055
1056 if (ucisalpha(0x1d5))
1057 printf("ALPHA\n");
1058 else
1059 printf("NOT ALPHA\n");
1060
1061 if (ucisupper(0x1d5)) {
1062 printf("UPPER\n");
1063 lo = uctolower(0x1d5);
1064 printf("0x%04lx\n", lo);
1065 lo = uctotitle(0x1d5);
1066 printf("0x%04lx\n", lo);
1067 } else
1068 printf("NOT UPPER\n");
1069
1070 if (ucistitle(0x1d5))
1071 printf("TITLE\n");
1072 else
1073 printf("NOT TITLE\n");
1074
1075 if (uciscomposite(0x1d5))
1076 printf("COMPOSITE\n");
1077 else
1078 printf("NOT COMPOSITE\n");
1079
1080 if (ucdecomp(0x1d5, &lo, &dec)) {
1081 for (i = 0; i < lo; i++)
1082 printf("0x%04lx ", dec[i]);
1083 putchar('\n');
1084 }
1085
1086 if ((lo = uccombining_class(0x41)) != 0)
1087 printf("0x41 CCL %ld\n", lo);
1088
1089 if (ucisxdigit(0xfeff))
1090 printf("0xFEFF HEX DIGIT\n");
1091 else
1092 printf("0xFEFF NOT HEX DIGIT\n");
1093
1094 if (ucisdefined(0x10000))
1095 printf("0x10000 DEFINED\n");
1096 else
1097 printf("0x10000 NOT DEFINED\n");
1098
1099 if (ucnumber_lookup(0x30, &num)) {
1100 if (num.numerator != num.denominator)
1101 printf("UCNUMBER: 0x30 = %d/%d\n", num.numerator, num.denominator);
1102 else
1103 printf("UCNUMBER: 0x30 = %d\n", num.numerator);
1104 } else
1105 printf("UCNUMBER: 0x30 NOT A NUMBER\n");
1106
1107 if (ucnumber_lookup(0xbc, &num)) {
1108 if (num.numerator != num.denominator)
1109 printf("UCNUMBER: 0xbc = %d/%d\n", num.numerator, num.denominator);
1110 else
1111 printf("UCNUMBER: 0xbc = %d\n", num.numerator);
1112 } else
1113 printf("UCNUMBER: 0xbc NOT A NUMBER\n");
1114
1115
1116 if (ucnumber_lookup(0xff19, &num)) {
1117 if (num.numerator != num.denominator)
1118 printf("UCNUMBER: 0xff19 = %d/%d\n", num.numerator, num.denominator);
1119 else
1120 printf("UCNUMBER: 0xff19 = %d\n", num.numerator);
1121 } else
1122 printf("UCNUMBER: 0xff19 NOT A NUMBER\n");
1123
1124 if (ucnumber_lookup(0x4e00, &num)) {
1125 if (num.numerator != num.denominator)
1126 printf("UCNUMBER: 0x4e00 = %d/%d\n", num.numerator, num.denominator);
1127 else
1128 printf("UCNUMBER: 0x4e00 = %d\n", num.numerator);
1129 } else
1130 printf("UCNUMBER: 0x4e00 NOT A NUMBER\n");
1131
1132 if (ucdigit_lookup(0x06f9, &dig))
1133 printf("UCDIGIT: 0x6f9 = %d\n", dig);
1134 else
1135 printf("UCDIGIT: 0x6f9 NOT A NUMBER\n");
1136
1137 dig = ucgetdigit(0x0969);
1138 printf("UCGETDIGIT: 0x969 = %d\n", dig);
1139
1140 num = ucgetnumber(0x30);
1141 if (num.numerator != num.denominator)
1142 printf("UCGETNUMBER: 0x30 = %d/%d\n", num.numerator, num.denominator);
1143 else
1144 printf("UCGETNUMBER: 0x30 = %d\n", num.numerator);
1145
1146 num = ucgetnumber(0xbc);
1147 if (num.numerator != num.denominator)
1148 printf("UCGETNUMBER: 0xbc = %d/%d\n", num.numerator, num.denominator);
1149 else
1150 printf("UCGETNUMBER: 0xbc = %d\n", num.numerator);
1151
1152 num = ucgetnumber(0xff19);
1153 if (num.numerator != num.denominator)
1154 printf("UCGETNUMBER: 0xff19 = %d/%d\n", num.numerator, num.denominator);
1155 else
1156 printf("UCGETNUMBER: 0xff19 = %d\n", num.numerator);
1157
1158 ucdata_cleanup();
1159 exit(0);
1160 }
1161
1162 #endif /* TEST */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial