![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to UnicodeWrappers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Unicode|
Return to UnicodeWrappers.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Unicode |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 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.1 (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: /*
26: File: UnicodeWrappers.c
27:
28: Contains: Wrapper routines for Unicode conversion and comparison.
29:
30: Version: HFS Plus 1.0
31:
32: Written by: Mark Day
33:
34: Copyright: � 1996-1999 by Apple Computer, Inc., all rights reserved.
35:
36: File Ownership:
37:
38: DRI: Mark Day
39:
40: Other Contact: Don Brady
41:
42: Technology: xxx put technology here xxx
43:
44: Writers:
45:
46: (DSH) Deric Horn
47: (msd) Mark Day
48: (djb) Don Brady
49:
50: Change History (most recent first):
51: <Rhap> 2/09/99 djb Fix UnicodeToMacRoman to handle a terminating decomposed char.
52: <Rhap> 1/22/99 djb Add more TARGET_OS_MAC conditionals to remove orphaned code.
53: <Rhap> 7/6/98 djb Handle hi-bit Mac Roman characters in basic latin conversions (radar #2247519).
54: <Rhap> 6/11/98 PPD Added a few special-case ASCII/Unicode mappings to cover installer's needs.
55: <Rhap> 3/31/98 djb Sync up with final HFSVolumes.h header file.
56:
57: <CS41> 1/28/98 msd Bug 2207446: When mangling a name, check to see if the Unicode
58: Converter is installed before we call it.
59: <CS40> 1/21/98 msd Bug 2206836: If a name contains a colon, change it to question
60: mark and mangle the name.
61: <CS39> 12/11/97 msd For Metrowerks and test tools, call the Get_xxx routines to get
62: the Unicode table addresses.
63: <CS38> 12/10/97 djb Radar #2005461, don't use fallback chars when converting to
64: Unicode, instead let the client (Catalog) retry with MacRoman.
65: <CS37> 12/2/97 DSH Conditionalize out some unicode related routines for DFA
66: <CS36> 11/26/97 djb Radar #2005461,2005688 don't swallow kTECPartialCharErr errors!
67: <CS35> 11/17/97 djb Name mangling was broken with decomposed Unicode.
68: <CS34> 11/16/97 djb Radar #2001928 - use kUnicodeCanonicalDecompVariant variant.
69: <CS33> 11/11/97 DSH Use Get_gLowerCaseTable for DiskFirstAid builds to avoid loading
70: in a branch to the table.
71: <CS32> 11/7/97 msd Replace FastSimpleCompareStrings with FastUnicodeCompare (which
72: handles ignorable Unicode characters). Remove the wrapper
73: routine, CompareUnicodeNames, and have its callers call
74: FastUnicodeCompare directly.
75: <CS31> 10/17/97 djb Change kUnicodeUseHFSPlusMapping to kUnicodeUseLatestMapping.
76: <CS30> 10/17/97 msd Fix some type casts for char pointers.
77: <CS29> 10/13/97 djb Add new SPIs for Finder View font (radar #1679073).
78: <CS28> 10/1/97 djb Preserve current heap zone in InitializeEncodingContext routine
79: (radar #1682686).
80: <CS27> 9/17/97 djb Handle kTECPartialCharErr errors in ConvertHFSNameToUnicode.
81: <CS26> 9/16/97 msd In MockConvertFromPStringToUnicode, use pragma unused instead of
82: commenting out unused parameter (so SC will compile it).
83: <CS25> 9/15/97 djb Fix MockConverters to do either 7-bit ascii or else mangle the
84: name (radar #1672388). Use 'p2u#' resource for bootstrapping
85: Unicode. Make sure InitializeEncodingContext uses System heap.
86: <CS24> 9/10/97 msd Make InitializeEncodingContext public.
87: <CS23> 9/7/97 djb Handle '�' char in BasicLatinUnicode converter.
88: <CS22> 9/4/97 djb Add logging to BasicLatinUnicodeToPascal.
89: <CS21> 8/26/97 djb Make FastSimpleCompareStrings faster. Add
90: BasicLatinUnicodeToPascal to make 7-bit ascii conversions
91: faster.
92: <CS20> 8/14/97 djb Add FastRelString here (to be next to the data tables).
93: <CS19> 7/21/97 djb LogEndTime now takes an error code.
94: <CS18> 7/18/97 msd Include LowMemPriv.h, Gestalt.h, TextUtils.h.
95: <CS17> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name
96: collision
97: <CS16> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line
98: <CS15> 7/8/97 DSH InitializeUnicode changed its API
99: <CS14> 7/1/97 DSH SC, DFA complier, requires parameters in functions. #pragma'd
100: them out to eliminate C warnings.
101: <CS13> 6/30/97 msd Remove unused parameter warnings in FallbackProc by commenting
102: out unused parameter names.
103: <CS12> 6/26/97 DSH FallbackProc declare variables before useage for SC,
104: MockConverters no longer static for DFA.
105: <CS11> 6/25/97 msd In function InitStaticUnicodeConverter, the variable fsVars was
106: being used before being initialized.
107: <CS10> 6/24/97 DSH Runtime checks to call through CFM or static linked routines.
108: <CS9> 6/20/97 msd Re-introduce fix from <CS7>. Fix another missing cast. Remove a
109: spurious semicolon.
110: <CS8> 6/18/97 djb Add more ConversionContexts routines. Improved file mangling.
111: <CS7> 6/16/97 msd Add a missing cast in GetFileIDString.
112: <CS6> 6/13/97 djb Added support for long filenames. Switched to
113: ConvertUnicodeToHFSName, ConvertHFSNameToUnicode, and
114: CompareUnicodeNames.
115: <CS5> 6/4/97 djb Use system script instead of macRoman.
116: <CS4> 5/19/97 djb Add call to LockMappingTable so tables won't move!
117: <CS3> 5/9/97 djb Include HFSInstrumentation.h
118: <CS2> 5/7/97 djb Add summary traces. Add FastSimpleCompareStrings routine.
119: <CS1> 4/24/97 djb first checked in
120: <HFS5> 3/27/97 djb Add calls to real Unicode conversion routines.
121: <HFS4> 2/6/97 msd Add conditional code to use real Unicode comparison routines
122: (default to off).
123: <HFS3> 1/6/97 djb Fix HFSUnicodeCompare - the final comparison of length1 and
124: length2 was backwards.
125: <HFS2> 12/12/96 msd Use precompiled headers.
126: <HFS1> 12/12/96 msd first checked in
127:
128: */
129:
130: #if ( PRAGMA_LOAD_SUPPORTED )
131: #pragma load PrecompiledHeaders
132: #else
133: #if TARGET_OS_MAC
134: #include <CodeFragments.h>
135: #include <Errors.h>
136: #include <MixedModePriv.h>
137: #include <Script.h>
138: #include <UnicodeConverter.h>
139: #include <LowMemPriv.h>
140: #include <Gestalt.h>
141: #include <TextUtils.h>
142: #else
143: #include "../headers/system/MacOSStubs.h"
144: #endif /* TARGET_OS_MAC */
145: #endif /* PRAGMA_LOAD_SUPPORTED */
146:
147: #if TARGET_OS_MAC
148: #include <IntlResources.h>
149: #include <TextCommonPriv.h>
150: #include <UnicodeConverterPriv.h>
151: #include <FileMgrResources.h>
152: #endif /* TARGET_OS_MAC */
153:
154: #if TARGET_OS_RHAPSODY
155: #include "UCStringCompareData.h"
156: #endif /* TARGET_OS_RHAPSODY */
157:
158: #include "../headers/FileMgrInternal.h"
159: #include "../headers/system/HFSUnicodeWrappers.h"
160: #include "../headers/system/HFSInstrumentation.h"
161:
162: #include "ConvertUTF.h"
163:
164: #ifdef __MWERKS__
165: #define USE_TABLE_ACCESSORS 1
166: #endif
167:
168: #ifndef USE_TABLE_ACCESSORS
169: #define USE_TABLE_ACCESSORS 0
170: #endif
171:
172:
173: #if TARGET_OS_MAC
174: enum {
175: uupCreateTextToUnicodeInfoProcInfo =
176: kPascalStackBased
177: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
178: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ConstUnicodeMappingPtr)))
179: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(TextToUnicodeInfo*))),
180:
181:
182: uppCreateUnicodeToTextInfoProcInfo =
183: kPascalStackBased
184: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
185: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ConstUnicodeMappingPtr)))
186: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(UnicodeToTextInfo*))),
187:
188:
189: uppConvertFromTextToUnicodeProcInfo =
190: kPascalStackBased
191: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
192: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(TextToUnicodeInfo)))
193: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ByteCount)))
194: | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ConstLogicalAddress)))
195: | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(OptionBits)))
196: | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(ItemCount)))
197: | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(ByteOffset*)))
198: | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(ItemCount*)))
199: | STACK_ROUTINE_PARAMETER(8, SIZE_CODE(sizeof(ByteOffset*)))
200: | STACK_ROUTINE_PARAMETER(9, SIZE_CODE(sizeof(ByteCount)))
201: | STACK_ROUTINE_PARAMETER(10, SIZE_CODE(sizeof(ByteCount*)))
202: | STACK_ROUTINE_PARAMETER(11, SIZE_CODE(sizeof(ByteCount*)))
203: | STACK_ROUTINE_PARAMETER(12, SIZE_CODE(sizeof(UniCharArrayPtr))),
204:
205:
206: uppConvertFromUnicodeToTextProcInfo =
207: kPascalStackBased
208: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
209: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UnicodeToTextInfo)))
210: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ByteCount)))
211: | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ConstUniCharArrayPtr)))
212: | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(OptionBits)))
213: | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(ItemCount)))
214: | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(ByteOffset*)))
215: | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(ItemCount*)))
216: | STACK_ROUTINE_PARAMETER(8, SIZE_CODE(sizeof(ByteOffset*)))
217: | STACK_ROUTINE_PARAMETER(9, SIZE_CODE(sizeof(ByteCount)))
218: | STACK_ROUTINE_PARAMETER(10, SIZE_CODE(sizeof(ByteCount*)))
219: | STACK_ROUTINE_PARAMETER(11, SIZE_CODE(sizeof(ByteCount*)))
220: | STACK_ROUTINE_PARAMETER(12, SIZE_CODE(sizeof(LogicalAddress))),
221:
222:
223: uppUpgradeScriptInfoToTextEncodingProcInfo =
224: kPascalStackBased
225: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
226: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ScriptCode)))
227: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(LangCode)))
228: | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(RegionCode)))
229: | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ConstStr255Param)))
230: | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(TextEncoding*))),
231:
232:
233: uppRevertTextEncodingToScriptInfoProcInfo =
234: kPascalStackBased
235: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
236: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(TextEncoding)))
237: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ScriptCode*)))
238: | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(LangCode*)))
239: | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(StringPtr))),
240:
241:
242: // NOTE: this one uses "C" calling conventions...
243: uppLockMappingTableProcInfo =
244: kCStackBased
245: | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
246: | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UnicodeMapping*)))
247: | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Boolean)))
248: };
249: #endif /* TARGET_OS_MAC */
250:
251:
252: enum {
253: smLargestScript = 32,
254:
255: kMinFileExtensionChars = 1, // does not include dot
256: kMaxFileExtensionChars = 5 // does not include dot
257: };
258:
259: #define kASCIIPiSymbol 0xB9
260: #define kASCIIMicroSign 0xB5
261: #define kASCIIGreekDelta 0xC6
262:
263:
264: #define Is7BitASCII(c) ( (c) >= 0x20 && (c) <= 0x7F )
265:
266: #define IsSpecialASCIIChar(c) ( (c) == (UInt8) kASCIIMicroSign || (c) == (UInt8) kASCIIPiSymbol || (c) == (UInt8) kASCIIGreekDelta )
267:
268: // Note: '�' has two Unicode representations 0x00B5 (micro sign) and 0x03BC (greek)
269: // '�' has two Unicode representations 0x2206 (increment) and 0x0394 (greek)
270: #define IsSpecialUnicodeChar(c) ( (c) == 0x00B5 || (c) == 0x03BC || (c) == 0x03C0 || (c) == 0x2206 || (c) == 0x0394 )
271:
272: #define IsHexDigit(c) ( ((c) >= (UInt8) '0' && (c) <= (UInt8) '9') || ((c) >= (UInt8) 'A' && (c) <= (UInt8) 'F') )
273:
274: //
275: // PToUTable and PToUEntry describe the 'p2u#' resource
276: // This resource is used to map pascal to Unicode before
277: // the real Unicode converter is initialize.
278: //
279: struct PToUEntry {
280: Str31 pascalString; // pascal representation
281: UInt16 unicodeChars; // unicode char count
282: UniChar unicodeString[63]; // unicode representation
283: };
284: typedef struct PToUEntry PToUEntry;
285:
286:
287: struct PToUTable {
288: UInt16 entries; // number of entries
289: PToUEntry entry[1];
290: };
291: typedef struct PToUTable PToUTable;
292:
293:
294: extern UniChar * Get_gLowerCaseTable(void);
295:
296: // Unicode Glue routines
297: // WARNING: These Glue APIs must match the APIs in UnicodeConverter.h (the glue assumes they are the same)
298: // for example CreateTextToUnicodeInfo_Glue and CreateTextToUnicodeInfo must have identical parameters and calling conventions
299:
300: extern pascal OSStatus CreateTextToUnicodeInfo_Glue(ConstUnicodeMappingPtr iUnicodeMapping, TextToUnicodeInfo *oTextToUnicodeInfo);
301: extern pascal OSStatus CreateUnicodeToTextInfo_Glue(ConstUnicodeMappingPtr iUnicodeMapping, UnicodeToTextInfo *oUnicodeToTextInfo);
302: extern pascal OSStatus ConvertFromTextToUnicode_Glue(TextToUnicodeInfo iTextToUnicodeInfo, ByteCount iSourceLen, ConstLogicalAddress iSourceStr, OptionBits iControlFlags, ItemCount iOffsetCount, ByteOffset iOffsetArray[], ItemCount *oOffsetCount, ByteOffset oOffsetArray[], ByteCount iBufLen, ByteCount *oSourceRead, ByteCount *oUnicodeLen, UniCharArrayPtr oUnicodeStr);
303: extern pascal OSStatus ConvertFromUnicodeToText_Glue(UnicodeToTextInfo iUnicodeToTextInfo, ByteCount iUnicodeLen, ConstUniCharArrayPtr iUnicodeStr, OptionBits iControlFlags, ItemCount iOffsetCount, ByteOffset iOffsetArray[], ItemCount *oOffsetCount, ByteOffset oOffsetArray[], ByteCount iBufLen, ByteCount *oInputRead, ByteCount *oOutputLen, LogicalAddress oOutputStr);
304: extern pascal OSStatus UpgradeScriptInfoToTextEncoding_Glue(ScriptCode textScriptID, LangCode textLanguageID, RegionCode regionID, ConstStr255Param textFontname, TextEncoding *encoding);
305: extern pascal OSStatus RevertTextEncodingToScriptInfo_Glue(TextEncoding encoding, ScriptCode *textScriptID, LangCode *textLanguageID, Str255 textFontname);
306:
307: // EXCEPTION: this one uses "C" calling conventions (why?)
308: extern OSStatus LockMappingTable_Glue(UnicodeMapping *unicodeMappingPtr, Boolean lockIt);
309:
310: #if TARGET_OS_MAC
311: static OSErr InitStaticUnicodeConverter(void);
312: static OSErr InitDynamicUnicodeConverter( Boolean forBootVolume );
313: #endif /* TARGET_OS_MAC */
314:
315:
316: #if TARGET_OS_MAC
317: static OSErr InstallConversionContexts( FSVarsRec *fsVars );
318:
319: static OSErr InstallLibraryVector( CFragConnectionID connectionID, ConstStr255Param symbolName,
320: ProcInfoType procInfo, UniversalProcPtr *vector );
321:
322: static OSErr InstallSystemConversionContext( FSVarsRec *fsVars, Boolean forBootVolume );
323: #endif /* TARGET_OS_MAC */
324:
325: static void GetFilenameExtension( ItemCount length, ConstUniCharArrayPtr unicodeStr, Str15 extStr );
326:
327: static void GetFileIDString( HFSCatalogNodeID fileID, Str15 fileIDStr );
328:
329: static void AppendPascalString( ConstStr15Param src, Str31 dst );
330:
331: static UInt32 HexStringToInteger( UInt32 length, const UInt8 *hexStr );
332:
333:
334: pascal OSStatus FallbackProc( UniChar *srcUniStr, ByteCount srcUniStrLen, ByteCount *srcConvLen,
335: TextPtr destStr, ByteCount destStrLen, ByteCount *destConvLen,
336: LogicalAddress contextPtr, ConstUnicodeMappingPtr unicodeMappingPtr );
337:
338:
339: static OSErr MacRomanToUnicode (ConstStr255Param pascalString, ItemCount *unicodeChars, UniCharArrayPtr unicodeString);
340: static OSErr UnicodeToMacRoman (ItemCount unicodeChars, ConstUniCharArrayPtr unicodeString, Str31 pascalString);
341:
342:
343: /*
344: Get the base encoding used by the File System
345:
346: If no HFS Plus volumes have been mounted yet then
347: the default encoding could be kTextEncodingUndefined
348: */
349: #if TARGET_OS_MAC
350: TextEncoding
351: GetDefaultTextEncoding(void)
352: {
353: FSVarsRec *fsVars;
354:
355: fsVars = (FSVarsRec*) LMGetFSMVars();
356:
357: return fsVars->gDefaultBaseEncoding;
358: }
359: #endif
360:
361:
362: /*
363: Set the base encoding used by the File System
364: */
365: #if TARGET_OS_MAC
366: OSErr
367: SetDefaultTextEncoding(TextEncoding encoding)
368: {
369: FSVarsRec *fsVars;
370: OSErr result;
371:
372:
373: fsVars = (FSVarsRec*) LMGetFSMVars();
374:
375:
376: // undefined only makes sense when Unicode Library is not installed
377: if ( encoding == kTextEncodingUndefined )
378: {
379: if ( fsVars->gIsUnicodeInstalled == false )
380: fsVars->gDefaultBaseEncoding = encoding;
381:
382: return noErr;
383: }
384:
385: encoding = GetTextEncodingBasePriv(encoding);
386:
387: if ( !ValidMacEncoding(encoding) )
388: return paramErr; // we only support Mac encodings!
389:
390: // if Unicode Library is installed then setup context for this encoding
391: // otherwise it will occur when the first HFS Plus volume gets mounted
392: if ( fsVars->gIsUnicodeInstalled )
393: {
394: result = InitializeEncodingContext( encoding, fsVars );
395: if ( result != noErr )
396: return result;
397: }
398:
399: // make it the default...
400: fsVars->gDefaultBaseEncoding = encoding;
401:
402: return noErr;
403: }
404: #endif /* TARGET_OS_MAC */
405:
406: /*
407: Get the encoding that matches font
408: */
409:
410: #if TARGET_OS_MAC
411: OSErr
412: GetTextEncodingForFont( ConstStr255Param fontName, UInt32 * textEncoding )
413: {
414: FSVarsRec * fsVars;
415: OSErr result;
416:
417:
418: fsVars = (FSVarsRec*) LMGetFSMVars();
419:
420: // if Unicode Library is installed then we can get the encoding...
421: if ( fsVars->gIsUnicodeInstalled )
422: {
423: result = UpgradeScriptInfoToTextEncoding_Glue ( kTextScriptDontCare,
424: kTextLanguageDontCare,
425: kTextRegionDontCare,
426: fontName,
427: textEncoding );
428: }
429: else // Unicode Library not installed so save font name for later...
430: {
431: StringPtr savedFontName;
432: UInt16 stringByteSize;
433:
434: stringByteSize = fontName[0] + 1;
435: savedFontName = fsVars->gTextEncodingFontName;
436:
437: // if we already had one then get rid of it
438: if ( savedFontName != NULL )
439: DisposePtr( (Ptr) savedFontName );
440:
441: savedFontName = (StringPtr) NewPtrSys( stringByteSize );
442:
443: if ( savedFontName != NULL )
444: BlockMoveData(fontName, savedFontName, stringByteSize);
445:
446: fsVars->gTextEncodingFontName = savedFontName;
447:
448: *textEncoding = kTextEncodingUndefined;
449: result = noErr;
450: }
451:
452: return result;
453: }
454: #endif /* TARGET_OS_MAC */
455:
456: /*
457: Count the number of encodings installed by the File System
458: */
459: #if TARGET_OS_MAC
460: ItemCount
461: CountInstalledEncodings(void)
462: {
463: FSVarsRec *fsVars;
464:
465: fsVars = (FSVarsRec*) LMGetFSMVars();
466:
467: return fsVars->gInstalledEncodings;
468: }
469: #endif
470:
471: /*
472: Convert a Unicode string to a Pascal string (Str31) for use in an HFS file/folder name.
473: */
474: #if 0
475: OSErr
476: ConvertUnicodeToHFSName( ConstHFSUniStr255Param unicodeName, TextEncoding encoding, HFSCatalogNodeID cnid, Str31 hfsName )
477: {
478: ByteCount unicodeByteLength;
479: ByteCount pascalSizeLimit;
480: OSErr result;
481:
482: hfsName[0] = 0; // in case we get errors, make sure output is valid
483: unicodeByteLength = unicodeName->length * sizeof(UniChar);
484:
485: if ( unicodeByteLength == 0 )
486: return noErr;
487:
488: if ( cnid == kHFSRootFolderID )
489: pascalSizeLimit = kHFSMaxVolumeNameChars; // an HFS volume name
490: else
491: pascalSizeLimit = kHFSMaxFileNameChars; // an HFS file name
492:
493: result = MockConvertFromUnicodeToPString( unicodeByteLength, unicodeName->unicode, hfsName );
494:
495: // Check if name was too long or some characters were unrepresentable...
496: // if so we need to mangle the name so that the file can be found by
497: // name later
498:
499: if ( result == kTECOutputBufferFullStatus || result == kTECUsedFallbacksStatus )
500: {
501: Str15 fileIDStr; // file ID as a pascal string
502: Str15 extStr; // dot extension as a pascal string
503:
504: GetFileIDString(cnid, fileIDStr);
505:
506: // Get a filename extension only if it is a file.
507: if ( pascalSizeLimit == kHFSMaxFileNameChars)
508: GetFilenameExtension(unicodeName->length, unicodeName->unicode, extStr);
509: else
510: extStr[0] = (UInt8) 0; // volumes don't have extensions
511:
512: // calculate free space for filename prefix
513: pascalSizeLimit -= StrLength(extStr) + StrLength(fileIDStr);
514:
515: // Generate the prefix part of the name (before extension or File ID string).
516: // Since the Unicode converter wasn't installed, use the PString we already have,
517: // shortening it if needed.
518: if (hfsName[0] > pascalSizeLimit)
519: hfsName[0] = pascalSizeLimit;
520: else
521: hfsName[0] -= StrLength(extStr); // remove extension chars (if any) from source
522:
523: strcat(hfsName, fileIDStr);
524: strcat(hfsName, extStr);
525:
526: result = noErr;
527: }
528:
529: return result;
530:
531: } // end ConvertUnicodeToHFSName
532: #endif
533:
534: /*
535: Convert a Pascal string (Str31, such as a file/folder name) to Unicode.
536: */
537: #if TARGET_OS_MAC
538: OSErr
539: ConvertHFSNameToUnicode( ConstStr31Param hfsName, TextEncoding encoding, HFSUniStr255 *unicodeName )
540: {
541: ByteCount unicodeByteLength;
542: OSErr result;
543:
544:
545: result = MockConvertFromPStringToUnicode( hfsName, sizeof(unicodeName->unicode), &unicodeByteLength, unicodeName->unicode );
546:
547: unicodeName->length = unicodeByteLength / sizeof(UniChar); // Note: from byte count to char count
548:
549: return result;
550:
551: } // end ConvertHFSNameToUnicode
552: #endif
553:
554:
555: /*
556: MockConvertFromUnicodeToPString
557: */
558: #if TARGET_OS_MAC
559: OSErr
560: MockConvertFromUnicodeToPString( ByteCount unicodeLength, ConstUniCharArrayPtr unicodeStr, Str31 pascalStr )
561: {
562: return UnicodeToMacRoman(unicodeLength / sizeof(UniChar), unicodeStr, pascalStr);
563: }
564: #endif
565:
566: /*
567: MockConvertFromPStringToUnicode
568: */
569: #if TARGET_OS_MAC
570: OSErr
571: MockConvertFromPStringToUnicode(ConstStr31Param pascalStr, ByteCount maxUnicodeLen, ByteCount *actualUnicodeLen, UniCharArrayPtr unicodeStr)
572: {
573: #pragma unused(maxUnicodeLen)
574:
575: UInt32 unicodeChars;
576: OSErr result;
577:
578: result = MacRomanToUnicode (pascalStr, &unicodeChars, unicodeStr);
579:
580: *actualUnicodeLen = unicodeChars * sizeof(UniChar); // return length in bytes
581:
582: return result;
583: }
584: #endif
585:
586: /*
587: Initialize the Unicode Converter library
588:
589: If the library cannot be initialized the wrapper code will default to using 7-bit ASCII or mangled names.
590:
591: WARNING: This cannot be called from within a file system call (since it calls the file system)!
592: */
593: #if TARGET_OS_MAC
594: OSErr InitUnicodeConverter(Boolean forBootVolume)
595: {
596: FSVarsRec *fsVars;
597: Handle resourceHandle;
598: long response;
599: OSErr err;
600:
601:
602: fsVars = (FSVarsRec*) LMGetFSMVars();
603:
604: if ( fsVars->gIsUnicodeInstalled == true ) // Has Unicode already been installed
605: return ( noErr );
606:
607: err = Gestalt( gestaltSysArchitecture, &response ); //�� Runtime check to load static or dynamic libraries
608: if ( (response == gestaltPowerPC) && (err == noErr) )
609: {
610: SInt32 savedOffsetToUTC;
611:
612: if (forBootVolume)
613: {
614: savedOffsetToUTC = fsVars->offsetToUTC; // save offset from GMT to local time
615: fsVars->offsetToUTC = 0; // trick CFM into caching an older mod date for the extensions folder
616:
617: // For bootstrap PascalToUnicode conversions we need to load the p2u table
618: resourceHandle = GetResource ('p2u#', 0); // get our special mapping table
619: if (resourceHandle != NULL)
620: {
621: HLock(resourceHandle);
622: fsVars->gBootPToUTable = *resourceHandle;
623: }
624: }
625:
626:
627: err = InitDynamicUnicodeConverter( forBootVolume );
628:
629:
630: if (forBootVolume)
631: {
632: fsVars->offsetToUTC = savedOffsetToUTC; // restore offset from GMT to local time
633:
634: // The real converters should be online now so we can jettison the table
635: if (resourceHandle != NULL)
636: {
637: HUnlock(resourceHandle);
638: fsVars->gBootPToUTable = NULL;
639: ReleaseResource(resourceHandle); // we no longer need this table
640: }
641: }
642: }
643:
644: if ( (err != noErr) || (response != gestaltPowerPC) ) // If we got an error or on a 68K mac
645: {
646: err = InitStaticUnicodeConverter(); // Init the 68K static version of the converters
647: }
648:
649:
650: return ( err );
651: }
652: #endif /* TARGET_OS_MAC */
653:
654:
655: /*
656: Initialize the Staticly linked 68K Unicode Converter library
657:
658: If the library cannot be initialized the wrapper code will default to using 7-bit ASCII or mangled names.
659: WARNING: This cannot be called from within a file system call (since it calls the file system)!
660: */
661: #if TARGET_OS_MAC
662: static OSErr
663: InitStaticUnicodeConverter(void)
664: {
665: FSVarsRec *fsVars;
666: THz savedHeapZone;
667: OSErr err;
668: Str31 textEncodingConverterName;
669:
670: // use the system context
671: savedHeapZone = GetZone();
672: SetZone( SystemZone() );
673:
674: GetIndString( textEncodingConverterName, kBaseHFSPlusResourceID, rTextEncodingConverterName ); //���need real string!!
675: err = InitializeUnicode( textEncodingConverterName );
676: ExitOnError( err );
677:
678: fsVars = (FSVarsRec*) LMGetFSMVars();
679: fsVars->gUseDynamicUnicodeConverters = false;
680:
681: err = InstallSystemConversionContext( fsVars, false );
682: ExitOnError( err );
683:
684: fsVars = (FSVarsRec*) LMGetFSMVars();
685: fsVars->gIsUnicodeInstalled = true;
686:
687:
688: ErrorExit:
689:
690: SetZone( savedHeapZone );
691:
692: return( err );
693: }
694: #endif /* TARGET_OS_MAC */
695:
696:
697:
698: /*
699: Initialize the PPC CFM dynamically linked 68K Unicode Converter library
700: If the library cannot be initialized the wrapper code will default to
701: using the 68K staticly linked library.
702: */
703: #if TARGET_OS_MAC
704: static OSErr
705: InitDynamicUnicodeConverter( Boolean forBootVolume )
706: {
707: CFragConnectionID unicodeLib = 0;
708: CFragConnectionID textLib = 0;
709: Ptr tempMainAddr;
710: Str255 errMessage;
711: FSVarsRec *fsVars;
712: THz savedHeapZone;
713: OSErr result;
714:
715:
716: fsVars = (FSVarsRec*) LMGetFSMVars();
717:
718: // use the system context
719: savedHeapZone = GetZone();
720: SetZone( SystemZone() );
721: #if 0
722: (void) BeginSystemMode();
723: #endif
724:
725: result = GetSharedLibrary("\pUnicodeConverter", kPowerPCCFragArch, kPrivateCFragCopy, &unicodeLib, &tempMainAddr, errMessage);
726: ExitOnError( result );
727:
728: result = GetSharedLibrary("\pTextCommon", kPowerPCCFragArch, kPrivateCFragCopy, &textLib, &tempMainAddr, errMessage);
729: ExitOnError( result );
730:
731:
732: fsVars->gUseDynamicUnicodeConverters = true;
733:
734: result = InstallLibraryVector( unicodeLib,
735: "\pCreateTextToUnicodeInfo",
736: uupCreateTextToUnicodeInfoProcInfo,
737: &fsVars->uppCreateTextToUnicodeInfo );
738: ExitOnError( result );
739:
740:
741: result = InstallLibraryVector( unicodeLib,
742: "\pCreateUnicodeToTextInfo",
743: uppCreateUnicodeToTextInfoProcInfo,
744: &fsVars->uppCreateUnicodeToTextInfo );
745: ExitOnError( result );
746:
747:
748: result = InstallLibraryVector( unicodeLib,
749: "\pConvertFromTextToUnicode",
750: uppConvertFromTextToUnicodeProcInfo,
751: &fsVars->uppConvertFromTextToUnicode ); // don't set vector yet
752: ExitOnError( result );
753:
754:
755: result = InstallLibraryVector( unicodeLib,
756: "\pConvertFromUnicodeToText",
757: uppConvertFromUnicodeToTextProcInfo,
758: &fsVars->uppConvertFromUnicodeToText ); // don't set vector yet
759: ExitOnError( result );
760:
761:
762: result = InstallLibraryVector( unicodeLib,
763: "\pLockMappingTable",
764: uppLockMappingTableProcInfo,
765: &fsVars->uppLockMappingTable );
766: ExitOnError( result );
767:
768:
769: result = InstallLibraryVector( textLib,
770: "\pUpgradeScriptInfoToTextEncoding",
771: uppUpgradeScriptInfoToTextEncodingProcInfo,
772: &fsVars->uppUpgradeScriptInfoToTextEncoding );
773: ExitOnError( result );
774:
775: #if 0
776: result = InstallLibraryVector( textLib,
777: "\pRevertTextEncodingToScriptInfo",
778: uppRevertTextEncodingToScriptInfoProcInfo,
779: &fsVars->uppRevertTextEncodingToScriptInfo );
780: ExitOnError( result );
781: #endif
782:
783: // NOTE: Real Unicode filename conversion is not enabled yet but that's OK.
784: // We can still call the converter library since it finds it's data files by
785: // matching file type and creator (not by name).
786:
787: result = InstallSystemConversionContext(fsVars, forBootVolume);
788: ExitOnError( result );
789:
790: fsVars->gIsUnicodeInstalled = true; // Unicode binding and setup succesful, and now enabled
791:
792: // restore previous context
793: #if 0
794: (void) EndSystemMode();
795: #endif
796: SetZone( savedHeapZone );
797:
798: return noErr;
799:
800: ErrorExit:
801:
802: fsVars->uppCreateTextToUnicodeInfo = NULL;
803: fsVars->uppCreateUnicodeToTextInfo = NULL;
804: fsVars->uppConvertFromTextToUnicode = NULL;
805: fsVars->uppConvertFromUnicodeToText = NULL;
806: fsVars->uppLockMappingTable = NULL;
807:
808: if ( unicodeLib )
809: (void) CloseConnection( &unicodeLib );
810:
811: if ( textLib )
812: (void) CloseConnection( &textLib );
813:
814: #if 0
815: (void) EndSystemMode();
816: #endif
817: SetZone( savedHeapZone );
818:
819: return result;
820:
821: } // end InitDynamicUnicodeConverter
822: #endif /* TARGET_OS_MAC */
823:
824:
825:
826: //
827: // Install a conversion context for the system script (call early in boot)
828: //
829: #if TARGET_OS_MAC
830: static OSErr
831: InstallSystemConversionContext( FSVarsRec *fsVars, Boolean forBootVolume )
832: {
833: TextEncoding defaultEncoding;
834: ScriptCode script;
835: RegionCode region;
836: OSErr result;
837:
838: // The Script Manager does not setup the region until later in boot
839: // so if we're booting from HFS Plus we need to "manually" determine
840: // the system script and region using the 'itlc' resource.
841:
842: if ( forBootVolume )
843: {
844: Handle configResource;
845: ItlcRecord *itlConfig;
846:
847: configResource = GetResource( 'itlc', 0 );
848:
849: if ( configResource != NULL )
850: {
851: itlConfig = (ItlcRecord*) *configResource;
852:
853: script = itlConfig->itlcSystem;
854: region = itlConfig->itlcRegionCode;
855:
856: ReleaseResource( configResource );
857: }
858: else
859: {
860: script = GetScriptManagerVariable(smSysScript);
861: region = kTextRegionDontCare;
862: }
863: }
864: else
865: {
866: script = GetScriptManagerVariable(smSysScript);
867: region = GetScriptManagerVariable(smRegionCode);
868: }
869:
870: result = UpgradeScriptInfoToTextEncoding_Glue( script,
871: kTextLanguageDontCare,
872: region,
873: NULL,
874: &defaultEncoding );
875: if ( result == paramErr )
876: {
877: // ok, last ditch effort to get an encoding...
878: result = UpgradeScriptInfoToTextEncoding_Glue( script,
879: kTextLanguageDontCare,
880: kTextRegionDontCare,
881: NULL,
882: &defaultEncoding );
883: }
884: ReturnIfError(result);
885:
886: defaultEncoding = GetTextEncodingBasePriv(defaultEncoding);
887:
888: result = InitializeEncodingContext( defaultEncoding, fsVars );
889: ReturnIfError(result);
890:
891: if ( defaultEncoding != kTextEncodingMacRoman )
892: {
893: result = InitializeEncodingContext( kTextEncodingMacRoman, fsVars ); // always install Roman
894: ReturnIfError(result);
895: }
896:
897: // Since a call to set the default text encoding can occur
898: // before any HFS Plus volumes are mounted we need to check
899: // gDefaultBaseEncoding and gTextEncodingFontName to see if
900: // the default encoding needs to change...
901: if ( !forBootVolume )
902: {
903: TextEncoding requestedEncoding;
904:
905: requestedEncoding = fsVars->gDefaultBaseEncoding;
906:
907: if ( requestedEncoding == kTextEncodingUndefined && fsVars->gTextEncodingFontName != NULL )
908: {
909: result = UpgradeScriptInfoToTextEncoding_Glue ( kTextScriptDontCare,
910: kTextLanguageDontCare,
911: kTextRegionDontCare,
912: fsVars->gTextEncodingFontName,
913: &requestedEncoding );
914: if ( result != noErr )
915: requestedEncoding = kTextEncodingUndefined;
916:
917: DisposePtr((Ptr) fsVars->gTextEncodingFontName); // we no longer need font name
918: fsVars->gTextEncodingFontName = NULL;
919: }
920:
921: if ( requestedEncoding != kTextEncodingUndefined && requestedEncoding != defaultEncoding )
922: {
923: result = InitializeEncodingContext( requestedEncoding, fsVars );
924: if ( result == noErr )
925: defaultEncoding = requestedEncoding;
926: }
927: }
928:
929:
930: // remember the default text encoding...
931: fsVars->gDefaultBaseEncoding = defaultEncoding;
932:
933: return noErr;
934:
935: } // end InstallSystemConversionContext
936: #endif /* TARGET_OS_MAC */
937:
938:
939:
940: //
941: // Install any addition scripts that were installed by the system (call late in boot)
942: //
943: #if TARGET_OS_MAC
944: OSErr
945: InstallConversionContextsForInstalledScripts( void )
946: {
947: FSVarsRec* fsVars;
948: TextEncoding encoding;
949: UInt32 scriptCount;
950: ScriptCode systemScript;
951: ScriptCode script;
952: OSErr result;
953:
954:
955: fsVars = (FSVarsRec*) LMGetFSMVars();
956:
957: scriptCount = GetScriptManagerVariable(smEnabled);
958: systemScript = GetScriptManagerVariable(smSysScript);
959:
960: script = 0;
961:
962: while ( (scriptCount > 0) && (script <= smLargestScript) )
963: {
964: if ( GetScriptVariable(script, smScriptEnabled) != 0 ) // is this script enabled?
965: {
966: --scriptCount;
967:
968: if ( script != systemScript ) // we already did systemScript
969: {
970: LangCode language;
971:
972: language = GetScriptVariable( script, smScriptLang );
973:
974: result = UpgradeScriptInfoToTextEncoding_Glue( script, language, kTextRegionDontCare, NULL, &encoding );
975: if ( result == noErr )
976: (void) InitializeEncodingContext( encoding, fsVars );
977: }
978: }
979:
980: ++script; // on to the next one
981: }
982:
983: return noErr;
984:
985: } // end InstallConversionContextsForInstalledScripts
986: #endif /* TARGET_OS_MAC */
987:
988:
989:
990: //
991: // Install any addition scripts that were used by an HFS Plus volume (called at volume mount time)
992: //
993: #if TARGET_OS_MAC
994: OSErr
995: InstallVolumeConversionContexts( UInt64 encodingsBitmap )
996: {
997: FSVarsRec * fsVars;
998: UInt32 encodingMask;
999: UInt32 index;
1000: UInt32 encoding;
1001: OSErr result;
1002:
1003:
1004: fsVars = (FSVarsRec*) LMGetFSMVars();
1005:
1006: index = 0;
1007: encodingMask = 1;
1008:
1009: while ( encodingMask != 0 )
1010: {
1011: if ( encodingMask & encodingsBitmap.lo ) // encodings 0 - 31
1012: {
1013: encoding = MapIndexToEncoding(index);
1014: result = InitializeEncodingContext( encoding, fsVars );
1015: }
1016:
1017: if ( encodingMask & encodingsBitmap.hi ) // encodings 32 - 64
1018: {
1019: encoding = MapIndexToEncoding(index + 32);
1020: result = InitializeEncodingContext( encoding, fsVars );
1021: }
1022:
1023: encodingMask = encodingMask << 1;
1024: ++index;
1025: }
1026:
1027: return noErr;
1028:
1029: } // end InstallVolumeConversionContexts
1030: #endif /* TARGET_OS_MAC */
1031:
1032:
1033: //
1034: // Initialze a conversion context for a single encoding (if not already installed)
1035: //
1036: #if TARGET_OS_MAC
1037: OSErr InitializeEncodingContext( TextEncoding encoding, FSVarsRec *fsVars )
1038: {
1039: UInt32 index;
1040: UnicodeMapping unicodeMapping;
1041: THz savedHeapZone;
1042: OSStatus result;
1043:
1044:
1045: encoding = GetTextEncodingBasePriv( encoding );
1046: index = MapEncodingToIndex(encoding);
1047:
1048: if ( fsVars->gConversionContext[index].toUnicode != 0 )
1049: return noErr; // this one is already installed!
1050:
1051: savedHeapZone = GetZone();
1052: SetZone( SystemZone() ); // always use the system heap since Conversion Contexts are global
1053:
1054:
1055: // Note: by default kTextEncodingUnicodeV2_0 allows corporate use characters
1056: unicodeMapping.unicodeEncoding = CreateTextEncodingPriv( kTextEncodingUnicodeV2_0, kUnicodeCanonicalDecompVariant, 0 );
1057: unicodeMapping.otherEncoding = encoding;
1058: unicodeMapping.mappingVersion = kUnicodeUseHFSPlusMapping;
1059:
1060:
1061: if ( fsVars->gUseDynamicUnicodeConverters == false )
1062: result = LockMappingTable( &unicodeMapping, true );
1063: else
1064: result = LockMappingTable_Glue( &unicodeMapping, true );
1065: ExitOnError( result );
1066:
1067: result = CreateTextToUnicodeInfo_Glue( &unicodeMapping, &fsVars->gConversionContext[index].toUnicode );
1068: ExitOnError( result );
1069:
1070: result = CreateUnicodeToTextInfo_Glue( &unicodeMapping, &fsVars->gConversionContext[index].fromUnicode );
1071: ExitOnError( result );
1072:
1073: ++(fsVars->gInstalledEncodings); // keep track of how many we've installed
1074:
1075: #if 0
1076: result = SetFallbackUnicodeToText( fsVars->gConversionContext[index].fromUnicode,
1077: NewUnicodeToTextFallbackProc(FallbackProc), // since we are compiled 68K no routine descriptor is needed
1078: kUnicodeFallbackCustomOnly,
1079: NULL );
1080:
1081: #endif
1082:
1083: ErrorExit:
1084:
1085: SetZone( savedHeapZone );
1086:
1087: return result;
1088:
1089: } // end InitializeEncodingContext
1090: #endif /* TARGET_OS_MAC */
1091:
1092:
1093: #if TARGET_OS_MAC
1094: pascal OSStatus
1095: FallbackProc( UniChar * srcUniStr, ByteCount srcUniStrLen, ByteCount *srcConvLen,
1096: TextPtr destStr, ByteCount destStrLen, ByteCount *destConvLen,
1097: LogicalAddress contextPtr, ConstUnicodeMappingPtr unicodeMappingPtr)
1098: {
1099: #pragma unused (srcUniStr, destStrLen, contextPtr, unicodeMappingPtr)
1100: *srcConvLen = srcUniStrLen;
1101: *destStr = '_';
1102: *destConvLen = sizeof(unsigned char);
1103:
1104: return noErr;
1105: }
1106: #endif
1107:
1108: #if TARGET_OS_MAC
1109: static OSErr
1110: InstallLibraryVector ( CFragConnectionID connectionID, ConstStr255Param symbolName, ProcInfoType procInfo, UniversalProcPtr *vector)
1111: {
1112: UniversalProcPtr routineDescriptor;
1113: CFragSymbolClass symClass;
1114: ProcPtr tVector;
1115: OSErr result;
1116:
1117:
1118: result = FindSymbol(connectionID, symbolName, (Ptr *) &tVector, &symClass);
1119: ReturnIfError( result );
1120:
1121: routineDescriptor = NewRoutineDescriptorTrap(tVector, procInfo, kPowerPCISA);
1122:
1123: if ( routineDescriptor != NULL )
1124: *vector = routineDescriptor;
1125: else
1126: result = memFullErr;
1127:
1128: return result;
1129: }
1130: #endif
1131:
1132:
1133: //
1134: // Get filename extension (if any) as a pascal string
1135: //
1136: #if TARGET_OS_MAC
1137: static void
1138: GetFilenameExtension( ItemCount length, ConstUniCharArrayPtr unicodeStr, Str15 extStr )
1139: {
1140: UInt32 i;
1141: UniChar c;
1142: UInt16 extChars; // number of extension characters (excluding the dot)
1143: UInt16 maxExtChars;
1144: Boolean foundExtension;
1145:
1146:
1147: extStr[0] = (UInt8) 0; // assume there's no extension
1148:
1149: if ( length < 3 )
1150: return; // sorry, "x.y" is smallest possible extension
1151:
1152: if ( length < (kMaxFileExtensionChars + 2) )
1153: maxExtChars = length - 2; // we need at least one prefix character and dot
1154: else
1155: maxExtChars = kMaxFileExtensionChars;
1156:
1157: i = length;
1158: extChars = 0;
1159: foundExtension = false;
1160:
1161: while ( extChars <= maxExtChars )
1162: {
1163: c = unicodeStr[--i];
1164:
1165: if ( c == (UniChar) '.' ) // look for leading dot
1166: {
1167: if ( extChars > 0 ) // cannot end with a dot
1168: foundExtension = true;
1169: break;
1170: }
1171:
1172: if ( Is7BitASCII(c) || IsSpecialUnicodeChar(c) )
1173: ++extChars;
1174: else
1175: break;
1176: }
1177:
1178: // if we found one then copy it
1179: if ( foundExtension )
1180: {
1181: UInt8 *extStrPtr = extStr;
1182: const UniChar *unicodeStrPtr = &unicodeStr[i]; // point to dot char
1183:
1184: *(extStrPtr++) = extChars + 1; // set length to extension chars plus dot
1185:
1186: for ( i = 0; i <= extChars; ++i )
1187: {
1188: c = *(unicodeStrPtr++);
1189:
1190: // map any special characters
1191: switch (c)
1192: {
1193: case 0x00B5: // micro sign
1194: case 0x03BC: // greek mu
1195: c = (UniChar) '�';
1196: break;
1197:
1198: case 0x03C0: // greek pi
1199: c = (UniChar) '�';
1200: break;
1201:
1202: case 0x2206: // increment sign
1203: case 0x0394: // greek capital delta
1204: c = (UniChar) '�';
1205: break;
1206: }
1207:
1208: *(extStrPtr++) = (UInt8) c; // copy/convert to ascii
1209: }
1210: }
1211:
1212: } // end GetFilenameExtension
1213: #endif /* TARGET_OS_MAC */
1214:
1215:
1216: //
1217: // Count filename extension characters (if any)
1218: //
1219: static UInt32
1220: CountFilenameExtensionChars( const unsigned char * filename )
1221: {
1222: UInt32 i;
1223: UniChar c;
1224: UInt32 extChars; // number of extension characters (excluding the dot)
1225: UInt32 length;
1226: UInt16 maxExtChars;
1227: Boolean foundExtension;
1228:
1229:
1230: length = strlen(filename);
1231:
1232: if ( length < 3 )
1233: return 0; // sorry, "x.y" is smallest possible extension
1234:
1235: if ( length < (kMaxFileExtensionChars + 2) )
1236: maxExtChars = length - 2; // we need at least on prefix character and dot
1237: else
1238: maxExtChars = kMaxFileExtensionChars;
1239:
1240: extChars = 0; // assume there's no extension
1241: i = length - 1; // index to last ascii character
1242: foundExtension = false;
1243:
1244: while ( extChars <= maxExtChars )
1245: {
1246: c = filename[i--];
1247:
1248: if ( c == (UInt8) '.' ) // look for leading dot
1249: {
1250: if ( extChars > 0 ) // cannot end with a dot
1251: return (extChars);
1252:
1253: break;
1254: }
1255:
1256: if ( Is7BitASCII(c) || IsSpecialASCIIChar(c) )
1257: ++extChars;
1258: else
1259: break;
1260: }
1261:
1262: return 0;
1263:
1264: } // end CountFilenameExtensionChars
1265:
1266:
1267: //
1268: // Convert file ID into a hexidecimal string with no leading zeros
1269: //
1270: #if TARGET_OS_MAC
1271: static void
1272: GetFileIDString( HFSCatalogNodeID fileID, Str15 fileIDStr )
1273: {
1274: SInt32 i, b;
1275: static UInt8 *translate = (UInt8 *) "0123456789ABCDEF";
1276: UInt8 c;
1277:
1278: fileIDStr[1] = '#';
1279:
1280: for ( i = 1, b = 28; b >= 0; b -= 4 )
1281: {
1282: c = *(translate + ((fileID >> b) & 0x0000000F));
1283:
1284: // if its not a leading zero add it to our string
1285: if ( (c != (UInt8) '0') || (i > 1) || (b == 0) )
1286: fileIDStr[++i] = c;
1287: }
1288:
1289: fileIDStr[0] = (UInt8) i;
1290:
1291: } // end GetFileIDString
1292: #endif /* TARGET_OS_MAC */
1293:
1294:
1295: //
1296: // Append a suffix to a pascal string
1297: //
1298: #if TARGET_OS_MAC
1299: static void
1300: AppendPascalString( ConstStr15Param src, Str31 dst )
1301: {
1302: UInt32 i, j;
1303: UInt32 srcLen;
1304:
1305: srcLen = StrLength(src);
1306:
1307: if ( (srcLen + StrLength(dst)) > 31 ) // safety net
1308: return;
1309:
1310: i = dst[0] + 1; // get end of dst
1311:
1312: for (j = 1; j <= srcLen; ++j)
1313: dst[i++] = src[j];
1314:
1315: dst[0] += srcLen;
1316:
1317: } // end AppendPascalString
1318: #endif /* TARGET_OS_MAC */
1319:
1320:
1321: HFSCatalogNodeID
1322: GetEmbeddedFileID(const unsigned char * filename, UInt32 *prefixLength)
1323: {
1324: short length;
1325: short extChars;
1326: short i;
1327: UInt8 c; // current character in filename
1328:
1329: *prefixLength = 0;
1330:
1331: if ( filename == NULL )
1332: return 0;
1333:
1334: length = strlen(filename);
1335:
1336: if ( length < 4 )
1337: return 0; // too small to have a file ID
1338:
1339: if ( length >= 6 ) // big enough for a file ID (#10) and an extension (.x) ?
1340: extChars = CountFilenameExtensionChars(filename);
1341: else
1342: extChars = 0;
1343:
1344: if ( extChars > 0 )
1345: length -= (extChars + 1); // skip dot plus extension characters
1346:
1347: // scan for file id digits...
1348: for ( i = length - 1; i >= 0; --i)
1349: {
1350: c = filename[i];
1351:
1352: if ( c == '#' ) // look for file ID marker
1353: {
1354: if ( (length - i) < 3 )
1355: break; // too small to be a file ID
1356:
1357: *prefixLength = i;
1358: return HexStringToInteger(length - i - 1, &filename[i+1]);
1359: }
1360:
1361: if ( !IsHexDigit(c) )
1362: break; // file ID string must have hex digits
1363: }
1364:
1365: return 0;
1366:
1367: } // end GetEmbeddedFileID
1368:
1369:
1370: //_______________________________________________________________________
1371:
1372: static UInt32
1373: HexStringToInteger (UInt32 length, const UInt8 *hexStr)
1374: {
1375: UInt32 value; // decimal value represented by the string
1376: short i;
1377: UInt8 c; // next character in buffer
1378: const UInt8 *p; // pointer to character string
1379:
1380: value = 0;
1381: p = hexStr;
1382:
1383: for ( i = 0; i < length; ++i )
1384: {
1385: c = *p++;
1386:
1387: if (c >= '0' && c <= '9')
1388: {
1389: value = value << 4;
1390: value += (UInt32) c - (UInt32) '0';
1391: }
1392: else if (c >= 'A' && c <= 'F')
1393: {
1394: value = value << 4;
1395: value += 10 + ((unsigned int) c - (unsigned int) 'A');
1396: }
1397: else
1398: {
1399: return 0; // oops, how did this character get in here?
1400: }
1401: }
1402:
1403: return value;
1404:
1405: } // end HexStringToInteger
1406:
1407:
1408: //_______________________________________________________________________
1409: //
1410: // Routine: FastRelString
1411: //
1412: // Output: returns -1 if str1 < str2
1413: // returns 1 if str1 > str2
1414: // return 0 if equal
1415: //
1416: //_______________________________________________________________________
1417:
1418: #if USE_TABLE_ACCESSORS
1419: UInt16 *Get_gCompareTable(void);
1420: #else
1421: extern unsigned short gCompareTable[];
1422: #endif
1423:
1424: SInt32 FastRelString( ConstStr255Param str1, ConstStr255Param str2 )
1425: {
1426: UInt16* compareTable;
1427: SInt32 bestGuess;
1428: UInt8 length, length2;
1429:
1430:
1431: length = *(str1++);
1432: length2 = *(str2++);
1433:
1434: if (length == length2)
1435: bestGuess = 0;
1436: else if (length < length2)
1437: bestGuess = -1;
1438: else
1439: {
1440: bestGuess = 1;
1441: length = length2;
1442: }
1443:
1444: #if USE_TABLE_ACCESSORS
1445: compareTable = Get_gCompareTable();
1446: #else
1447: compareTable = (UInt16*) gCompareTable;
1448: #endif
1449:
1450: while (length--)
1451: {
1452: UInt8 aChar, bChar;
1453:
1454: aChar = *(str1++);
1455: bChar = *(str2++);
1456:
1457: if (aChar != bChar) // If they don't match exacly, do case conversion
1458: {
1459: UInt16 aSortWord, bSortWord;
1460:
1461: aSortWord = compareTable[aChar];
1462: bSortWord = compareTable[bChar];
1463:
1464: if (aSortWord > bSortWord)
1465: return 1;
1466:
1467: if (aSortWord < bSortWord)
1468: return -1;
1469: }
1470:
1471: // If characters match exactly, then go on to next character immediately without
1472: // doing any extra work.
1473: }
1474:
1475: // if you got to here, then return bestGuess
1476: return bestGuess;
1477: }
1478:
1479:
1480:
1481: /* 0x00A0 - 0x00FF = Latin 1 Supplement (30 total) */
1482: UInt8 gLatin1Table[] =
1483: { /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
1484: /* 0x00A0 */ 0xCA, 0xC1, 0xA2, 0xA3, 0xDB, 0xB4, '?', 0xA4, 0xAC, 0xA9, 0xBB, 0xC7, 0xC2, '?', 0xA8, 0xF8,
1485: /* 0x00B0 */ 0xA1, 0XB1, '?', '?', 0xAB, 0xB5, 0xA6, 0xe1, 0xFC, '?', 0xBC, 0xC8, '?', '?', '?', 0xC0,
1486: /* 0x00C0 */ '?', '?', '?', '?', '?', '?', 0xAE, '?', '?', '?', '?', '?', '?', '?', '?', '?',
1487: /* 0x00D0 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xAF, '?', '?', '?', '?', '?', '?', 0xA7,
1488: /* 0x00E0 */ '?', '?', '?', '?', '?', '?', 0xBE, '?', '?', '?', '?', '?', '?', '?', '?', '?',
1489: /* 0x00F0 */ '?', '?', '?', '?', '?', '?', '?', 0xD6, 0xBF, '?', '?', '?', '?', '?', '?', '?'
1490: };
1491:
1492:
1493: /* 0x02C0 - 0x02DF = Spacing Modifiers (8 total) */
1494: UInt8 gSpaceModsTable[] =
1495: { /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
1496: /* 0x02C0 */ '?', '?', '?', '?', '?', '?', 0xF6, 0xFF, '?', '?', '?', '?', '?', '?', '?', '?',
1497: /* 0x02D0 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xF9, 0xFA, 0xFB, 0xFE, 0xF7, 0xFD, '?', '?'
1498: };
1499:
1500:
1501: /* 0x20xx = General Punctuation (16 total) */
1502: UInt8 gPunctTable[] =
1503: { /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
1504: /* 0x2000 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
1505: /* 0x2010 */ '?', '?', '?', 0xd0, 0xd1, '?', '?', '?', 0xd4, 0xd5, 0xe2, '?', 0xd2, 0xd3, 0xe3, '?',
1506: /* 0x2020 */ 0xa0, 0xe0, 0xa5, '?', '?', '?', 0xc9, '?', '?', '?', '?', '?', '?', '?', '?', '?',
1507: /* 0x2030 */ 0xe4, '?', '?', '?', '?', '?', '?', '?', '?', 0xdc, 0xdd, '?', '?', '?', '?', '?',
1508: /* 0x2040 */ '?', '?', '?', '?', 0xda, '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?'
1509: };
1510:
1511:
1512: /* 0x2200 = Mathematical Operators (11 total) */
1513: UInt8 gMathTable[] =
1514: { /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
1515: /* 0x2200 */ '?', '?', 0xb6, '?', '?', '?', 0xc6, '?', '?', '?', '?', '?', '?', '?', '?', 0xb8,
1516: /* 0x2210 */ '?', 0xb7, '?', '?', '?', '?', '?', '?', '?', '?', 0xc3, '?', '?', '?', 0xb0, '?',
1517: /* 0x2220 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', 0xba, '?', '?', '?', '?',
1518: /* 0x2230 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
1519: /* 0x2240 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xc5, '?', '?', '?', '?', '?', '?', '?',
1520: /* 0x2250 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
1521: /* 0x2260 */ 0xad, '?', '?', '?', 0xb2, 0xb3, '?', '?', '?', '?', '?', '?', '?', '?', '?', '?'
1522: };
1523:
1524:
1525: /* */
1526: UInt8 gReverseCombTable[] =
1527: { /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
1528: /* 0x40 */ 0xDA, 0x40, 0xDA, 0xDA, 0xDA, 0x56, 0xDA, 0xDA, 0xDA, 0x6C, 0xDA, 0xDA, 0xDA, 0xDA, 0x82, 0x98,
1529: /* 0x50 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xAE, 0xDA, 0xDA, 0xDA, 0xC4, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
1530: /* 0x60 */ 0xDA, 0x4B, 0xDA, 0xDA, 0xDA, 0x61, 0xDA, 0xDA, 0xDA, 0x77, 0xDA, 0xDA, 0xDA, 0xDA, 0x8D, 0xA3,
1531: /* 0x70 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xB9, 0xDA, 0xDA, 0xDA, 0xCF, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
1532:
1533: /* Combining Diacritical Marks (0x0300 - 0x030A) */
1534:
1535: /* 0 1 2 3 4 5 6 7 8 9 A */
1536: /* 'A' */
1537: /* 0x0300 */ 0xCB, 0xE7, 0xE5, 0xCC, '?', '?', '?', '?', 0x80, '?', 0x81,
1538:
1539: /* 'a' */
1540: /* 0x0300 */ 0x88, 0x87, 0x89, 0x8B, '?', '?', '?', '?', 0x8A, '?', 0x8C,
1541:
1542: /* 'E' */
1543: /* 0x0300 */ 0xE9, 0x83, 0xE6, '?', '?', '?', '?', '?', 0xE8, '?', '?',
1544:
1545: /* 'e' */
1546: /* 0x0300 */ 0x8F, 0x8E, 0x90, '?', '?', '?', '?', '?', 0x91, '?', '?',
1547:
1548: /* 'I' */
1549: /* 0x0300 */ 0xED, 0xEA, 0xEB, '?', '?', '?', '?', '?', 0xEC, '?', '?',
1550:
1551: /* 'i' */
1552: /* 0x0300 */ 0x93, 0x92, 0x94, '?', '?', '?', '?', '?', 0x95, '?', '?',
1553:
1554: /* 'N' */
1555: /* 0x0300 */ '?', '?', '?', 0x84, '?', '?', '?', '?', '?', '?', '?',
1556:
1557: /* 'n' */
1558: /* 0x0300 */ '?', '?', '?', 0x96, '?', '?', '?', '?', '?', '?', '?',
1559:
1560: /* 'O' */
1561: /* 0x0300 */ 0xF1, 0xEE, 0xEF, 0xCD, '?', '?', '?', '?', 0x85, '?', '?',
1562:
1563: /* 'o' */
1564: /* 0x0300 */ 0x98, 0x97, 0x99, 0x9B, '?', '?', '?', '?', 0x9A, '?', '?',
1565:
1566: /* 'U' */
1567: /* 0x0300 */ 0xF4, 0xF2, 0xF3, '?', '?', '?', '?', '?', 0x86, '?', '?',
1568:
1569: /* 'u' */
1570: /* 0x0300 */ 0x9D, 0x9C, 0x9E, '?', '?', '?', '?', '?', 0x9F, '?', '?',
1571:
1572: /* 'Y' */
1573: /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xD9, '?', '?',
1574:
1575: /* 'y' */
1576: /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xD8, '?', '?',
1577:
1578: /* else */
1579: /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?'
1580: };
1581:
1582:
1583: static OSErr UnicodeToMacRoman (ItemCount unicodeChars, ConstUniCharArrayPtr unicodeString, Str31 pascalString)
1584: {
1585: UInt8 *p;
1586: const UniChar *u;
1587: UniChar c;
1588: UniChar mask;
1589: UInt16 inputChars;
1590: UInt16 pascalChars;
1591: OSErr result = noErr;
1592: UInt8 lsb;
1593: UInt8 prevChar;
1594: UInt8 mc;
1595:
1596:
1597: mask = (UniChar) 0xFF80;
1598: p = &pascalString[1];
1599: u = unicodeString;
1600: inputChars = unicodeChars;
1601: pascalChars = prevChar = 0;
1602:
1603: while (inputChars) {
1604: c = *(u++);
1605: lsb = (UInt8) c;
1606:
1607: /*
1608: * If its not 7-bit ascii, then we need to map it
1609: */
1610: if ( c & mask ) {
1611: mc = '?';
1612: switch (c & 0xFF00) {
1613: case 0x0000:
1614: if (lsb >= 0xA0)
1615: mc = gLatin1Table[lsb - 0xA0];
1616: break;
1617:
1618: case 0x0200:
1619: if (lsb >= 0xC0 && lsb <= 0xDF)
1620: mc = gSpaceModsTable[lsb - 0xC0];
1621: break;
1622:
1623: case 0x2000:
1624: if (lsb <= 0x4F)
1625: mc = gPunctTable[lsb];
1626: break;
1627:
1628: case 0x2200:
1629: if (lsb <= 0x6F)
1630: mc = gMathTable[lsb];
1631: break;
1632:
1633: case 0x0300:
1634: if (c <= 0x030A) {
1635: if (prevChar >= 'A' && prevChar < 'z') {
1636: mc = gReverseCombTable[gReverseCombTable[prevChar - 0x40] + lsb];
1637: --p; /* backup over base char */
1638: --pascalChars;
1639: }
1640: }
1641: else {
1642: switch (c) {
1643: case 0x0327: /* combining cedilla */
1644: if (prevChar == 'C')
1645: mc = 0x82;
1646: else if (prevChar == 'c')
1647: mc = 0x8D;
1648: else
1649: break;
1650: --p; /* backup over base char */
1651: --pascalChars;
1652: break;
1653:
1654: case 0x03A9: mc = 0xBD; break; /* omega */
1655:
1656: case 0x03C0: mc = 0xB9; break; /* pi */
1657: }
1658: }
1659: break;
1660:
1661: default:
1662: switch (c) {
1663: case 0x0131: mc = 0xf5; break; /* dotless i */
1664:
1665: case 0x0152: mc = 0xce; break; /* OE */
1666:
1667: case 0x0153: mc = 0xcf; break; /* oe */
1668:
1669: case 0x0192: mc = 0xc4; break; /* � */
1670:
1671: case 0x2122: mc = 0xaa; break; /* TM */
1672:
1673: case 0x25ca: mc = 0xd7; break; /* diamond */
1674:
1675: case 0xf8ff: mc = 0xf0; break; /* apple logo */
1676:
1677: case 0xfb01: mc = 0xde; break; /* fi */
1678:
1679: case 0xfb02: mc = 0xdf; break; /* fl */
1680: }
1681: } /* end switch (c & 0xFF00) */
1682:
1683: /*
1684: * If we have an unmapped character then we need to mangle the name...
1685: */
1686: if (mc == '?')
1687: result = kTECUsedFallbacksStatus;
1688:
1689: prevChar = 0;
1690: lsb = mc;
1691:
1692: } /* end if (c & mask) */
1693: else {
1694: prevChar = lsb;
1695: }
1696:
1697: if (pascalChars >= 31)
1698: break;
1699:
1700: *(p++) = lsb;
1701: ++pascalChars;
1702: --inputChars;
1703:
1704: } /* end while */
1705:
1706: pascalString[0] = pascalChars;
1707:
1708: if (inputChars > 0)
1709: result = kTECOutputBufferFullStatus; /* ran out of room! */
1710:
1711: return result;
1712: }
1713:
1714:
1715: UniChar gHiBitBaseUnicode[128] =
1716: {
1717: /* 0x80 */ 0x0041, 0x0041, 0x0043, 0x0045, 0x004e, 0x004f, 0x0055, 0x0061,
1718: /* 0x88 */ 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0063, 0x0065, 0x0065,
1719: /* 0x90 */ 0x0065, 0x0065, 0x0069, 0x0069, 0x0069, 0x0069, 0x006e, 0x006f,
1720: /* 0x98 */ 0x006f, 0x006f, 0x006f, 0x006f, 0x0075, 0x0075, 0x0075, 0x0075,
1721: /* 0xa0 */ 0x2020, 0x00b0, 0x00a2, 0x00a3, 0x00a7, 0x2022, 0x00b6, 0x00df,
1722: /* 0xa8 */ 0x00ae, 0x00a9, 0x2122, 0x00b4, 0x00a8, 0x2260, 0x00c6, 0x00d8,
1723: /* 0xb0 */ 0x221e, 0x00b1, 0x2264, 0x2265, 0x00a5, 0x00b5, 0x2202, 0x2211,
1724: /* 0xb8 */ 0x220f, 0x03c0, 0x222b, 0x00aa, 0x00ba, 0x03a9, 0x00e6, 0x00f8,
1725: /* 0xc0 */ 0x00bf, 0x00a1, 0x00ac, 0x221a, 0x0192, 0x2248, 0x2206, 0x00ab,
1726: /* 0xc8 */ 0x00bb, 0x2026, 0x00a0, 0x0041, 0x0041, 0x004f, 0x0152, 0x0153,
1727: /* 0xd0 */ 0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0x00f7, 0x25ca,
1728: /* 0xd8 */ 0x0079, 0x0059, 0x2044, 0x00a4, 0x2039, 0x203a, 0xfb01, 0xfb02,
1729: /* 0xe0 */ 0x2021, 0x00b7, 0x201a, 0x201e, 0x2030, 0x0041, 0x0045, 0x0041,
1730: /* 0xe8 */ 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049, 0x004f, 0x004f,
1731: /* 0xf0 */ 0xf8ff, 0x004f, 0x0055, 0x0055, 0x0055, 0x0131, 0x02c6, 0x02dc,
1732: /* 0xf8 */ 0x00af, 0x02d8, 0x02d9, 0x02da, 0x00b8, 0x02dd, 0x02db, 0x02c7
1733: };
1734:
1735: UniChar gHiBitCombUnicode[128] =
1736: {
1737: /* 0x80 */ 0x0308, 0x030a, 0x0327, 0x0301, 0x0303, 0x0308, 0x0308, 0x0301,
1738: /* 0x88 */ 0x0300, 0x0302, 0x0308, 0x0303, 0x030a, 0x0327, 0x0301, 0x0300,
1739: /* 0x90 */ 0x0302, 0x0308, 0x0301, 0x0300, 0x0302, 0x0308, 0x0303, 0x0301,
1740: /* 0x98 */ 0x0300, 0x0302, 0x0308, 0x0303, 0x0301, 0x0300, 0x0302, 0x0308,
1741: /* 0xa0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1742: /* 0xa8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1743: /* 0xb0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1744: /* 0xb8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1745: /* 0xc0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1746: /* 0xc8 */ 0x0000, 0x0000, 0x0000, 0x0300, 0x0303, 0x0303, 0x0000, 0x0000,
1747: /* 0xd0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1748: /* 0xd8 */ 0x0308, 0x0308, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1749: /* 0xe0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0302, 0x0302, 0x0301,
1750: /* 0xe8 */ 0x0308, 0x0300, 0x0301, 0x0302, 0x0308, 0x0300, 0x0301, 0x0302,
1751: /* 0xf0 */ 0x0000, 0x0300, 0x0301, 0x0302, 0x0300, 0x0000, 0x0000, 0x0000,
1752: /* 0xf8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
1753: };
1754:
1755:
1756: static OSErr MacRomanToUnicode (ConstStr255Param pascalString, ItemCount *unicodeChars, UniCharArrayPtr unicodeString)
1757: {
1758: const UInt8 *p;
1759: UniChar *u;
1760: UInt16 pascalChars;
1761: UInt8 c;
1762:
1763:
1764: p = pascalString;
1765: u = unicodeString;
1766:
1767: *unicodeChars = pascalChars = *(p++); // pick up length byte
1768:
1769: while (pascalChars--) {
1770: c = *(p++);
1771:
1772: if ( (SInt8) c >= 0 ) { // make sure its seven bit ascii
1773: *(u++) = (UniChar) c; // pad high byte with zero
1774: }
1775: else { /* its a hi bit character */
1776: UniChar uc;
1777:
1778: c &= 0x7F;
1779: *(u++) = uc = gHiBitBaseUnicode[c];
1780:
1781: /*
1782: * if the unicode character (uc) is an alpha char
1783: * then we have an additional combining character
1784: */
1785: if ((uc <= (UniChar) 'z') && (uc >= (UniChar) 'A')) {
1786: *(u++) = gHiBitCombUnicode[c];
1787: ++(*unicodeChars);
1788: }
1789: }
1790: }
1791:
1792: return noErr;
1793: }
1794:
1795:
1796:
1797: //
1798: // FastUnicodeCompare - Compare two Unicode strings; produce a relative ordering
1799: //
1800: // IF RESULT
1801: // --------------------------
1802: // str1 < str2 => -1
1803: // str1 = str2 => 0
1804: // str1 > str2 => +1
1805: //
1806: // The lower case table starts with 256 entries (one for each of the upper bytes
1807: // of the original Unicode char). If that entry is zero, then all characters with
1808: // that upper byte are already case folded. If the entry is non-zero, then it is
1809: // the _index_ (not byte offset) of the start of the sub-table for the characters
1810: // with that upper byte. All ignorable characters are folded to the value zero.
1811: //
1812: // In pseudocode:
1813: //
1814: // Let c = source Unicode character
1815: // Let table[] = lower case table
1816: //
1817: // lower = table[highbyte(c)]
1818: // if (lower == 0)
1819: // lower = c
1820: // else
1821: // lower = table[lower+lowbyte(c)]
1822: //
1823: // if (lower == 0)
1824: // ignore this character
1825: //
1826: // To handle ignorable characters, we now need a loop to find the next valid character.
1827: // Also, we can't pre-compute the number of characters to compare; the string length might
1828: // be larger than the number of non-ignorable characters. Further, we must be able to handle
1829: // ignorable characters at any point in the string, including as the first or last characters.
1830: // We use a zero value as a sentinel to detect both end-of-string and ignorable characters.
1831: // Since the File Manager doesn't prevent the NUL character (value zero) as part of a filename,
1832: // the case mapping table is assumed to map u+0000 to some non-zero value (like 0xFFFF, which is
1833: // an invalid Unicode character).
1834: //
1835: // Pseudocode:
1836: //
1837: // while (1) {
1838: // c1 = GetNextValidChar(str1) // returns zero if at end of string
1839: // c2 = GetNextValidChar(str2)
1840: //
1841: // if (c1 != c2) break // found a difference
1842: //
1843: // if (c1 == 0) // reached end of string on both strings at once?
1844: // return 0; // yes, so strings are equal
1845: // }
1846: //
1847: // // When we get here, c1 != c2. So, we just need to determine which one is less.
1848: // if (c1 < c2)
1849: // return -1;
1850: // else
1851: // return 1;
1852: //
1853:
1854: #if TARGET_OS_MAC
1855: extern void gLowerCaseTable(void); // Really an exported data symbol, a table
1856: #else
1857: extern UInt16 gLowerCaseTable[];
1858: #endif
1859:
1860: SInt32 FastUnicodeCompare ( register ConstUniCharArrayPtr str1, register ItemCount length1,
1861: register ConstUniCharArrayPtr str2, register ItemCount length2)
1862: {
1863: register UInt16 c1,c2;
1864: register UInt16 temp;
1865: register UInt16* lowerCaseTable;
1866:
1867: #if ( FORDISKFIRSTAID || USE_TABLE_ACCESSORS)
1868: lowerCaseTable = Get_gLowerCaseTable();
1869: #else
1870: lowerCaseTable = (UInt16*) gLowerCaseTable;
1871: #endif
1872:
1873: while (1) {
1874: // Set default values for c1, c2 in case there are no more valid chars
1875: c1 = 0;
1876: c2 = 0;
1877:
1878: // Find next non-ignorable char from str1, or zero if no more
1879: while (length1 && c1 == 0) {
1880: c1 = *(str1++);
1881: --length1;
1882: if ((temp = lowerCaseTable[c1>>8]) != 0) // is there a subtable for this upper byte?
1883: c1 = lowerCaseTable[temp + (c1 & 0x00FF)]; // yes, so fold the char
1884: }
1885:
1886:
1887: // Find next non-ignorable char from str2, or zero if no more
1888: while (length2 && c2 == 0) {
1889: c2 = *(str2++);
1890: --length2;
1891: if ((temp = lowerCaseTable[c2>>8]) != 0) // is there a subtable for this upper byte?
1892: c2 = lowerCaseTable[temp + (c2 & 0x00FF)]; // yes, so fold the char
1893: }
1894:
1895: if (c1 != c2) // found a difference, so stop looping
1896: break;
1897:
1898: if (c1 == 0) // did we reach the end of both strings at the same time?
1899: return 0; // yes, so strings are equal
1900: }
1901:
1902: if (c1 < c2)
1903: return -1;
1904: else
1905: return 1;
1906: }
1907:
1908:
1909: OSErr
1910: ConvertUTF8ToUnicode(ByteCount srcLen, const unsigned char* srcStr, ByteCount maxDstLen,
1911: ByteCount *actualDstLen, UniCharArrayPtr dstStr)
1912: {
1913: ConversionResult result;
1914: UTF8* sourceStart;
1915: UTF8* sourceEnd;
1916: UTF16* targetStart;
1917: UTF16* targetEnd;
1918:
1919: sourceStart = (UTF8*) srcStr;
1920: sourceEnd = sourceStart + srcLen;
1921: targetStart = (UTF16*) dstStr;
1922: targetEnd = targetStart + maxDstLen/2;
1923:
1924: result = ConvertUTF8toUTF16 (&sourceStart, sourceEnd, &targetStart, targetEnd);
1925:
1926: *actualDstLen = (targetStart - dstStr) * sizeof(UniChar);
1927:
1928: if (result == targetExhausted)
1929: return kTECOutputBufferFullStatus;
1930: else if (result == sourceExhausted)
1931: return kTextMalformedInputErr;
1932:
1933: return noErr;
1934: }
1935:
1936:
1937: OSErr
1938: ConvertUnicodeToUTF8(ByteCount srcLen, ConstUniCharArrayPtr srcStr, ByteCount maxDstLen,
1939: ByteCount *actualDstLen, unsigned char* dstStr)
1940: {
1941: ConversionResult result;
1942: UTF16* sourceStart;
1943: UTF16* sourceEnd;
1944: UTF8* targetStart;
1945: UTF8* targetEnd;
1946: ByteCount outputLength;
1947:
1948: sourceStart = (UTF16*) srcStr;
1949: sourceEnd = (UTF16*) ((char*) srcStr + srcLen);
1950: targetStart = (UTF8*) dstStr;
1951: targetEnd = targetStart + maxDstLen;
1952:
1953: result = ConvertUTF16toUTF8 (&sourceStart, sourceEnd, &targetStart, targetEnd);
1954:
1955: *actualDstLen = outputLength = targetStart - dstStr;
1956:
1957: if (result == targetExhausted)
1958: return kTECOutputBufferFullStatus;
1959: else if (result == sourceExhausted)
1960: return kTECPartialCharErr;
1961:
1962: if (outputLength >= maxDstLen)
1963: return kTECOutputBufferFullStatus;
1964:
1965: dstStr[outputLength] = 0; /* also add null termination */
1966:
1967: return noErr;
1968: }
1969:
1970:
1971: OSErr
1972: ConvertUTF8ToMacRoman(ByteCount srcLen, const unsigned char* srcStr, Str31 dstStr)
1973: {
1974: UniChar uniStr[64];
1975: ByteCount uniLen;
1976: OSErr result;
1977:
1978: result = ConvertUTF8ToUnicode(srcLen, srcStr, sizeof(uniStr), &uniLen, uniStr);
1979: if (result == 0)
1980: result = UnicodeToMacRoman(uniLen / sizeof(UniChar), uniStr, dstStr);
1981:
1982: return result;
1983: }
1984:
1985:
1986: OSErr
1987: ConvertMacRomanToUTF8(Str31 srcStr, ByteCount maxDstLen, ByteCount *actualDstLen,
1988: unsigned char* dstStr)
1989: {
1990: UniChar uniStr[64];
1991: ItemCount unicodeChars;
1992: OSErr result;
1993:
1994: result = MacRomanToUnicode(srcStr, &unicodeChars, uniStr);
1995:
1996: if (result == 0)
1997: result = ConvertUnicodeToUTF8(unicodeChars * sizeof(UniChar), uniStr,
1998: maxDstLen, actualDstLen, dstStr);
1999: return result;
2000: }
2001:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.