自学教程：C++ CFStringGetCharacters函数代码示例

CFComparisonResultCFStringCompareWithOptionsAndLocale (CFStringRef str1,  CFStringRef str2, CFRange rangeToCompare,  CFStringCompareFlags compareOptions, CFLocaleRef locale){  CFComparisonResult ret;  UniChar *string1;  UniChar *string2;  CFIndex length1;  CFIndex length2;  CFAllocatorRef alloc;  UCollator *ucol;    alloc = CFAllocatorGetDefault ();    length1 = rangeToCompare.length;  string1 = CFAllocatorAllocate (alloc, (length1) * sizeof(UniChar), 0);  CFStringGetCharacters (str1, rangeToCompare, string1);    length2 = CFStringGetLength (str2);  string2 = CFAllocatorAllocate (alloc, (length2) * sizeof(UniChar), 0);  CFStringGetCharacters (str2, CFRangeMake(0, length2), string2);    ucol = CFStringICUCollatorOpen (compareOptions, locale);  ret = ucol_strcoll (ucol, string2, length2, string1, length1);  CFStringICUCollatorClose (ucol);    CFAllocatorDeallocate (alloc, string1);  CFAllocatorDeallocate (alloc, string2);  return ret;}

CF_PRIVATE UCalendar *__CFCalendarCreateUCalendar(CFStringRef calendarID, CFStringRef localeID, CFTimeZoneRef tz) {    if (calendarID) {	CFDictionaryRef components = CFLocaleCreateComponentsFromLocaleIdentifier(kCFAllocatorSystemDefault, localeID);	CFMutableDictionaryRef mcomponents = CFDictionaryCreateMutableCopy(kCFAllocatorSystemDefault, 0, components);	CFDictionarySetValue(mcomponents, kCFLocaleCalendarIdentifier, calendarID);	localeID = CFLocaleCreateLocaleIdentifierFromComponents(kCFAllocatorSystemDefault, mcomponents);	CFRelease(mcomponents);	CFRelease(components);    }    char buffer[BUFFER_SIZE];    const char *cstr = CFStringGetCStringPtr(localeID, kCFStringEncodingASCII);    if (NULL == cstr) {	if (CFStringGetCString(localeID, buffer, BUFFER_SIZE, kCFStringEncodingASCII)) cstr = buffer;    }    if (NULL == cstr) {	if (calendarID) CFRelease(localeID);	return NULL;    }        UChar ubuffer[BUFFER_SIZE];    CFStringRef tznam = CFTimeZoneGetName(tz);    CFIndex cnt = CFStringGetLength(tznam);    if (BUFFER_SIZE < cnt) cnt = BUFFER_SIZE;    CFStringGetCharacters(tznam, CFRangeMake(0, cnt), (UniChar *)ubuffer);    UErrorCode status = U_ZERO_ERROR;    UCalendar *cal = ucal_open(ubuffer, cnt, cstr, UCAL_DEFAULT, &status);    if (calendarID) CFRelease(localeID);    return cal;}

/************************************************************************** *              debugstr_cf */const char* debugstr_cf(CFTypeRef t){    CFStringRef s;    const char* ret;    if (!t) return "(null)";    if (CFGetTypeID(t) == CFStringGetTypeID())        s = t;    else        s = CFCopyDescription(t);    ret = CFStringGetCStringPtr(s, kCFStringEncodingUTF8);    if (ret) ret = debugstr_a(ret);    if (!ret)    {        const UniChar* u = CFStringGetCharactersPtr(s);        if (u)            ret = debugstr_wn((const WCHAR*)u, CFStringGetLength(s));    }    if (!ret)    {        UniChar buf[200];        int len = min(CFStringGetLength(s), sizeof(buf)/sizeof(buf[0]));        CFStringGetCharacters(s, CFRangeMake(0, len), buf);        ret = debugstr_wn(buf, len);    }    if (s != t) CFRelease(s);    return ret;}

static jstring getJString(JNIEnv *env, CFStringRef cs) {    if (cs == NULL) return NULL;    CFRange range = CFRangeMake(0, CFStringGetLength(cs));    UniChar *chars = alloca(range.length);    CFStringGetCharacters(cs, range, chars);    return (*env)->NewString(env, (jchar *) chars, (jsize) range.length);}

void ARRAY_TEXT::convertFromUTF8(const CUTF8String* fromString, CUTF16String* toString)	{#ifdef _WIN32	int len = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)fromString->c_str(), fromString->length(), NULL, 0);		if(len){		std::vector<uint8_t> buf((len + 1) * sizeof(PA_Unichar));		if(MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)fromString->c_str(), fromString->length(), (LPWSTR)&buf[0], len)){			*toString = CUTF16String((const PA_Unichar *)&buf[0]);		}    }else{			*toString = CUTF16String((const PA_Unichar *)L"");	}           #else           CFStringRef str = CFStringCreateWithBytes(kCFAllocatorDefault, fromString->c_str(), fromString->length(), kCFStringEncodingUTF8, true);           if(str){               int len = CFStringGetLength(str)+1;               std::vector<uint8_t> buf(len * sizeof(PA_Unichar));               CFStringGetCharacters(str, CFRangeMake(0, len), (UniChar *)&buf[0]);               *toString = CUTF16String((const PA_Unichar *)&buf[0]);               CFRelease(str);           }#endif	}

static void callback(        ConstFSEventStreamRef streamRef,        void *clientCallBackInfo,        size_t numEvents,        void *eventPathsVoid,        const FSEventStreamEventFlags eventFlags[],        const FSEventStreamEventId eventIds[]){    qDebug() << "FolderWatcherPrivate::callback by OS X";    QStringList paths;    CFArrayRef eventPaths = (CFArrayRef)eventPathsVoid;    for (int i = 0; i < numEvents; ++i) {        CFStringRef path = reinterpret_cast<CFStringRef>(CFArrayGetValueAtIndex(eventPaths, i));        QString qstring;        CFIndex pathLength = CFStringGetLength(path);        qstring.resize(pathLength);        CFStringGetCharacters(path, CFRangeMake(0, pathLength), reinterpret_cast<UniChar *>(qstring.data()));        paths.append(qstring);    }    reinterpret_cast<FolderWatcherPrivate*>(clientCallBackInfo)->doNotifyParent(paths);}

static OSStatus FindSNESFolder (FSRef *folderRef, char *folderPath, const char *folderName){	OSStatus	err;	CFURLRef	burl, purl;	CFStringRef	fstr;	FSRef		pref;	UniChar		buffer[PATH_MAX + 1];	Boolean		r;	fstr = CFStringCreateWithCString(kCFAllocatorDefault, folderName, CFStringGetSystemEncoding());	CFStringGetCharacters(fstr, CFRangeMake(0, CFStringGetLength(fstr)), buffer);	burl = CFBundleCopyBundleURL(CFBundleGetMainBundle());	purl = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, burl);	r    = CFURLGetFSRef(purl, &pref);	err = FSMakeFSRefUnicode(&pref, CFStringGetLength(fstr), buffer, kTextEncodingUnicodeDefault, folderRef);	if (err == dirNFErr || err == fnfErr)	{		err = FSCreateDirectoryUnicode(&pref, CFStringGetLength(fstr), buffer, kFSCatInfoNone, NULL, folderRef, NULL, NULL);		if (err == noErr)			AddFolderIcon(folderRef, folderName);	}	if (err == noErr)		err = FSRefMakePath(folderRef, (unsigned char *) folderPath, PATH_MAX);	CFRelease(purl);	CFRelease(burl);	CFRelease(fstr);	return (err);}

jstring createJavaString(JNIEnv *env, CFStringRef stringRef){    CFIndex length = CFStringGetLength(stringRef);    UniChar buffer[length];    CFStringGetCharacters(stringRef, CFRangeMake(0, length), buffer);    return (*env)->NewString(env, (jchar *)buffer, length);}

static const wxUint16* GetEncTable(wxFontEncoding enc){#ifdef __WXMAC__    if( enc >= wxFONTENCODING_MACMIN && enc <= wxFONTENCODING_MACMAX )    {        int i = enc-wxFONTENCODING_MACMIN ;        if ( gMacEncodingsInited[i] == false )        {            // create            CFStringEncoding cfencoding = wxMacGetSystemEncFromFontEnc( enc ) ;            if( !CFStringIsEncodingAvailable( cfencoding ) )                return NULL;            memset( gMacEncodings[i] , 0 , 128 * 2 );            char s[2] = { 0 , 0 };            CFRange firstchar = CFRangeMake( 0, 1 );            for( unsigned char c = 255 ; c >= 128 ; --c )            {                s[0] = c ;                wxCFStringRef cfref( CFStringCreateWithCStringNoCopy( NULL, s, cfencoding , kCFAllocatorNull ) );                CFStringGetCharacters( cfref, firstchar, (UniChar*)  &gMacEncodings[i][c-128] );            }            gMacEncodingsInited[i]=true;        }        return gMacEncodings[i] ;    }#endif    for (int i = 0; encodings_list[i].table != NULL; i++)    {        if (encodings_list[i].encoding == enc)            return encodings_list[i].table;    }    return NULL;}

static bool __CFLocaleICUCurrencyName(const char *locale, const char *value, UCurrNameStyle style, CFStringRef *out) {    size_t valLen = strlen(value);    if (valLen != 3) // not a valid ISO code        return false;    UChar curr[4];    UBool isChoice = FALSE;    int32_t size = 0;    UErrorCode icuStatus = U_ZERO_ERROR;    u_charsToUChars(value, curr, (int32_t)valLen);    curr[valLen] = '/0';    const UChar *name;    name = ucurr_getName(curr, locale, style, &isChoice, &size, &icuStatus);    if (U_FAILURE(icuStatus) || icuStatus == U_USING_DEFAULT_WARNING)        return false;    UChar result[kMaxICUNameSize];    if (isChoice)    {        UChar pattern[kMaxICUNameSize];        CFStringRef patternRef = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("{0,choice,%S}"), name);        CFIndex pattlen = CFStringGetLength(patternRef);        CFStringGetCharacters(patternRef, CFRangeMake(0, pattlen), (UniChar *)pattern);        CFRelease(patternRef);        pattern[pattlen] = '/0';        // null terminate the pattern        // Format the message assuming a large amount of the currency        size = u_formatMessage("en_US", pattern, pattlen, result, kMaxICUNameSize, &icuStatus, 10.0);        if (U_FAILURE(icuStatus))            return false;        name = result;            }    *out = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, (UniChar *)name, size);    return (*out != NULL);}

//-------------------------------------------------------------------------------------------------//	GetVisualName//-------------------------------------------------------------------------------------------------//void GetVisualName( ITUniStr255 name ){	CFIndex length = CFStringGetLength( kTVisualPluginName );    	name[0] = (UniChar)length;	CFStringGetCharacters( kTVisualPluginName, CFRangeMake( 0, length ), &name[1] );}

// Sets up the text based on the specified CFString//void UpdateATSUIStuffString(CFStringRef string){    free(gText);    gLength = CFStringGetLength(string);    gText = (UniChar *)malloc(gLength * sizeof(UniChar));    CFStringGetCharacters(string, CFRangeMake(0, gLength), gText);}

static void assertEqualsAsCharactersPtr(JSValueRef value, const char* expectedValue){    JSStringRef valueAsString = JSValueToStringCopy(context, value, NULL);    size_t jsLength = JSStringGetLength(valueAsString);    const JSChar* jsBuffer = JSStringGetCharactersPtr(valueAsString);    CFStringRef expectedValueAsCFString = CFStringCreateWithCString(kCFAllocatorDefault,                                                                     expectedValue,                                                                    kCFStringEncodingUTF8);        CFIndex cfLength = CFStringGetLength(expectedValueAsCFString);    UniChar* cfBuffer = (UniChar*)malloc(cfLength * sizeof(UniChar));    CFStringGetCharacters(expectedValueAsCFString, CFRangeMake(0, cfLength), cfBuffer);    CFRelease(expectedValueAsCFString);    if (memcmp(jsBuffer, cfBuffer, cfLength * sizeof(UniChar)) != 0) {        fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsBuffer != cfBuffer/n");        failed = 1;    }        if (jsLength != (size_t)cfLength) {        fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsLength(%ld) != cfLength(%ld)/n", jsLength, cfLength);        failed = 1;    }    free(cfBuffer);    JSStringRelease(valueAsString);}

/*********************************************************************	 MoveFile*		 lpFromFileName: old file path*		 lpToFileName: new file path********************************************************************/BOOL MoveFile(const char * lpFromFileName, const char * lpToFileName){	OSErr theErr;	FSRef fromFileRef;	FSRef toFileRef;	FSRef parentFolderRef;		// Get the path to the old file	theErr = FSPathMakeRef((const UInt8 *)lpFromFileName, &fromFileRef, NULL);	if (theErr != noErr)	{		SetLastError(theErr);		return false;	}		// Get the path to the new folder for the file	char folderName[strlen(lpToFileName)];	CFStringRef folderPathCFString = CFStringCreateWithCString(NULL, lpToFileName, kCFStringEncodingUTF8);	CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, folderPathCFString, kCFURLPOSIXPathStyle, FALSE);	CFURLRef folderURL = CFURLCreateCopyDeletingLastPathComponent(NULL, fileURL);	CFURLGetFileSystemRepresentation(folderURL, TRUE, (UInt8 *)folderName, strlen(lpToFileName));	theErr = FSPathMakeRef((UInt8 *)folderName, &parentFolderRef, NULL);	CFRelease(fileURL);	CFRelease(folderURL);	CFRelease(folderPathCFString);		// Move the old file	theErr = FSMoveObject(&fromFileRef, &parentFolderRef, &toFileRef);	if (theErr != noErr)	{		SetLastError(theErr);		return false;	}		// Get a CFString for the new file name	CFStringRef newFileNameCFString = CFStringCreateWithCString(NULL, lpToFileName, kCFStringEncodingUTF8);	fileURL = CFURLCreateWithFileSystemPath(NULL, newFileNameCFString, kCFURLPOSIXPathStyle, FALSE);	CFRelease(newFileNameCFString);	newFileNameCFString = CFURLCopyLastPathComponent(fileURL);	CFRelease(fileURL);		// Convert CFString to Unicode and rename the file	UniChar unicodeFileName[256];	CFStringGetCharacters(newFileNameCFString, CFRangeMake(0, CFStringGetLength(newFileNameCFString)), 						  unicodeFileName);	theErr = FSRenameUnicode(&toFileRef, CFStringGetLength(newFileNameCFString), unicodeFileName, 							 kTextEncodingUnknown, NULL);	if (theErr != noErr)	{		SetLastError(theErr);		CFRelease(newFileNameCFString);		return false;	}		CFRelease(newFileNameCFString);		SetLastError(theErr);	return true;}

static QString q_toString(const CFStringRef &str){    CFIndex length = CFStringGetLength(str);    QVarLengthArray<UniChar> buffer(length);    CFRange range = { 0, length };    CFStringGetCharacters(str, range, buffer.data());    return QString(reinterpret_cast<const QChar *>(buffer.data()), length);}

QString convert_CFString_to_QString(CFStringRef str) {	CFIndex length = CFStringGetLength(str);	const UniChar *chars = CFStringGetCharactersPtr(str);	if (chars)		return QString(reinterpret_cast<const QChar *>(chars), length);	QVarLengthArray<UniChar> buffer(length);	CFStringGetCharacters(str, CFRangeMake(0, length), buffer.data());	return QString(reinterpret_cast<const QChar *>(buffer.constData()), length);}

// Given an application bundle reference and the name of an icon file// which is a resource in that bundle, look up the full (posix style)// path to that icon. Returns the path, or an empty wxString on failurewxString GetPathForIconFile( CFBundleRef bundle, CFStringRef iconFile ){    // If either parameter is NULL there is no hope of success    if( !bundle || !iconFile )        return wxEmptyString;    // Create a range object representing the whole string    CFRange wholeString;    wholeString.location = 0;    wholeString.length = CFStringGetLength( iconFile );    // Index of the period in the file name for iconFile    UniCharCount periodIndex;    // In order to locate the period delimiting the extension,    // iconFile must be represented as UniChar[]    {        // Allocate a buffer and copy in the iconFile string        UniChar* buffer = new UniChar[ wholeString.length ];        CFStringGetCharacters( iconFile, wholeString, buffer );        // Locate the period character        OSStatus status = LSGetExtensionInfo( wholeString.length, buffer, &periodIndex );        // Deallocate the buffer        delete [] buffer;        // If the period could not be located it will not be possible to get the URL        if( status != noErr || periodIndex == kLSInvalidExtensionIndex )            return wxEmptyString;    }    // Range representing the name part of iconFile    CFRange iconNameRange;    iconNameRange.location = 0;    iconNameRange.length = periodIndex - 1;    // Range representing the extension part of iconFile    CFRange iconExtRange;    iconExtRange.location = periodIndex;    iconExtRange.length = wholeString.length - periodIndex;    // Get the name and extension strings    wxCFStringRef iconName = CFStringCreateWithSubstring( kCFAllocatorDefault, iconFile, iconNameRange );    wxCFStringRef iconExt = CFStringCreateWithSubstring( kCFAllocatorDefault, iconFile, iconExtRange );    // Now it is possible to query the URL for the icon as a resource    wxCFRef< CFURLRef > iconUrl = wxCFRef< CFURLRef >( CFBundleCopyResourceURL( bundle, iconName, iconExt, NULL ) );    if( !iconUrl.get() )        return wxEmptyString;    // All being well, return the icon path    return wxCFStringRef( CFURLCopyFileSystemPath( iconUrl, kCFURLPOSIXPathStyle ) ).AsString();}

wxString wxMacCFStringHolder::AsString(wxFontEncoding encoding){    if ( m_cfs == NULL )        return wxEmptyString ;    Size cflen = CFStringGetLength( m_cfs )  ;    size_t noChars ;    wxChar* buf = NULL ;#if wxUSE_UNICODE#if SIZEOF_WCHAR_T == 2    buf = new wxChar[ cflen + 1 ] ;    CFStringGetCharacters( m_cfs , CFRangeMake( 0 , cflen ) , (UniChar*) buf ) ;    noChars = cflen ;#else    UniChar* unibuf = new UniChar[ cflen + 1 ] ;    CFStringGetCharacters( m_cfs , CFRangeMake( 0 , cflen ) , (UniChar*) unibuf ) ;    unibuf[cflen] = 0 ;    wxMBConvUTF16 converter ;    noChars = converter.MB2WC( NULL , (const char*)unibuf , 0 ) ;    wxASSERT_MSG( noChars != wxCONV_FAILED, _T("Unable to count the number of characters in this string!") );    buf = new wxChar[ noChars + 1 ] ;    noChars = converter.MB2WC( buf , (const char*)unibuf , noChars + 1 ) ;    wxASSERT_MSG( noChars != wxCONV_FAILED, _T("Conversion of string failed!") );    delete[] unibuf ;#endif#else    CFIndex cStrLen ;    CFStringGetBytes( m_cfs , CFRangeMake(0, cflen) , wxMacGetSystemEncFromFontEnc( encoding ) ,        '?' , false , NULL , 0 , &cStrLen ) ;    buf = new wxChar[ cStrLen + 1 ] ;    CFStringGetBytes( m_cfs , CFRangeMake(0, cflen) , wxMacGetSystemEncFromFontEnc( encoding ) ,        '?' , false , (unsigned char*) buf , cStrLen , &cStrLen) ;    noChars = cStrLen ;#endif    buf[noChars] = 0 ;    wxMacConvertNewlines10To13( buf ) ;    wxString result(buf) ;    delete[] buf ;    return result ;}

// Creates the ATSUI data//void SetUpATSUIStuff(void){        CFStringRef	string = CFSTR("Hello World!");    verify_noerr( ATSUCreateStyle(&gStyle) );    UpdateATSUIStyle();        gLength = CFStringGetLength(string);    gText = (UniChar *)malloc(gLength * sizeof(UniChar));    CFStringGetCharacters(string, CFRangeMake(0, gLength), gText);}

/******************************************************* MyValidationProc(theControl)** Purpose:  called when a key filter can't be: after cut, paste, etc** Inputs:   theControl          - the control to validate** Returns:  none*/static pascal void MyValidationProc(ControlRef theControl)	{	OSStatus status;	CFStringRef theCFString = NULL;	UniChar *buffer = NULL;	// Getting the text content of the control	status = GetControlData(theControl, kControlEntireControl, kControlEditTextCFStringTag, sizeof(theCFString), &theCFString, NULL);	require_noerr(status, ExitValidation);	require(theCFString != NULL, ExitValidation);		CFIndex i, j, len = CFStringGetLength(theCFString);	if (len == 0) goto ExitValidation; // there's nothing to validate		// Grabbing the characters as Unicode chars	buffer = (UniChar *)malloc(len * sizeof(UniChar));	require(buffer != NULL, ExitValidation);		// Checking to see if we have only digits	CFStringGetCharacters(theCFString, CFRangeMake(0, len), buffer);	Boolean ok = true;	for (i = 0; (i < len) && ok; i++)		ok = (buffer[i] >= '0') && (buffer[i] <= '9');		if (!ok)		{		// if not, we remove the offending characters		// we also make sure that we restore the insertion point to the correct location.		ControlEditTextSelectionRec textSelection;		status = GetControlData(theControl, kControlEntireControl, kControlEditTextSelectionTag, sizeof(textSelection), &textSelection, NULL);		require_noerr(status, ExitValidation);		for (i = 0, j = 0; i < len; i++)			if ((buffer[i] >= '0') && (buffer[i] <= '9')) buffer[j++] = buffer[i];		CFRelease(theCFString);		theCFString = CFStringCreateWithCharacters(NULL, buffer, j);		require(theCFString != NULL, ExitValidation);				status = SetControlData(theControl, kControlEntireControl, kControlEditTextCFStringTag, sizeof(theCFString), &theCFString);		require_noerr(status, ExitValidation);				textSelection.selEnd -= (len - j); textSelection.selStart = textSelection.selEnd;		status = SetControlData(theControl, kControlEntireControl, kControlEditTextSelectionTag, sizeof(textSelection), &textSelection);		require_noerr(status, ExitValidation);		}ExitValidation:	if (buffer != NULL) free(buffer);	if (theCFString != NULL) CFRelease(theCFString);		return;	}   // MyValidationProc

void ConsoleMessage::execute(){    if (theSession) {        jsize len = ::CFStringGetLength(mMessage);        jchar* buffer = new jchar[len];        CFRange range = { 0, len };        CFStringGetCharacters(mMessage, range, buffer);        System_out_print(theSession->getCurrentEnv(), buffer, len);        delete[] buffer;    }}

static void CopyUTF8toUTF16NFC(const nsACString& aSrc, nsAString& aResult){    static PRBool sChecked = PR_FALSE;    static UnicodeNormalizer sUnicodeNormalizer = NULL;    // CFStringNormalize was not introduced until Mac OS 10.2    if (!sChecked) {        CFBundleRef carbonBundle =            CFBundleGetBundleWithIdentifier(CFSTR("com.apple.Carbon"));        if (carbonBundle)            sUnicodeNormalizer = (UnicodeNormalizer)                ::CFBundleGetFunctionPointerForName(carbonBundle,                                                    CFSTR("CFStringNormalize"));        sChecked = PR_TRUE;    }    if (!sUnicodeNormalizer) {  // OS X 10.1 or earlier        CopyUTF8toUTF16(aSrc, aResult);        return;      }    const nsAFlatCString &inFlatSrc = PromiseFlatCString(aSrc);    // The number of 16bit code units in a UTF-16 string will never be    // larger than the number of bytes in the corresponding UTF-8 string.    CFMutableStringRef inStr =        ::CFStringCreateMutable(NULL, inFlatSrc.Length());    if (!inStr) {        CopyUTF8toUTF16(aSrc, aResult);        return;      }         ::CFStringAppendCString(inStr, inFlatSrc.get(), kCFStringEncodingUTF8);     sUnicodeNormalizer(inStr, kCFStringNormalizationFormC);    CFIndex length = CFStringGetLength(inStr);    const UniChar* chars = CFStringGetCharactersPtr(inStr);    if (chars)         aResult.Assign(chars, length);    else {        nsAutoTArray<UniChar, 512> buffer;        if (buffer.SetLength(length)) {            CFStringGetCharacters(inStr, CFRangeMake(0, length), buffer.Elements());            aResult.Assign(buffer.Elements(), length);        }        else             CopyUTF8toUTF16(aSrc, aResult);    }    CFRelease(inStr);}

int dir_Create(char *pathString, int pathStringLength) {	/* Create a new directory with the given path. By default, this	   directory is created in the current directory. Use	   a full path name such as "MyDisk:Working:New Folder" to	   create folders elsewhere. */    char cFileName[1001];    if (pathStringLength >= 1000) {        return false;    }    /* copy the file name into a null-terminated C string */    sqFilenameFromString((char *) cFileName, (int) pathString, pathStringLength);    #if defined(__MWERKS__)	{        CFStringRef 	filePath,lastFilePath;        CFURLRef 	    sillyThing,sillyThing2;        FSRef	        parentFSRef;        UniChar         buffer[1024];        long            tokenLength;		int err;                filePath   = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)cFileName,strlen(cFileName),gCurrentVMEncoding,false);        if (filePath == nil)             return false;        sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLHFSPathStyle,true);        CFRelease(filePath);        lastFilePath = CFURLCopyLastPathComponent(sillyThing);        tokenLength = CFStringGetLength(lastFilePath);        if (tokenLength > 1024)            return false;        CFStringGetCharacters(lastFilePath,CFRangeMake(0,tokenLength),buffer);        CFRelease(lastFilePath);        sillyThing2 = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault,sillyThing);        err = CFURLGetFSRef(sillyThing2,&parentFSRef);        CFRelease(sillyThing);        CFRelease(sillyThing2);        if (err == 0) {            return false;          }		err = FSCreateDirectoryUnicode(&parentFSRef,tokenLength,buffer,kFSCatInfoNone,NULL,NULL,NULL,NULL);		    	return (err == noErr ? 1 : 0);    }#else    return mkdir(cFileName, 0777) == 0;#endif}

rktio_char16_t *rktio_recase_utf16(rktio_t *rktio, rktio_bool_t to_up, rktio_char16_t *s1, intptr_t l1, intptr_t *olen){#ifdef MACOS_UNICODE_SUPPORT  CFMutableStringRef mstr;  CFStringRef str;  CFRange rng;  rktio_char16_t *result;  intptr_t len;  str = CFStringCreateWithBytes(NULL, (unsigned char *)s1, (l1 * sizeof(rktio_char16_t)), kCFStringEncodingUnicode, FALSE);  mstr = CFStringCreateMutableCopy(NULL, 0, str);  CFRelease(str);  if (to_up)    CFStringUppercase(mstr, NULL);  else    CFStringLowercase(mstr, NULL);  len = CFStringGetLength(mstr);  result = malloc((len + 1) * sizeof(rktio_char16_t));  rng = CFRangeMake(0, len);  CFStringGetCharacters(mstr, rng, (UniChar *)result);  CFRelease(mstr);  result[len] = 0;  if (olen)    *olen = len;  return result;#elif defined(RKTIO_SYSTEM_WINDOWS)  rktio_char16_t *result;    result = malloc((l1 + 1) * sizeof(rktio_char16_t));  memcpy(result, s1, l1 * sizeof(rktio_char16_t));  result[l1] = 0;    if (to_up)    CharUpperBuffW((wchar_t *)result, l1);  else    CharLowerBuffW((wchar_t *)result, l1);  if (olen)    *olen = l1;  return result;#else  return NULL;#endif}

extern int utf8_decodestr(const u_int8_t * utf8p, size_t utf8len, u_int16_t *ucsp, size_t *ucslen,        size_t buflen, u_int16_t altslash, int flags){    int         err;    CFStringRef str;    CFIndex     utf16Count;        assert(utf8p != NULL);    assert(ucsp != NULL);    assert(ucslen != NULL);    assert(altslash == 0);    assert(flags == UTF_PRECOMPOSED);    err = 0;    str = CFStringCreateWithBytes(NULL, utf8p, utf8len, kCFStringEncodingUTF8, false);    if (str == NULL) {        err = EINVAL;    }        if (err == 0) {        CFMutableStringRef  tmpStr;                tmpStr = CFStringCreateMutableCopy(NULL, 0, str);        if (tmpStr != NULL) {            CFStringNormalize(tmpStr, kCFStringNormalizationFormC);                        // Swap tmpStr into str.                        CFRelease(str);            str = tmpStr;        }    }        if (err == 0) {        utf16Count = CFStringGetLength(str);                if (utf16Count > (buflen / 2)) {            utf16Count = (buflen / 2);            err = ENAMETOOLONG;        }                CFStringGetCharacters(str, CFRangeMake(0, utf16Count), ucsp);                *ucslen = utf16Count * sizeof(uint16_t);    }        if (str != NULL) {        CFRelease(str);    }    return err;}

QString CFStringToQString(CFStringRef str) {    if (!str)        return QString();    CFIndex length = CFStringGetLength(str);    if (length == 0)        return QString();    QString string(length, Qt::Uninitialized);    CFStringGetCharacters(str, CFRangeMake(0, length), reinterpret_cast<UniChar *>        (const_cast<QChar *>(string.unicode())));    return string;}

QString QCFStringToQString(CFStringRef str){    if(!str)        return QString();    CFIndex length = CFStringGetLength(str);    const UniChar *chars = CFStringGetCharactersPtr(str);    if (chars)        return QString(reinterpret_cast<const QChar *>(chars), length);    QVector<UniChar> buffer(length);    CFStringGetCharacters(str, CFRangeMake(0, length), buffer.data());    return QString(reinterpret_cast<const QChar *>(buffer.constData()), length);}

// this is a Qt implementation I foundQString cfstring2qstring(CFStringRef str){    if(!str)        return QString();        CFIndex length = CFStringGetLength(str);    if(const UniChar *chars = CFStringGetCharactersPtr(str))        return QString((QChar *)chars, length);    UniChar *buffer = (UniChar*)malloc(length * sizeof(UniChar));    CFStringGetCharacters(str, CFRangeMake(0, length), buffer);    QString ret((QChar *)buffer, length);    free(buffer);    return ret;}

void stringGettingAtCharactersExample(void) {    CFStringRef str;    const UniChar *chars;    show(CFSTR("------------------Character Manipulations---------------"));    // Create some test CFString    str = CFStringCreateWithCString(NULL, "Hello World", kCFStringEncodingASCII);    show(CFSTR("Original String : %@"), str);    // The fastest way to get the contents; this might return NULL though    // depending on the system, the release, etc, so don't depend on it     // (unless you used CFStringCreateMutableWithExternalCharactersNoCopy())    chars = CFStringGetCharactersPtr(str);    // If that fails, you can try copying the UniChars out    // either into some stack buffer or some allocated piece of memory...    // Using the former is fine, but you need to know the size; the latter    // always works but requires allocating some memory; not too efficient.    if (chars == NULL) {        CFIndex length = CFStringGetLength(str);        UniChar *buffer = (UniChar*)malloc(length * sizeof(UniChar));        CFStringGetCharacters(str, CFRangeMake(0, length), buffer);        // Process the chars...        free(buffer);    }    else        show(CFSTR("Characters      : %@"), str);    // You can use CFStringGetCharacterAtIndex() to get at the characters one at a time,    // but doing a lot of characters this way might get slow...    // An option is to use "inline buffer" functionality which mixes the convenience of    // one-at-a-time char access with efficiency of bulk access    {        CFStringInlineBuffer inlineBuffer;        CFIndex length = CFStringGetLength(str);        CFIndex cnt;        CFStringInitInlineBuffer(str, &inlineBuffer, CFRangeMake(0, length));        for (cnt = 0; cnt < length; cnt++) {            UniChar ch = CFStringGetCharacterFromInlineBuffer(&inlineBuffer, cnt);            // Process character...	         (void)ch;   // Dummy processing to prevent compiler warning...        }    }    }