![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_encodings.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / hfs|
Return to hfs_encodings.c CVS log | Up to [Apple XNU] / XNU / bsd / hfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 2000 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: #include <sys/param.h>
26: #include <sys/systm.h>
27: #include <sys/kernel.h>
28: #include <sys/lock.h>
29: #include <sys/malloc.h>
30: #include <sys/queue.h>
31:
32: #include "hfs.h"
33:
34:
35: /* hfs encoding converter list */
36: SLIST_HEAD(encodinglst, hfs_encoding) hfs_encoding_list = {0};
37: decl_simple_lock_data(,hfs_encoding_list_slock);
38:
39:
40: /* hfs encoding converter entry */
41: struct hfs_encoding {
42: SLIST_ENTRY(hfs_encoding) link;
43: int refcount;
44: int kmod_id;
45: UInt32 encoding;
46: hfs_to_unicode_func_t get_unicode_func;
47: unicode_to_hfs_func_t get_hfsname_func;
48: };
49:
50: /* XXX We should use an "official" interface! */
51: extern kern_return_t kmod_destroy(host_t host, kmod_t id);
52: extern struct host realhost;
53:
54: #define MAX_HFS_UNICODE_CHARS (15*5)
55:
56: static int mac_roman_to_unicode(Str31 hfs_str, UniChar *uni_str, UInt32 maxCharLen, UInt32 *usedCharLen);
57:
58: static int unicode_to_mac_roman(UniChar *uni_str, UInt32 unicodeChars, Str31 hfs_str);
59:
60:
61: void
62: hfs_converterinit(void)
63: {
64: SLIST_INIT(&hfs_encoding_list);
65: simple_lock_init(&hfs_encoding_list_slock);
66:
67: /*
68: * add resident MacRoman converter and take a reference
69: * since its always "loaded".
70: */
71: hfs_addconverter(0, kTextEncodingMacRoman, mac_roman_to_unicode, unicode_to_mac_roman);
72: SLIST_FIRST(&hfs_encoding_list)->refcount++;
73: }
74:
75:
76: /*
77: * hfs_addconverter - add an HFS encoding converter
78: *
79: * This is called exclusivly by kernel loadable modules
80: * (like HFS_Japanese.kmod) to register hfs encoding
81: * conversion routines.
82: *
83: */
84: int
85: hfs_addconverter(int id, UInt32 encoding, hfs_to_unicode_func_t get_unicode, unicode_to_hfs_func_t get_hfsname)
86: {
87: struct hfs_encoding *encp;
88:
89: MALLOC(encp, struct hfs_encoding *, sizeof(struct hfs_encoding), M_TEMP, M_WAITOK);
90:
91: simple_lock(&hfs_encoding_list_slock);
92:
93: encp->link.sle_next = NULL;
94: encp->refcount = 0;
95: encp->encoding = encoding;
96: encp->get_unicode_func = get_unicode;
97: encp->get_hfsname_func = get_hfsname;
98: encp->kmod_id = id;
99: SLIST_INSERT_HEAD(&hfs_encoding_list, encp, link);
100:
101: simple_unlock(&hfs_encoding_list_slock);
102: return (0);
103: }
104:
105:
106: /*
107: * hfs_remconverter - remove an HFS encoding converter
108: *
109: * Can be called by a kernel loadable module's finalize
110: * routine to remove an encoding converter so that the
111: * module (i.e. the code) can be unloaded.
112: *
113: * However, in the normal case, the removing and unloading
114: * of these converters is done in hfs_relconverter.
115: * The call is initiated from within the kernel during the unmounting of an hfs voulume.
116: */
117: int
118: hfs_remconverter(int id, UInt32 encoding)
119: {
120: struct hfs_encoding *encp;
121: int busy = 0;
122:
123: simple_lock(&hfs_encoding_list_slock);
124: SLIST_FOREACH(encp, &hfs_encoding_list, link) {
125: if (encp->encoding == encoding && encp->kmod_id == id) {
126: encp->refcount--;
127:
128: /* if converter is no longer in use, release it */
129: if (encp->refcount <= 0 && encp->kmod_id != 0) {
130: SLIST_REMOVE(&hfs_encoding_list, encp, hfs_encoding, link);
131: FREE(encp, M_TEMP);
132: } else {
133: busy = 1;
134: }
135: break;
136: }
137: }
138: simple_unlock(&hfs_encoding_list_slock);
139:
140: return (busy);
141: }
142:
143:
144: /*
145: * hfs_getconverter - get HFS encoding converters
146: *
147: * Normally called during the mounting of an hfs voulume.
148: */
149: int
150: hfs_getconverter(UInt32 encoding, hfs_to_unicode_func_t *get_unicode, unicode_to_hfs_func_t *get_hfsname)
151: {
152: struct hfs_encoding *encp;
153: int found = 0;
154:
155: simple_lock(&hfs_encoding_list_slock);
156: SLIST_FOREACH(encp, &hfs_encoding_list, link) {
157: if (encp->encoding == encoding) {
158: found = 1;
159: *get_unicode = encp->get_unicode_func;
160: *get_hfsname = encp->get_hfsname_func;
161: ++encp->refcount;
162: break;
163: }
164: }
165: simple_unlock(&hfs_encoding_list_slock);
166:
167: if (!found) {
168: *get_unicode = NULL;
169: *get_hfsname = NULL;
170: return (EINVAL);
171: }
172:
173: return (0);
174: }
175:
176:
177: /*
178: * hfs_relconverter - release interest in an HFS encoding converter
179: *
180: * Normally called during the unmounting of an hfs voulume.
181: */
182: int
183: hfs_relconverter(UInt32 encoding)
184: {
185: struct hfs_encoding *encp;
186: int found = 0;
187:
188: simple_lock(&hfs_encoding_list_slock);
189: SLIST_FOREACH(encp, &hfs_encoding_list, link) {
190: if (encp->encoding == encoding) {
191: found = 1;
192: encp->refcount--;
193:
194: /* if converter is no longer in use, release it */
195: if (encp->refcount <= 0 && encp->kmod_id != 0) {
196: int id = encp->kmod_id;
197:
198: SLIST_REMOVE(&hfs_encoding_list, encp, hfs_encoding, link);
199: FREE(encp, M_TEMP);
200: encp = NULL;
201:
202: simple_unlock(&hfs_encoding_list_slock);
203: kmod_destroy(&realhost, id);
204: simple_lock(&hfs_encoding_list_slock);
205: }
206: break;
207: }
208: }
209: simple_unlock(&hfs_encoding_list_slock);
210:
211: return (found ? 0 : EINVAL);
212: }
213:
214:
215: /*
216: * Convert HFS encoded string into UTF-8
217: *
218: * Unicode output is fully decomposed
219: * '/' chars are converted to ':'
220: */
221: int
222: hfs_to_utf8(ExtendedVCB *vcb, Str31 hfs_str, ByteCount maxDstLen, ByteCount *actualDstLen, unsigned char* dstStr)
223: {
224: int error;
225: UniChar uniStr[MAX_HFS_UNICODE_CHARS];
226: ItemCount uniCount;
227: hfs_to_unicode_func_t hfs_get_unicode = VCBTOHFS(vcb)->hfs_get_unicode;
228:
229: error = hfs_get_unicode(hfs_str, uniStr, MAX_HFS_UNICODE_CHARS, &uniCount);
230:
231: if (error == 0)
232: error = ConvertUnicodeToUTF8(uniCount * sizeof(UniChar), uniStr, maxDstLen, actualDstLen, dstStr);
233:
234: return error;
235: }
236:
237:
238: /*
239: * Convert UTF-8 string into HFS encoding
240: *
241: * ':' chars are converted to '/'
242: * Assumes input represents fully decomposed Unicode
243: */
244: int
245: utf8_to_hfs(ExtendedVCB *vcb, ByteCount srcLen, const unsigned char* srcStr, Str31 dstStr)
246: {
247: int error;
248: UniChar uniStr[MAX_HFS_UNICODE_CHARS];
249: ItemCount uniCount;
250: unicode_to_hfs_func_t hfs_get_hfsname = VCBTOHFS(vcb)->hfs_get_hfsname;
251:
252: error = ConvertUTF8ToUnicode(srcLen, srcStr, sizeof(uniStr), &uniCount, uniStr);
253: if (error == 0)
254: error = hfs_get_hfsname(uniStr, uniCount/sizeof(UniChar), dstStr);
255:
256: return error;
257: }
258:
259:
260:
261: /*
262: * HFS MacRoman to/from Unicode conversions are built into the kernel
263: * All others hfs encodings are loadable.
264: */
265:
266: /* 0x00A0 - 0x00FF = Latin 1 Supplement (30 total) */
267: static UInt8 gLatin1Table[] = {
268: /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
269: /* 0x00A0 */ 0xCA, 0xC1, 0xA2, 0xA3, 0xDB, 0xB4, '?', 0xA4, 0xAC, 0xA9, 0xBB, 0xC7, 0xC2, '?', 0xA8, 0xF8,
270: /* 0x00B0 */ 0xA1, 0XB1, '?', '?', 0xAB, 0xB5, 0xA6, 0xe1, 0xFC, '?', 0xBC, 0xC8, '?', '?', '?', 0xC0,
271: /* 0x00C0 */ '?', '?', '?', '?', '?', '?', 0xAE, '?', '?', '?', '?', '?', '?', '?', '?', '?',
272: /* 0x00D0 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xAF, '?', '?', '?', '?', '?', '?', 0xA7,
273: /* 0x00E0 */ '?', '?', '?', '?', '?', '?', 0xBE, '?', '?', '?', '?', '?', '?', '?', '?', '?',
274: /* 0x00F0 */ '?', '?', '?', '?', '?', '?', '?', 0xD6, 0xBF, '?', '?', '?', '?', '?', '?', '?'
275: };
276:
277: /* 0x02C0 - 0x02DF = Spacing Modifiers (8 total) */
278: static UInt8 gSpaceModsTable[] = {
279: /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
280: /* 0x02C0 */ '?', '?', '?', '?', '?', '?', 0xF6, 0xFF, '?', '?', '?', '?', '?', '?', '?', '?',
281: /* 0x02D0 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xF9, 0xFA, 0xFB, 0xFE, 0xF7, 0xFD, '?', '?'
282: };
283:
284: /* 0x2010 - 0x20AF = General Punctuation (17 total) */
285: static UInt8 gPunctTable[] = {
286: /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
287: /* 0x2010 */ '?', '?', '?', 0xd0, 0xd1, '?', '?', '?', 0xd4, 0xd5, 0xe2, '?', 0xd2, 0xd3, 0xe3, '?',
288: /* 0x2020 */ 0xa0, 0xe0, 0xa5, '?', '?', '?', 0xc9, '?', '?', '?', '?', '?', '?', '?', '?', '?',
289: /* 0x2030 */ 0xe4, '?', '?', '?', '?', '?', '?', '?', '?', 0xdc, 0xdd, '?', '?', '?', '?', '?',
290: /* 0x2040 */ '?', '?', '?', '?', 0xda, '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
291: /* 0x2050 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
292: /* 0x2060 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
293: /* 0x2070 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
294: /* 0x2080 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
295: /* 0x2090 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
296: /* 0x20A0 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', 0xdb, '?', '?', '?'
297: };
298:
299: /* 0x22xx = Mathematical Operators (11 total) */
300: static UInt8 gMathTable[] = {
301: /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
302: /* 0x2200 */ '?', '?', 0xb6, '?', '?', '?', 0xc6, '?', '?', '?', '?', '?', '?', '?', '?', 0xb8,
303: /* 0x2210 */ '?', 0xb7, '?', '?', '?', '?', '?', '?', '?', '?', 0xc3, '?', '?', '?', 0xb0, '?',
304: /* 0x2220 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', 0xba, '?', '?', '?', '?',
305: /* 0x2230 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
306: /* 0x2240 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xc5, '?', '?', '?', '?', '?', '?', '?',
307: /* 0x2250 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
308: /* 0x2260 */ 0xad, '?', '?', '?', 0xb2, 0xb3, '?', '?'
309: };
310:
311: /* */
312: static UInt8 gReverseCombTable[] = {
313: /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
314: /* 0x40 */ 0xDA, 0x40, 0xDA, 0xDA, 0xDA, 0x56, 0xDA, 0xDA, 0xDA, 0x6C, 0xDA, 0xDA, 0xDA, 0xDA, 0x82, 0x98,
315: /* 0x50 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xAE, 0xDA, 0xDA, 0xDA, 0xC4, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
316: /* 0x60 */ 0xDA, 0x4B, 0xDA, 0xDA, 0xDA, 0x61, 0xDA, 0xDA, 0xDA, 0x77, 0xDA, 0xDA, 0xDA, 0xDA, 0x8D, 0xA3,
317: /* 0x70 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xB9, 0xDA, 0xDA, 0xDA, 0xCF, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
318:
319: /* Combining Diacritical Marks (0x0300 - 0x030A) */
320: /* 0 1 2 3 4 5 6 7 8 9 A */
321: /* 'A' */
322: /* 0x0300 */ 0xCB, 0xE7, 0xE5, 0xCC, '?', '?', '?', '?', 0x80, '?', 0x81,
323:
324: /* 'a' */
325: /* 0x0300 */ 0x88, 0x87, 0x89, 0x8B, '?', '?', '?', '?', 0x8A, '?', 0x8C,
326:
327: /* 'E' */
328: /* 0x0300 */ 0xE9, 0x83, 0xE6, '?', '?', '?', '?', '?', 0xE8, '?', '?',
329:
330: /* 'e' */
331: /* 0x0300 */ 0x8F, 0x8E, 0x90, '?', '?', '?', '?', '?', 0x91, '?', '?',
332:
333: /* 'I' */
334: /* 0x0300 */ 0xED, 0xEA, 0xEB, '?', '?', '?', '?', '?', 0xEC, '?', '?',
335:
336: /* 'i' */
337: /* 0x0300 */ 0x93, 0x92, 0x94, '?', '?', '?', '?', '?', 0x95, '?', '?',
338:
339: /* 'N' */
340: /* 0x0300 */ '?', '?', '?', 0x84, '?', '?', '?', '?', '?', '?', '?',
341:
342: /* 'n' */
343: /* 0x0300 */ '?', '?', '?', 0x96, '?', '?', '?', '?', '?', '?', '?',
344:
345: /* 'O' */
346: /* 0x0300 */ 0xF1, 0xEE, 0xEF, 0xCD, '?', '?', '?', '?', 0x85, '?', '?',
347:
348: /* 'o' */
349: /* 0x0300 */ 0x98, 0x97, 0x99, 0x9B, '?', '?', '?', '?', 0x9A, '?', '?',
350:
351: /* 'U' */
352: /* 0x0300 */ 0xF4, 0xF2, 0xF3, '?', '?', '?', '?', '?', 0x86, '?', '?',
353:
354: /* 'u' */
355: /* 0x0300 */ 0x9D, 0x9C, 0x9E, '?', '?', '?', '?', '?', 0x9F, '?', '?',
356:
357: /* 'Y' */
358: /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xD9, '?', '?',
359:
360: /* 'y' */
361: /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xD8, '?', '?',
362:
363: /* else */
364: /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?'
365: };
366:
367:
368: /*
369: * Convert Unicode string into HFS MacRoman encoding
370: *
371: * Assumes Unicode input is fully decomposed
372: */
373: static int unicode_to_mac_roman(UniChar *uni_str, UInt32 unicodeChars, Str31 hfs_str)
374: {
375: UInt8 *p;
376: const UniChar *u;
377: UniChar c;
378: UniChar mask;
379: UInt16 inputChars;
380: UInt16 pascalChars;
381: OSErr result = noErr;
382: UInt8 lsb;
383: UInt8 prevChar;
384: UInt8 mc;
385:
386: mask = (UniChar) 0xFF80;
387: p = &hfs_str[1];
388: u = uni_str;
389: inputChars = unicodeChars;
390: pascalChars = prevChar = 0;
391:
392: while (inputChars) {
393: c = *(u++);
394: lsb = (UInt8) c;
395:
396: /*
397: * If its not 7-bit ascii, then we need to map it
398: */
399: if ( c & mask ) {
400: mc = '?';
401: switch (c & 0xFF00) {
402: case 0x0000:
403: if (lsb >= 0xA0)
404: mc = gLatin1Table[lsb - 0xA0];
405: break;
406:
407: case 0x0200:
408: if (lsb >= 0xC0 && lsb <= 0xDF)
409: mc = gSpaceModsTable[lsb - 0xC0];
410: break;
411:
412: case 0x2000:
413: if (lsb >= 0x10 && lsb <= 0xAF)
414: mc = gPunctTable[lsb- 0x10];
415: break;
416:
417: case 0x2200:
418: if (lsb <= 0x68)
419: mc = gMathTable[lsb];
420: break;
421:
422: case 0x0300:
423: if (c <= 0x030A) {
424: if (prevChar >= 'A' && prevChar < 'z') {
425: mc = gReverseCombTable[gReverseCombTable[prevChar - 0x40] + lsb];
426: --p; /* backup over base char */
427: --pascalChars;
428: }
429: } else {
430: switch (c) {
431: case 0x0327: /* combining cedilla */
432: if (prevChar == 'C')
433: mc = 0x82;
434: else if (prevChar == 'c')
435: mc = 0x8D;
436: else
437: break;
438: --p; /* backup over base char */
439: --pascalChars;
440: break;
441:
442: case 0x03A9: mc = 0xBD; break; /* omega */
443:
444: case 0x03C0: mc = 0xB9; break; /* pi */
445: }
446: }
447: break;
448:
449: default:
450: switch (c) {
451: case 0x0131: mc = 0xf5; break; /* dotless i */
452:
453: case 0x0152: mc = 0xce; break; /* OE */
454:
455: case 0x0153: mc = 0xcf; break; /* oe */
456:
457: case 0x0192: mc = 0xc4; break; /* � */
458:
459: case 0x2122: mc = 0xaa; break; /* TM */
460:
461: case 0x25ca: mc = 0xd7; break; /* diamond */
462:
463: case 0xf8ff: mc = 0xf0; break; /* apple logo */
464:
465: case 0xfb01: mc = 0xde; break; /* fi */
466:
467: case 0xfb02: mc = 0xdf; break; /* fl */
468: }
469: } /* end switch (c & 0xFF00) */
470:
471: /*
472: * If we have an unmapped character then we need to mangle the name...
473: */
474: if (mc == '?')
475: result = kTECUsedFallbacksStatus;
476:
477: prevChar = 0;
478: lsb = mc;
479:
480: } else {
481: prevChar = lsb;
482: }
483:
484: if (pascalChars >= 31)
485: break;
486:
487: *(p++) = lsb;
488: ++pascalChars;
489: --inputChars;
490:
491: } /* end while */
492:
493: hfs_str[0] = pascalChars;
494:
495: if (inputChars > 0)
496: result = kTECOutputBufferFullStatus; /* ran out of room! */
497:
498: return result;
499: }
500:
501:
502: static UniChar gHiBitBaseUnicode[128] = {
503: /* 0x80 */ 0x0041, 0x0041, 0x0043, 0x0045, 0x004e, 0x004f, 0x0055, 0x0061,
504: /* 0x88 */ 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0063, 0x0065, 0x0065,
505: /* 0x90 */ 0x0065, 0x0065, 0x0069, 0x0069, 0x0069, 0x0069, 0x006e, 0x006f,
506: /* 0x98 */ 0x006f, 0x006f, 0x006f, 0x006f, 0x0075, 0x0075, 0x0075, 0x0075,
507: /* 0xa0 */ 0x2020, 0x00b0, 0x00a2, 0x00a3, 0x00a7, 0x2022, 0x00b6, 0x00df,
508: /* 0xa8 */ 0x00ae, 0x00a9, 0x2122, 0x00b4, 0x00a8, 0x2260, 0x00c6, 0x00d8,
509: /* 0xb0 */ 0x221e, 0x00b1, 0x2264, 0x2265, 0x00a5, 0x00b5, 0x2202, 0x2211,
510: /* 0xb8 */ 0x220f, 0x03c0, 0x222b, 0x00aa, 0x00ba, 0x03a9, 0x00e6, 0x00f8,
511: /* 0xc0 */ 0x00bf, 0x00a1, 0x00ac, 0x221a, 0x0192, 0x2248, 0x2206, 0x00ab,
512: /* 0xc8 */ 0x00bb, 0x2026, 0x00a0, 0x0041, 0x0041, 0x004f, 0x0152, 0x0153,
513: /* 0xd0 */ 0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0x00f7, 0x25ca,
514: /* 0xd8 */ 0x0079, 0x0059, 0x2044, 0x20ac, 0x2039, 0x203a, 0xfb01, 0xfb02,
515: /* 0xe0 */ 0x2021, 0x00b7, 0x201a, 0x201e, 0x2030, 0x0041, 0x0045, 0x0041,
516: /* 0xe8 */ 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049, 0x004f, 0x004f,
517: /* 0xf0 */ 0xf8ff, 0x004f, 0x0055, 0x0055, 0x0055, 0x0131, 0x02c6, 0x02dc,
518: /* 0xf8 */ 0x00af, 0x02d8, 0x02d9, 0x02da, 0x00b8, 0x02dd, 0x02db, 0x02c7
519: };
520:
521: static UniChar gHiBitCombUnicode[128] = {
522: /* 0x80 */ 0x0308, 0x030a, 0x0327, 0x0301, 0x0303, 0x0308, 0x0308, 0x0301,
523: /* 0x88 */ 0x0300, 0x0302, 0x0308, 0x0303, 0x030a, 0x0327, 0x0301, 0x0300,
524: /* 0x90 */ 0x0302, 0x0308, 0x0301, 0x0300, 0x0302, 0x0308, 0x0303, 0x0301,
525: /* 0x98 */ 0x0300, 0x0302, 0x0308, 0x0303, 0x0301, 0x0300, 0x0302, 0x0308,
526: /* 0xa0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
527: /* 0xa8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
528: /* 0xb0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
529: /* 0xb8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
530: /* 0xc0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
531: /* 0xc8 */ 0x0000, 0x0000, 0x0000, 0x0300, 0x0303, 0x0303, 0x0000, 0x0000,
532: /* 0xd0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
533: /* 0xd8 */ 0x0308, 0x0308, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
534: /* 0xe0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0302, 0x0302, 0x0301,
535: /* 0xe8 */ 0x0308, 0x0300, 0x0301, 0x0302, 0x0308, 0x0300, 0x0301, 0x0302,
536: /* 0xf0 */ 0x0000, 0x0300, 0x0301, 0x0302, 0x0300, 0x0000, 0x0000, 0x0000,
537: /* 0xf8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
538: };
539:
540:
541: /*
542: * Convert HFS MacRoman encoded string into Unicode
543: *
544: * Unicode output is fully decomposed
545: */
546: static int mac_roman_to_unicode(Str31 hfs_str, UniChar *uni_str,
547: UInt32 maxCharLen, UInt32 *unicodeChars)
548: {
549: const UInt8 *p;
550: UniChar *u;
551: UInt16 pascalChars;
552: UInt8 c;
553:
554: p = hfs_str;
555: u = uni_str;
556:
557: *unicodeChars = pascalChars = *(p++); /* pick up length byte */
558:
559: while (pascalChars--) {
560: c = *(p++);
561:
562: if ( (SInt8) c >= 0 ) { /* check if seven bit ascii */
563: *(u++) = (UniChar) c; /* just pad high byte with zero */
564: } else { /* its a hi bit character */
565: UniChar uc;
566:
567: c &= 0x7F;
568: *(u++) = uc = gHiBitBaseUnicode[c];
569:
570: /*
571: * if the unicode character we get back is an alpha char
572: * then we must have an additional combining character
573: */
574: if ((uc <= (UniChar) 'z') && (uc >= (UniChar) 'A')) {
575: *(u++) = gHiBitCombUnicode[c];
576: ++(*unicodeChars);
577: }
578: }
579: }
580:
581: return noErr;
582: }
583:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.