![[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 XNU] / XNU / bsd / hfs / hfscommon / Unicode|
Return to UnicodeWrappers.c CVS log | Up to [Apple XNU] / XNU / bsd / hfs / hfscommon / Unicode |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: File: UnicodeWrappers.c
24:
25: Contains: Wrapper routines for Unicode conversion and comparison.
26:
27: Version: HFS Plus 1.0
28:
29: Written by: Mark Day
30:
31: Copyright: � 1996-1999 by Apple Computer, Inc., all rights reserved.
32:
33: File Ownership:
34:
35: DRI: Mark Day
36:
37: Other Contact: Don Brady
38:
39: Technology: xxx put technology here xxx
40:
41: Writers:
42:
43: (DSH) Deric Horn
44: (msd) Mark Day
45: (djb) Don Brady
46:
47: Change History (most recent first):
48: <MOSXS> 6/10/99 djb Add support for Euro Sign (0x20AC) to MacRoman/Unicode conversions.
49: <MOSXS> 2/09/99 djb Fix UnicodeToMacRoman to handle a terminating decomposed char.
50: <MOSXS> 1/22/99 djb Add more TARGET_OS_MAC conditionals to remove orphaned code.
51: <MOSXS> 7/6/98 djb Handle hi-bit Mac Roman characters in basic latin conversions (radar #2247519).
52: <MOSXS> 6/11/98 PPD Added a few special-case ASCII/Unicode mappings to cover installer's needs.
53:
54: <CS41> 1/28/98 msd Bug 2207446: When mangling a name, check to see if the Unicode
55: Converter is installed before we call it.
56: <CS40> 1/21/98 msd Bug 2206836: If a name contains a colon, change it to question
57: mark and mangle the name.
58: <CS39> 12/11/97 msd For Metrowerks and test tools, call the Get_xxx routines to get
59: the Unicode table addresses.
60: <CS38> 12/10/97 djb Radar #2005461, don't use fallback chars when converting to
61: Unicode, instead let the client (Catalog) retry with MacRoman.
62: <CS37> 12/2/97 DSH Conditionalize out some unicode related routines for DFA
63: <CS36> 11/26/97 djb Radar #2005461,2005688 don't swallow kTECPartialCharErr errors!
64: <CS35> 11/17/97 djb Name mangling was broken with decomposed Unicode.
65: <CS34> 11/16/97 djb Radar #2001928 - use kUnicodeCanonicalDecompVariant variant.
66: <CS33> 11/11/97 DSH Use Get_gLowerCaseTable for DiskFirstAid builds to avoid loading
67: in a branch to the table.
68: <CS32> 11/7/97 msd Replace FastSimpleCompareStrings with FastUnicodeCompare (which
69: handles ignorable Unicode characters). Remove the wrapper
70: routine, CompareUnicodeNames, and have its callers call
71: FastUnicodeCompare directly.
72: <CS31> 10/17/97 djb Change kUnicodeUseHFSPlusMapping to kUnicodeUseLatestMapping.
73: <CS30> 10/17/97 msd Fix some type casts for char pointers.
74: <CS29> 10/13/97 djb Add new SPIs for Finder View font (radar #1679073).
75: <CS28> 10/1/97 djb Preserve current heap zone in InitializeEncodingContext routine
76: (radar #1682686).
77: <CS27> 9/17/97 djb Handle kTECPartialCharErr errors in ConvertHFSNameToUnicode.
78: <CS26> 9/16/97 msd In MockConvertFromPStringToUnicode, use pragma unused instead of
79: commenting out unused parameter (so SC will compile it).
80: <CS25> 9/15/97 djb Fix MockConverters to do either 7-bit ascii or else mangle the
81: name (radar #1672388). Use 'p2u#' resource for bootstrapping
82: Unicode. Make sure InitializeEncodingContext uses System heap.
83: <CS24> 9/10/97 msd Make InitializeEncodingContext public.
84: <CS23> 9/7/97 djb Handle '�' char in BasicLatinUnicode converter.
85: <CS22> 9/4/97 djb Add logging to BasicLatinUnicodeToPascal.
86: <CS21> 8/26/97 djb Make FastSimpleCompareStrings faster. Add
87: BasicLatinUnicodeToPascal to make 7-bit ascii conversions
88: faster.
89: <CS20> 8/14/97 djb Add FastRelString here (to be next to the data tables).
90: <CS19> 7/21/97 djb LogEndTime now takes an error code.
91: <CS18> 7/18/97 msd Include LowMemPriv.h, Gestalt.h, TextUtils.h.
92: <CS17> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name
93: collision
94: <CS16> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line
95: <CS15> 7/8/97 DSH InitializeUnicode changed its API
96: <CS14> 7/1/97 DSH SC, DFA complier, requires parameters in functions. #pragma'd
97: them out to eliminate C warnings.
98: <CS13> 6/30/97 msd Remove unused parameter warnings in FallbackProc by commenting
99: out unused parameter names.
100: <CS12> 6/26/97 DSH FallbackProc declare variables before useage for SC,
101: MockConverters no longer static for DFA.
102: <CS11> 6/25/97 msd In function InitStaticUnicodeConverter, the variable fsVars was
103: being used before being initialized.
104: <CS10> 6/24/97 DSH Runtime checks to call through CFM or static linked routines.
105: <CS9> 6/20/97 msd Re-introduce fix from <CS7>. Fix another missing cast. Remove a
106: spurious semicolon.
107: <CS8> 6/18/97 djb Add more ConversionContexts routines. Improved file mangling.
108: <CS7> 6/16/97 msd Add a missing cast in GetFileIDString.
109: <CS6> 6/13/97 djb Added support for long filenames. Switched to
110: ConvertUnicodeToHFSName, ConvertHFSNameToUnicode, and
111: CompareUnicodeNames.
112: <CS5> 6/4/97 djb Use system script instead of macRoman.
113: <CS4> 5/19/97 djb Add call to LockMappingTable so tables won't move!
114: <CS3> 5/9/97 djb Include HFSInstrumentation.h
115: <CS2> 5/7/97 djb Add summary traces. Add FastSimpleCompareStrings routine.
116: <CS1> 4/24/97 djb first checked in
117: <HFS5> 3/27/97 djb Add calls to real Unicode conversion routines.
118: <HFS4> 2/6/97 msd Add conditional code to use real Unicode comparison routines
119: (default to off).
120: <HFS3> 1/6/97 djb Fix HFSUnicodeCompare - the final comparison of length1 and
121: length2 was backwards.
122: <HFS2> 12/12/96 msd Use precompiled headers.
123: <HFS1> 12/12/96 msd first checked in
124:
125: */
126:
127: #include "../../hfs_macos_defs.h"
128: #include "UCStringCompareData.h"
129:
130: #include "../headers/FileMgrInternal.h"
131: #include "../headers/HFSUnicodeWrappers.h"
132:
133: #include "ConvertUTF.h"
134:
135: enum {
136: kMinFileExtensionChars = 1, // does not include dot
137: kMaxFileExtensionChars = 5 // does not include dot
138: };
139:
140: #define kASCIIPiSymbol 0xB9
141: #define kASCIIMicroSign 0xB5
142: #define kASCIIGreekDelta 0xC6
143:
144:
145: #define Is7BitASCII(c) ( (c) >= 0x20 && (c) <= 0x7F )
146:
147: #define IsSpecialASCIIChar(c) ( (c) == (UInt8) kASCIIMicroSign || (c) == (UInt8) kASCIIPiSymbol || (c) == (UInt8) kASCIIGreekDelta )
148:
149: // Note: '�' has two Unicode representations 0x00B5 (micro sign) and 0x03BC (greek)
150: // '�' has two Unicode representations 0x2206 (increment) and 0x0394 (greek)
151: #define IsSpecialUnicodeChar(c) ( (c) == 0x00B5 || (c) == 0x03BC || (c) == 0x03C0 || (c) == 0x2206 || (c) == 0x0394 )
152:
153: #define IsHexDigit(c) ( ((c) >= (UInt8) '0' && (c) <= (UInt8) '9') || ((c) >= (UInt8) 'A' && (c) <= (UInt8) 'F') )
154:
155:
156: static void GetFilenameExtension( ItemCount length, ConstUniCharArrayPtr unicodeStr, Str15 extStr );
157:
158: static void GetFileIDString( HFSCatalogNodeID fileID, Str15 fileIDStr );
159:
160: static void AppendPascalString( ConstStr15Param src, Str31 dst );
161:
162: static UInt32 HexStringToInteger( UInt32 length, const UInt8 *hexStr );
163:
164:
165:
166: //
167: // Get filename extension (if any) as a pascal string
168: //
169: #if TARGET_API_MAC_OS8
170: static void
171: GetFilenameExtension( ItemCount length, ConstUniCharArrayPtr unicodeStr, Str15 extStr )
172: {
173: UInt32 i;
174: UniChar c;
175: UInt16 extChars; // number of extension characters (excluding the dot)
176: UInt16 maxExtChars;
177: Boolean foundExtension;
178:
179:
180: extStr[0] = (UInt8) 0; // assume there's no extension
181:
182: if ( length < 3 )
183: return; // sorry, "x.y" is smallest possible extension
184:
185: if ( length < (kMaxFileExtensionChars + 2) )
186: maxExtChars = length - 2; // we need at least one prefix character and dot
187: else
188: maxExtChars = kMaxFileExtensionChars;
189:
190: i = length;
191: extChars = 0;
192: foundExtension = false;
193:
194: while ( extChars <= maxExtChars )
195: {
196: c = unicodeStr[--i];
197:
198: if ( c == (UniChar) '.' ) // look for leading dot
199: {
200: if ( extChars > 0 ) // cannot end with a dot
201: foundExtension = true;
202: break;
203: }
204:
205: if ( Is7BitASCII(c) || IsSpecialUnicodeChar(c) )
206: ++extChars;
207: else
208: break;
209: }
210:
211: // if we found one then copy it
212: if ( foundExtension )
213: {
214: UInt8 *extStrPtr = extStr;
215: const UniChar *unicodeStrPtr = &unicodeStr[i]; // point to dot char
216:
217: *(extStrPtr++) = extChars + 1; // set length to extension chars plus dot
218:
219: for ( i = 0; i <= extChars; ++i )
220: {
221: c = *(unicodeStrPtr++);
222:
223: // map any special characters
224: switch (c)
225: {
226: case 0x00B5: // micro sign
227: case 0x03BC: // greek mu
228: c = (UniChar) '�';
229: break;
230:
231: case 0x03C0: // greek pi
232: c = (UniChar) '�';
233: break;
234:
235: case 0x2206: // increment sign
236: case 0x0394: // greek capital delta
237: c = (UniChar) '�';
238: break;
239: }
240:
241: *(extStrPtr++) = (UInt8) c; // copy/convert to ascii
242: }
243: }
244:
245: } // end GetFilenameExtension
246: #endif /* TARGET_API_MAC_OS8 */
247:
248:
249: //
250: // Count filename extension characters (if any)
251: //
252: static UInt32
253: CountFilenameExtensionChars( const unsigned char * filename, UInt32 length )
254: {
255: UInt32 i;
256: UniChar c;
257: UInt32 extChars; // number of extension characters (excluding the dot)
258: UInt16 maxExtChars;
259: Boolean foundExtension;
260:
261:
262: if (length == kUndefinedStrLen)
263: length = strlen(filename);
264:
265: if ( length < 3 )
266: return 0; // sorry, "x.y" is smallest possible extension
267:
268: if ( length < (kMaxFileExtensionChars + 2) )
269: maxExtChars = length - 2; // we need at least on prefix character and dot
270: else
271: maxExtChars = kMaxFileExtensionChars;
272:
273: extChars = 0; // assume there's no extension
274: i = length - 1; // index to last ascii character
275: foundExtension = false;
276:
277: while ( extChars <= maxExtChars )
278: {
279: c = filename[i--];
280:
281: if ( c == (UInt8) '.' ) // look for leading dot
282: {
283: if ( extChars > 0 ) // cannot end with a dot
284: return (extChars);
285:
286: break;
287: }
288:
289: if ( Is7BitASCII(c) || IsSpecialASCIIChar(c) )
290: ++extChars;
291: else
292: break;
293: }
294:
295: return 0;
296:
297: } // end CountFilenameExtensionChars
298:
299:
300: //
301: // Convert file ID into a hexidecimal string with no leading zeros
302: //
303: #if TARGET_API_MAC_OS8
304: static void
305: GetFileIDString( HFSCatalogNodeID fileID, Str15 fileIDStr )
306: {
307: SInt32 i, b;
308: static UInt8 *translate = (UInt8 *) "0123456789ABCDEF";
309: UInt8 c;
310:
311: fileIDStr[1] = '#';
312:
313: for ( i = 1, b = 28; b >= 0; b -= 4 )
314: {
315: c = *(translate + ((fileID >> b) & 0x0000000F));
316:
317: // if its not a leading zero add it to our string
318: if ( (c != (UInt8) '0') || (i > 1) || (b == 0) )
319: fileIDStr[++i] = c;
320: }
321:
322: fileIDStr[0] = (UInt8) i;
323:
324: } // end GetFileIDString
325: #endif /* TARGET_API_MAC_OS8 */
326:
327:
328: //
329: // Append a suffix to a pascal string
330: //
331: #if TARGET_API_MAC_OS8
332: static void
333: AppendPascalString( ConstStr15Param src, Str31 dst )
334: {
335: UInt32 i, j;
336: UInt32 srcLen;
337:
338: srcLen = StrLength(src);
339:
340: if ( (srcLen + StrLength(dst)) > 31 ) // safety net
341: return;
342:
343: i = dst[0] + 1; // get end of dst
344:
345: for (j = 1; j <= srcLen; ++j)
346: dst[i++] = src[j];
347:
348: dst[0] += srcLen;
349:
350: } // end AppendPascalString
351: #endif /* TARGET_API_MAC_OS8 */
352:
353:
354: HFSCatalogNodeID
355: GetEmbeddedFileID(const unsigned char * filename, UInt32 length, UInt32 *prefixLength)
356: {
357: short extChars;
358: short i;
359: UInt8 c; // current character in filename
360:
361: *prefixLength = 0;
362:
363: if ( filename == NULL )
364: return 0;
365:
366: if (length == kUndefinedStrLen)
367: length = strlen(filename);
368:
369: if ( length < 4 )
370: return 0; // too small to have a file ID
371:
372: if ( length >= 6 ) // big enough for a file ID (#10) and an extension (.x) ?
373: extChars = CountFilenameExtensionChars(filename, length);
374: else
375: extChars = 0;
376:
377: if ( extChars > 0 )
378: length -= (extChars + 1); // skip dot plus extension characters
379:
380: // scan for file id digits...
381: for ( i = length - 1; i >= 0; --i)
382: {
383: c = filename[i];
384:
385: if ( c == '#' ) // look for file ID marker
386: {
387: if ( (length - i) < 3 )
388: break; // too small to be a file ID
389:
390: *prefixLength = i;
391: return HexStringToInteger(length - i - 1, &filename[i+1]);
392: }
393:
394: if ( !IsHexDigit(c) )
395: break; // file ID string must have hex digits
396: }
397:
398: return 0;
399:
400: } // end GetEmbeddedFileID
401:
402:
403: //_______________________________________________________________________
404:
405: static UInt32
406: HexStringToInteger (UInt32 length, const UInt8 *hexStr)
407: {
408: UInt32 value; // decimal value represented by the string
409: short i;
410: UInt8 c; // next character in buffer
411: const UInt8 *p; // pointer to character string
412:
413: value = 0;
414: p = hexStr;
415:
416: for ( i = 0; i < length; ++i )
417: {
418: c = *p++;
419:
420: if (c >= '0' && c <= '9')
421: {
422: value = value << 4;
423: value += (UInt32) c - (UInt32) '0';
424: }
425: else if (c >= 'A' && c <= 'F')
426: {
427: value = value << 4;
428: value += 10 + ((unsigned int) c - (unsigned int) 'A');
429: }
430: else
431: {
432: return 0; // oops, how did this character get in here?
433: }
434: }
435:
436: return value;
437:
438: } // end HexStringToInteger
439:
440:
441: //_______________________________________________________________________
442: //
443: // Routine: FastRelString
444: //
445: // Output: returns -1 if str1 < str2
446: // returns 1 if str1 > str2
447: // return 0 if equal
448: //
449: //_______________________________________________________________________
450:
451: extern unsigned short gCompareTable[];
452:
453: SInt32 FastRelString( ConstStr255Param str1, ConstStr255Param str2 )
454: {
455: UInt16* compareTable;
456: SInt32 bestGuess;
457: UInt8 length, length2;
458: UInt8 delta;
459:
460: delta = 0;
461: length = *(str1++);
462: length2 = *(str2++);
463:
464: if (length == length2)
465: bestGuess = 0;
466: else if (length < length2)
467: {
468: bestGuess = -1;
469: delta = length2 - length;
470: }
471: else
472: {
473: bestGuess = 1;
474: length = length2;
475: }
476:
477: compareTable = (UInt16*) gCompareTable;
478:
479: while (length--)
480: {
481: UInt8 aChar, bChar;
482:
483: aChar = *(str1++);
484: bChar = *(str2++);
485:
486: if (aChar != bChar) // If they don't match exacly, do case conversion
487: {
488: UInt16 aSortWord, bSortWord;
489:
490: aSortWord = compareTable[aChar];
491: if (bChar == 0 && delta == 1) {
492: bChar = *(str2++); /* skip over embedded null */
493: bestGuess = 0;
494: }
495: bSortWord = compareTable[bChar];
496:
497: if (aSortWord > bSortWord)
498: return 1;
499:
500: if (aSortWord < bSortWord)
501: return -1;
502: }
503:
504: // If characters match exactly, then go on to next character immediately without
505: // doing any extra work.
506: }
507:
508: // if you got to here, then return bestGuess
509: return bestGuess;
510: }
511:
512:
513:
514: //
515: // FastUnicodeCompare - Compare two Unicode strings; produce a relative ordering
516: //
517: // IF RESULT
518: // --------------------------
519: // str1 < str2 => -1
520: // str1 = str2 => 0
521: // str1 > str2 => +1
522: //
523: // The lower case table starts with 256 entries (one for each of the upper bytes
524: // of the original Unicode char). If that entry is zero, then all characters with
525: // that upper byte are already case folded. If the entry is non-zero, then it is
526: // the _index_ (not byte offset) of the start of the sub-table for the characters
527: // with that upper byte. All ignorable characters are folded to the value zero.
528: //
529: // In pseudocode:
530: //
531: // Let c = source Unicode character
532: // Let table[] = lower case table
533: //
534: // lower = table[highbyte(c)]
535: // if (lower == 0)
536: // lower = c
537: // else
538: // lower = table[lower+lowbyte(c)]
539: //
540: // if (lower == 0)
541: // ignore this character
542: //
543: // To handle ignorable characters, we now need a loop to find the next valid character.
544: // Also, we can't pre-compute the number of characters to compare; the string length might
545: // be larger than the number of non-ignorable characters. Further, we must be able to handle
546: // ignorable characters at any point in the string, including as the first or last characters.
547: // We use a zero value as a sentinel to detect both end-of-string and ignorable characters.
548: // Since the File Manager doesn't prevent the NUL character (value zero) as part of a filename,
549: // the case mapping table is assumed to map u+0000 to some non-zero value (like 0xFFFF, which is
550: // an invalid Unicode character).
551: //
552: // Pseudocode:
553: //
554: // while (1) {
555: // c1 = GetNextValidChar(str1) // returns zero if at end of string
556: // c2 = GetNextValidChar(str2)
557: //
558: // if (c1 != c2) break // found a difference
559: //
560: // if (c1 == 0) // reached end of string on both strings at once?
561: // return 0; // yes, so strings are equal
562: // }
563: //
564: // // When we get here, c1 != c2. So, we just need to determine which one is less.
565: // if (c1 < c2)
566: // return -1;
567: // else
568: // return 1;
569: //
570:
571: extern UInt16 gLowerCaseTable[];
572: extern UInt16 gLatinCaseFold[];
573:
574: SInt32 FastUnicodeCompare ( register ConstUniCharArrayPtr str1, register ItemCount length1,
575: register ConstUniCharArrayPtr str2, register ItemCount length2)
576: {
577: register UInt16 c1,c2;
578: register UInt16 temp;
579: register UInt16* lowerCaseTable;
580:
581: lowerCaseTable = (UInt16*) gLowerCaseTable;
582:
583: while (1) {
584: /* Set default values for c1, c2 in case there are no more valid chars */
585: c1 = 0;
586: c2 = 0;
587:
588: /* Find next non-ignorable char from str1, or zero if no more */
589: while (length1 && c1 == 0) {
590: c1 = *(str1++);
591: --length1;
592: /* check for basic latin first */
593: if (c1 < 0x0100) {
594: c1 = gLatinCaseFold[c1];
595: break;
596: }
597: /* case fold if neccessary */
598: if ((temp = lowerCaseTable[c1>>8]) != 0)
599: c1 = lowerCaseTable[temp + (c1 & 0x00FF)];
600: }
601:
602:
603: /* Find next non-ignorable char from str2, or zero if no more */
604: while (length2 && c2 == 0) {
605: c2 = *(str2++);
606: --length2;
607: /* check for basic latin first */
608: if (c2 < 0x0100) {
609: if ((c2 = gLatinCaseFold[c2]) != 0)
610: break;
611: else
612: continue; /* ignore this character */
613: }
614: /* case fold if neccessary */
615: if ((temp = lowerCaseTable[c2>>8]) != 0)
616: c2 = lowerCaseTable[temp + (c2 & 0x00FF)];
617: }
618:
619: if (c1 != c2) // found a difference, so stop looping
620: break;
621:
622: if (c1 == 0) // did we reach the end of both strings at the same time?
623: return 0; // yes, so strings are equal
624: }
625:
626: if (c1 < c2)
627: return -1;
628: else
629: return 1;
630: }
631:
632:
633: OSErr
634: ConvertUTF8ToUnicode(ByteCount srcLen, const unsigned char* srcStr, ByteCount maxDstLen,
635: ByteCount *actualDstLen, UniCharArrayPtr dstStr)
636: {
637: ConversionResult result;
638: UTF8* sourceStart;
639: UTF8* sourceEnd;
640: UTF16* targetStart;
641: UTF16* targetEnd;
642:
643: sourceStart = (UTF8*) srcStr;
644: sourceEnd = sourceStart + srcLen;
645: targetStart = (UTF16*) dstStr;
646: targetEnd = targetStart + maxDstLen/2;
647:
648: result = ConvertUTF8toUTF16 (&sourceStart, sourceEnd, &targetStart, targetEnd);
649:
650: *actualDstLen = (targetStart - dstStr) * sizeof(UniChar);
651:
652: if (result == targetExhausted)
653: return kTECOutputBufferFullStatus;
654: else if (result == sourceExhausted)
655: return kTextMalformedInputErr;
656:
657: return noErr;
658: }
659:
660:
661: OSErr
662: ConvertUnicodeToUTF8(ByteCount srcLen, ConstUniCharArrayPtr srcStr, ByteCount maxDstLen,
663: ByteCount *actualDstLen, unsigned char* dstStr)
664: {
665: ConversionResult result;
666: UTF16* sourceStart;
667: UTF16* sourceEnd;
668: UTF8* targetStart;
669: UTF8* targetEnd;
670: ByteCount outputLength;
671:
672: sourceStart = (UTF16*) srcStr;
673: sourceEnd = (UTF16*) ((char*) srcStr + srcLen);
674: targetStart = (UTF8*) dstStr;
675: targetEnd = targetStart + maxDstLen;
676:
677: result = ConvertUTF16toUTF8 (&sourceStart, sourceEnd, &targetStart, targetEnd);
678:
679: *actualDstLen = outputLength = targetStart - dstStr;
680:
681: if (result == targetExhausted)
682: return kTECOutputBufferFullStatus;
683: else if (result == sourceExhausted)
684: return kTECPartialCharErr;
685:
686: if (outputLength >= maxDstLen)
687: return kTECOutputBufferFullStatus;
688:
689: dstStr[outputLength] = 0; /* also add null termination */
690:
691: return noErr;
692: }
693:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.