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

std::string GetBinaryPath(){#ifdef linux	std::string path(GetBinaryFile());	size_t pathlength = path.find_last_of('/');	if (pathlength != std::string::npos)		return path.substr(0, pathlength);	else		return path;#elif WIN32	TCHAR currentDir[MAX_PATH+1];	int ret = ::GetModuleFileName(0, currentDir, sizeof(currentDir));	if (ret == 0 || ret == sizeof(currentDir))		return "";	char drive[MAX_PATH], dir[MAX_PATH], file[MAX_PATH], ext[MAX_PATH];	_splitpath(currentDir, drive, dir, file, ext);	_makepath(currentDir, drive, dir, NULL, NULL);	return std::string(currentDir);#elif MACOSX_BUNDLE	char cPath[1024];	CFBundleRef mainBundle = CFBundleGetMainBundle();	CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);	CFURLRef binaryPathURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault , mainBundleURL);	CFStringRef cfStringRef = CFURLCopyFileSystemPath(binaryPathURL, kCFURLPOSIXPathStyle);	CFStringGetCString(cfStringRef, cPath, 1024, kCFStringEncodingASCII);	CFRelease(mainBundleURL);	CFRelease(binaryPathURL);	CFRelease(cfStringRef);	return std::string(cPath);#else	return "";#endif}

/** * returns the path of the .app bundle on MacOS X * * this is needed to handle resource locations and config file pathes * propperly on Mac OS X. */std::string macBundlePath(){    char path[1024];    CFBundleRef mainBundle = CFBundleGetMainBundle();    assert(mainBundle);    CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);    assert(mainBundleURL);    CFStringRef cfStringRef = CFURLCopyFileSystemPath(            mainBundleURL, kCFURLPOSIXPathStyle);    assert(cfStringRef);    CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);    CFRelease(mainBundleURL);    CFRelease(cfStringRef);    return std::string(path);}

QString Uploader::sam7Path( ){  QString uploaderName;  #ifdef Q_OS_MAC // get the path within the app bundle  CFURLRef pluginRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());  CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle);  QDir appBundle( CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding()) );  uploaderName = appBundle.filePath( "Contents/Resources/sam7" );  #elif defined (Q_OS_WIN)  QDir d = QDir::current();  if(!d.exists("sam7.exe")) // in dev mode, we're one dir down in 'bin'    d.cdUp();  uploaderName = d.filePath("sam7.exe");  #else  QSettings settings;  QDir dir( settings.value("sam7_path", DEFAULT_SAM7_PATH).toString() );  uploaderName = dir.filePath("sam7");  #endif  return uploaderName;}

OSStatus SetVMPathFromApplicationDirectory() {	CFBundleRef mainBundle;	CFURLRef	bundleURL,bundleURLPrefix;	CFStringRef filePath;	CFMutableStringRef vmPathString;	mainBundle = CFBundleGetMainBundle();   	bundleURL = CFBundleCopyBundleURL(mainBundle);	bundleURLPrefix = CFURLCreateCopyDeletingLastPathComponent(NULL,bundleURL);	CFRelease(bundleURL);		filePath = CFURLCopyFileSystemPath (bundleURLPrefix, kCFURLPOSIXPathStyle);	CFRelease(bundleURLPrefix);		vmPathString = CFStringCreateMutableCopy(NULL, 0, filePath);	CFStringAppendCString(vmPathString, "/", kCFStringEncodingMacRoman);	SetVMPathFromCFString(vmPathString);	CFRelease(filePath);	CFRelease(vmPathString);		return 0;		}

int switch_to_game_directory(){    log_message("finding the bundle directory");    CFBundleRef bundle = CFBundleGetMainBundle();    CFURLRef url = NULL;    if(bundle)        url = CFBundleCopyBundleURL(bundle);    if(!url)    {        log_message("no bundle found");        return 0;    }    CFStringRef str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);    CFRelease(url);    int size = CFStringGetLength(str) + 1;    char *dir = (char *)malloc(size);    int success = CFStringGetCString(str, dir, size, kCFURLPOSIXPathStyle);    CFRelease(str);    if(success)    {        int success = chdir(dir);        if(success == 0)            log_messagef("changed directory to '%s'", dir);        else            log_messagef("failed changing directory to '%s'", dir);        // there must be a better way to tell if we're bundled :/        if(chdir("Contents/Resources") == 0)            log_message("running as an app bundle, changed to resources directory");        else            log_message("running unbundled");    }    free(dir);    return success;}

Image JUCE_API getIconFromApplication (const String& applicationPath, const int size){    Image hostIcon;    if (CFStringRef pathCFString = CFStringCreateWithCString (kCFAllocatorDefault, applicationPath.toRawUTF8(), kCFStringEncodingUTF8))    {        if (CFURLRef url = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, pathCFString, kCFURLPOSIXPathStyle, 1))        {            if (CFBundleRef appBundle = CFBundleCreate (kCFAllocatorDefault, url))            {                if (CFTypeRef infoValue = CFBundleGetValueForInfoDictionaryKey (appBundle, CFSTR("CFBundleIconFile")))                {                    if (CFGetTypeID (infoValue) == CFStringGetTypeID())                    {                        CFStringRef iconFilename = reinterpret_cast<CFStringRef> (infoValue);                        CFStringRef resourceURLSuffix = CFStringHasSuffix (iconFilename, CFSTR(".icns")) ? nullptr : CFSTR("icns");                        if (CFURLRef iconURL = CFBundleCopyResourceURL (appBundle, iconFilename, resourceURLSuffix, nullptr))                        {                            if (CFStringRef iconPath = CFURLCopyFileSystemPath (iconURL, kCFURLPOSIXPathStyle))                            {                                File icnsFile (CFStringGetCStringPtr (iconPath, CFStringGetSystemEncoding()));                                hostIcon = getIconFromIcnsFile (icnsFile, size);                                CFRelease (iconPath);                            }                            CFRelease (iconURL);                        }                    }                }                CFRelease (appBundle);            }            CFRelease (url);        }        CFRelease (pathCFString);    }    return hostIcon;}

char *Sys_PathFromOpenMenu(void) {    /* present an open file dialog and return the file's path */    OSStatus res;    NavDialogCreationOptions options;    NavDialogRef dialog;    NavReplyRecord reply;    NavUserAction action;    FSRef fileRef;    CFURLRef cfUrl;    CFStringRef cfString;    res = NavGetDefaultDialogCreationOptions(&options);    options.modality = kWindowModalityAppModal;    res = NavCreateGetFileDialog(&options, NULL, NULL, NULL, NULL, NULL, &dialog);    NavDialogRun(dialog);    action = NavDialogGetUserAction(dialog);    if (action == kNavUserActionNone || action == kNavUserActionCancel)        return NULL;    res = NavDialogGetReply(dialog, &reply);    if (res != noErr)        return NULL;    res = AEGetNthPtr(&reply.selection, 1, typeFSRef, NULL, NULL, &fileRef,                      sizeof(FSRef), NULL);    cfUrl = CFURLCreateFromFSRef(NULL, &fileRef);    cfString = NULL;    if (cfUrl) {        cfString = CFURLCopyFileSystemPath(cfUrl, kCFURLPOSIXPathStyle);        CFRelease(cfUrl);    }    memset(g_OpenFileName, 0, PATH_MAX);    CFStringGetCString(cfString, g_OpenFileName, PATH_MAX, kCFStringEncodingMacRoman);    return g_OpenFileName;}

 CF::String URL::GetFileSystemPath( CFURLPathStyle style ) {     CF::String  str;     CFStringRef cfStr;          if( this->_cfObject == NULL )     {         return str;     }          cfStr = CFURLCopyFileSystemPath( this->_cfObject, style );          if( cfStr != NULL )     {         str = cfStr;                  CFRelease( cfStr );     }          return str; }

char* getBundleRoot(){	// Adjust the path to the folder containing .app file:	CFBundleRef br;	CFURLRef ur;	CFStringRef sr;	br = CFBundleGetMainBundle();	if (br) {		long i;		ur = CFBundleCopyBundleURL(br);		sr = CFURLCopyFileSystemPath(ur, kCFURLPOSIXPathStyle);		i = switches_count++;		switches = realloc(switches,switches_count*sizeof(char*));		switches[i] = malloc(FILENAME_MAX);		CFStringGetCString(sr,switches[i],FILENAME_MAX,kCFStringEncodingASCII);		CFRelease(ur);		CFRelease(sr);		return switches[i];	}	return 0;};

void getexecutablepath(char* buffer, size_t bufferLen){#if defined( OS_MACOSX )	CFBundleRef mainBundle = CFBundleGetMainBundle();	CFURLRef executableUrl = CFBundleCopyExecutableURL(mainBundle);	CFStringRef executableString = CFURLCopyFileSystemPath(executableUrl, kCFURLPOSIXPathStyle);	CFMutableStringRef normalizedString = CFStringCreateMutableCopy(NULL, 0, executableString);	CFStringGetCString(normalizedString, buffer, bufferLen - 1, kCFStringEncodingUTF8);	CFRelease(executableUrl);	CFRelease(executableString);	CFRelease(normalizedString);#elif defined(__FreeBSD__)	sysctl_get_pathname(buffer, bufferLen);#else	if (readlink("/proc/self/exe", buffer, bufferLen) != -1)	{		return;	}	*buffer = 0;#endif	}

pascal OSStatus MoreAEOCreateObjSpecifierFromCFURLRef(const CFURLRef pCFURLRef,AEDesc *pObjSpecifier){	OSErr 		anErr = paramErr;	if (NULL != pCFURLRef)	{		CFStringRef tCFStringRef = CFURLCopyFileSystemPath(pCFURLRef,kCFURLHFSPathStyle);		anErr = coreFoundationUnknownErr;		if (NULL != tCFStringRef)		{			Boolean 		isDirectory = CFURLHasDirectoryPath(pCFURLRef);			AEDesc 			containerDesc = {typeNull, NULL};			AEDesc 			nameDesc = {typeNull, NULL};				Size			bufSize = (CFStringGetLength(tCFStringRef) + (isDirectory ? 1 : 0)) * sizeof(UniChar);				UniCharPtr		buf = (UniCharPtr) NewPtr(bufSize);				if ((anErr = MemError()) == noErr)				{					CFStringGetCharacters(tCFStringRef, CFRangeMake(0,bufSize/2), buf);					if (isDirectory) (buf)[(bufSize-1)/2] = (UniChar) 0x003A;								}						if (anErr == noErr)				anErr = AECreateDesc(typeUnicodeText, buf, GetPtrSize((Ptr) buf), &nameDesc);			if (anErr == noErr)				{					if (isDirectory)	// we use cObject here since this might be a package (and we have no way to tell)						anErr = CreateObjSpecifier(cObject, &containerDesc, formName, &nameDesc, false, pObjSpecifier);					else						anErr = CreateObjSpecifier(cFile, &containerDesc, formName, &nameDesc, false, pObjSpecifier);				}			MoreAEDisposeDesc(&nameDesc);			if (buf)				DisposePtr((Ptr)buf);		}	}	return anErr;}//end MoreAEOCreateObjSpecifierFromCFURLRef

static FILE* ios_open_from_bundle(const char path[], const char* perm) {    // Get a reference to the main bundle    CFBundleRef mainBundle = CFBundleGetMainBundle();    // Get a reference to the file's URL    CFStringRef pathRef = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8);    CFURLRef imageURL = CFBundleCopyResourceURL(mainBundle, pathRef, NULL, NULL);    if (!imageURL) {        return nullptr;    }    // Convert the URL reference into a string reference    CFStringRef imagePath = CFURLCopyFileSystemPath(imageURL, kCFURLPOSIXPathStyle);    // Get the system encoding method    CFStringEncoding encodingMethod = CFStringGetSystemEncoding();    // Convert the string reference into a C string    const char *finalPath = CFStringGetCStringPtr(imagePath, encodingMethod);    return fopen(finalPath, perm);}

static void GetTempFolderPath( uint16 *tempPath, size_t destMaxLength){	//Find the Temp directory	#if MSWindows		wchar_t tempFolderPath[4096];		GetTempPathW(4096,tempFolderPath);		StringCopy3D(tempPath,tempFolderPath, 4096);	#else		FSRef folderRef;		OSErr  err = FSFindFolder( kOnSystemDisk, kTemporaryFolderType, true, &folderRef );		if ( err != noErr )			{			err = FSFindFolder( kOnAppropriateDisk, kTemporaryFolderType, true, &folderRef );			}		if(err != noErr)			{			wchar_t tempFolderPath[]=L"/tmp/";			StringCopy3D(tempPath,tempFolderPath, destMaxLength);			}		else			{			CFURLRef url = CFURLCreateFromFSRef( kCFAllocatorDefault, &folderRef );			CFStringRef cfString = NULL;			if ( url != NULL )				{				cfString = CFURLCopyFileSystemPath( url, kCFURLPOSIXPathStyle );				CFStringGetCString(cfString,(char*)tempPath,2048,kCFStringEncodingUnicode);				int32 len=CFStringGetLength(cfString);				CFRelease( url );								tempPath[len]='/';				tempPath[len+1]=0;				}						}			#endif}

void Cinderactor::init(const std::string & ini_file ){    // Get a reference to the main bundle#ifdef _WIN32	std::string bundle_path(".//resources//");#else    CFBundleRef mainBundle = CFBundleGetMainBundle();    CFURLRef resourcesURL = CFBundleCopyBundleURL(mainBundle);	CFStringRef str = CFURLCopyFileSystemPath( resourcesURL, kCFURLPOSIXPathStyle );	CFRelease(resourcesURL);	char path[PATH_MAX];		CFStringGetCString( str, path, FILENAME_MAX, kCFStringEncodingASCII );	CFRelease(str);    std::string bundle_path(path);    bundle_path= bundle_path+"/Contents/Resources/";#endif    std::cout << ">>>>>>>>>>>> BUNDLE : bundle_path " << bundle_path << std::endl;    gestoos::nui::Interactor::set_resources_path(bundle_path);    gestoos::nui::Interactor::init( ini_file );    init_ok = true;}

/** * Get the location for global or user-local support files. * @return NULL if it could not be determined */char *Bgetsupportdir(int global){    char *dir = NULL;    #ifdef __APPLE__	FSRef ref;	CFStringRef str;	CFURLRef base;	const char *s;		if (FSFindFolder(global ? kLocalDomain : kUserDomain,					 kApplicationSupportFolderType,					 kDontCreateFolder, &ref) < 0) return NULL;	base = CFURLCreateFromFSRef(NULL, &ref);	if (!base) {        return NULL;    }    	str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle);	CFRelease(base);	if (!str) {        return NULL;    }    	s = CFStringGetCStringPtr(str, CFStringGetSystemEncoding());	if (s) {        dir = strdup(s);    }	CFRelease(str);#else    if (!global) {        dir = Bgethomedir();    }#endif    	return dir;}

QList<QStorageInfo> QStorageInfoPrivate::mountedVolumes(){    QList<QStorageInfo> volumes;    QCFType<CFURLEnumeratorRef> enumerator;    enumerator = CFURLEnumeratorCreateForMountedVolumes(Q_NULLPTR,                                                        kCFURLEnumeratorSkipInvisibles,                                                        Q_NULLPTR);    CFURLEnumeratorResult result = kCFURLEnumeratorSuccess;    do {        CFURLRef url;        CFErrorRef error;        result = CFURLEnumeratorGetNextURL(enumerator, &url, &error);        if (result == kCFURLEnumeratorSuccess) {            const QCFString urlString = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);            volumes.append(QStorageInfo(urlString));        }    } while (result != kCFURLEnumeratorEnd);    return volumes;}

CFIndex addCTFontDescriptor(CTFontDescriptorRef fd, JNIEnv *env, jobjectArray result, CFIndex index){    if (fd) {        CFStringRef name = CTFontDescriptorCopyAttribute(fd, kCTFontDisplayNameAttribute);        CFStringRef family = CTFontDescriptorCopyAttribute(fd, kCTFontFamilyNameAttribute);        CFURLRef url = CTFontDescriptorCopyAttribute(fd, kCTFontURLAttribute);        CFStringRef file = url ? CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle) : NULL;        if (name && family && file) {            jstring jname = createJavaString(env, name);            jstring jfamily = createJavaString(env, family);            jstring jfile = createJavaString(env, file);            (*env)->SetObjectArrayElement(env, result, index++, jname);            (*env)->SetObjectArrayElement(env, result, index++, jfamily);            (*env)->SetObjectArrayElement(env, result, index++, jfile);        }        if (name) CFRelease(name);        if (family) CFRelease(family);        if (url) CFRelease(url);        if (file) CFRelease(file);    }    return index;}

JNIEXPORT jstring JNICALLJava_org_gudy_azureus2_platform_macosx_access_jnilib_OSXAccess_getDocDir(	JNIEnv		*env,	jclass		cla ){	CFURLRef docURL;	CFStringRef docPath;	FSRef    fsRef;  OSErr    err = FSFindFolder(kUserDomain, kDocumentsFolderType, kDontCreateFolder, &fsRef);    jstring result = 0;	if (err == noErr) {  	if((docURL = CFURLCreateFromFSRef( kCFAllocatorSystemDefault, &fsRef))) {			docPath = CFURLCopyFileSystemPath(docURL, kCFURLPOSIXPathStyle);						if (docPath) {				// convert to unicode				CFIndex strLen = CFStringGetLength( docPath );				UniChar uniStr[ strLen ];				CFRange strRange;				strRange.location = 0;				strRange.length = strLen;				CFStringGetCharacters( docPath, strRange, uniStr );					result = (*env)->NewString( env, (jchar*)uniStr, (jsize)strLen );				CFRelease(docPath);								return result;			}			CFRelease(docURL);		}		return result;  }}

char *Bgethomedir(void){#ifdef _WIN32	TCHAR appdata[MAX_PATH];	if (SUCCEEDED(SHGetSpecialFolderPathA(NULL, appdata, CSIDL_APPDATA, FALSE)))		return strdup(appdata);	return NULL;#elif defined __APPLE__    #if LOWANG_IOS    const char* Sys_GetResourceDir(void);	return strdup(Sys_GetResourceDir());#else    	FSRef ref;	CFStringRef str;	CFURLRef base;	char *s;	if (FSFindFolder(kUserDomain, kVolumeRootFolderType, kDontCreateFolder, &ref) < 0) return NULL;	base = CFURLCreateFromFSRef(NULL, &ref);	if (!base) return NULL;	str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle);	CFRelease(base);	if (!str) return NULL;	s = (char*)CFStringGetCStringPtr(str,CFStringGetSystemEncoding());	if (s) s = strdup(s);	CFRelease(str);	return s;#endif#else	char *e = getenv("HOME");	if (!e) return NULL;	return strdup(e);#endif}

char *Bgetsupportdir(int global){#ifndef __APPLE__	return Bgethomedir();#else	FSRef ref;	CFStringRef str;	CFURLRef base;	char *s;		if (FSFindFolder(global ? kLocalDomain : kUserDomain,					 kApplicationSupportFolderType,					 kDontCreateFolder, &ref) < 0) return NULL;	base = CFURLCreateFromFSRef(NULL, &ref);	if (!base) return NULL;	str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle);	CFRelease(base);	if (!str) return NULL;	s = (char*)CFStringGetCStringPtr(str,CFStringGetSystemEncoding());	if (s) s = strdup(s);	CFRelease(str);	return s;#endif}

long GetProcDir(std::string & Dest){	CFAuto<CFURLRef> TestURL(		CFBundleCopyExecutableURL(CFBundleGetMainBundle()));			CFAuto<CFStringRef> PathCFString(		CFURLCopyFileSystemPath(TestURL,kCFURLPOSIXPathStyle));		long PathLen = CFStringGetLength(PathCFString) + 1;		char PathString[PathLen];		//AutoCharBuf PathString(PathLen);	CFStringGetCString(PathCFString, PathString, PathLen ,kCFStringEncodingUTF8);		char* PathTerm = strrchr(PathString, '/');		if (PathTerm != NULL)		*(PathTerm + 1) = '/0';			Dest = PathString;		return 0;	}

QString mac_app_filename() {	static QString appFileName;	if (appFileName.isEmpty()) {		CFURLRef bundleURL = NULL;		CFBundleRef bundle = NULL;		CFStringRef bundlePath = NULL;		bundle = CFBundleGetMainBundle();		if (bundle) {			bundleURL = CFBundleCopyBundleURL(bundle);			bundlePath = CFURLCopyFileSystemPath(bundleURL, kCFURLPOSIXPathStyle);			if (bundleURL) {				CFRelease(bundleURL);			}			if (bundlePath) {				appFileName = convert_CFString_to_QString(bundlePath);				CFRelease(bundlePath);			}		}	}	return appFileName;}

void read_database() {        int i;#ifdef __APPLE__    char app_path[1024];    CFURLRef mainBundleURL = CFBundleCopyBundleURL( CFBundleGetMainBundle());    CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);    CFStringGetCString( cfStringRef, app_path, 1024, kCFStringEncodingASCII);    CFRelease( mainBundleURL);    CFRelease( cfStringRef);    sprintf(db_file_name,"%s/Contents/Resources/nfosc.db",app_path);#else    strcpy(db_file_name,"nfosc.db");#endif        nfosc_t db_entry;    char line[36];    FILE *db_file = fopen(db_file_name, "r");    if (db_file==NULL) return;        while (fgets (line, 32, db_file)) {        db_entry.symbol_id = max_symbol_id;        for (i=0; i<32; i++) {            if (line[i]=='/n') {                db_entry.uid_str[i]='/0';                break;            }            db_entry.uid_str[i]=line[i];        }        if (verbose) printf("assigning ID %d to UID %s/n",max_symbol_id,db_entry.uid_str);        tag_database[max_symbol_id] = db_entry;        max_symbol_id++;    }        fclose (db_file);}

#endif  QSettings mySettings;  // For non static builds on mac and win (static builds are not supported)  // we need to be sure we can find the qt image  // plugins. In mac be sure to look in the  // application bundle...#ifdef Q_OS_WIN  QCoreApplication::addLibraryPath( QApplication::applicationDirPath()                                    + QDir::separator() + "qtplugins" );#endif#ifdef Q_OS_MACX  //qDebug("Adding qt image plugins to plugin search path...");  CFURLRef myBundleRef = CFBundleCopyBundleURL( CFBundleGetMainBundle() );  CFStringRef myMacPath = CFURLCopyFileSystemPath( myBundleRef, kCFURLPOSIXPathStyle );  const char *mypPathPtr = CFStringGetCStringPtr( myMacPath, CFStringGetSystemEncoding() );  CFRelease( myBundleRef );  CFRelease( myMacPath );  QString myPath( mypPathPtr );  // if we are not in a bundle assume that the app is built  // as a non bundle app and that image plugins will be  // in system Qt frameworks. If the app is a bundle  // lets try to set the qt plugin search path...  QFileInfo myInfo( myPath );  if ( myInfo.isBundle() )  {    // First clear the plugin search paths so we can be sure    // only plugins from the bundle are being used    QStringList myPathList;    QCoreApplication::setLibraryPaths( myPathList );

CFDictionaryRef createDockDescriptionForURL(CFURLRef url) {	if (!url) {		NSLog(CFSTR("%@"), CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: Cannot copy Dock description for a NULL URL"));		return NULL;	}	//return NULL for non-file: URLs.	CFStringRef scheme = CFURLCopyScheme(url);	Boolean isFileURL = (CFStringCompare(scheme, CFSTR("file"), kCFCompareCaseInsensitive) == kCFCompareEqualTo);	CFRelease(scheme);	if (!isFileURL)		return NULL;	CFDictionaryRef dict = NULL;	CFStringRef path     = NULL;	CFDataRef aliasData  = NULL;	FSRef    fsref;	if (CFURLGetFSRef(url, &fsref)) {		AliasHandle alias = NULL;		OSStatus    err   = FSNewAlias(/*fromFile*/ NULL, &fsref, &alias);		if (err != noErr) {			NSLog(CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: FSNewAlias for %@ returned %li"), url, (long)err);		} else {			HLock((Handle)alias);			err = FSCopyAliasInfo(alias, /*targetName*/ NULL, /*volumeName*/ NULL, (CFStringRef *)&path, /*whichInfo*/ NULL, /*info*/ NULL);			if (err != noErr) {				NSLog(CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: FSCopyAliasInfo for %@ returned %li"), url, (long)err);			}			aliasData = CFDataCreate(kCFAllocatorDefault, (UInt8 *)*alias, GetHandleSize((Handle)alias));			HUnlock((Handle)alias);			DisposeHandle((Handle)alias);		}	}	if (!path) {		path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);	}	if (path || aliasData) {		CFMutableDictionaryRef temp = CFDictionaryCreateMutable(kCFAllocatorDefault, /*capacity*/ 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);		if (path) {			CFDictionarySetValue(temp, _CFURLStringKey, path);			CFRelease(path);			int pathStyle = kCFURLPOSIXPathStyle;			CFNumberRef pathStyleNum = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &pathStyle);			CFDictionarySetValue(temp, _CFURLStringTypeKey, pathStyleNum);			CFRelease(pathStyleNum);		}		if (aliasData) {			CFDictionarySetValue(temp, _CFURLAliasDataKey, aliasData);			CFRelease(aliasData);		}		dict = temp;	}	return dict;}

CFStringRef copyCurrentProcessPath(void) {	CFURLRef URL = copyCurrentProcessURL();	CFStringRef path = CFURLCopyFileSystemPath(URL, kCFURLPOSIXPathStyle);	CFRelease(URL);	return path;}

/****  The main program: initialise, parse options and arguments.****  @param argc  Number of arguments.**  @param argv  Vector of arguments.*/int main(int argc, char **argv){#ifdef REDIRECT_OUTPUT	RedirectOutput();#endif#ifdef USE_BEOS	//  Parse arguments for BeOS	beos_init(argc, argv);#endif	//  Setup some defaults.#ifndef MAC_BUNDLE	StratagusLibPath = ".";#else	freopen("/tmp/stdout.txt", "w", stdout);	freopen("/tmp/stderr.txt", "w", stderr);	// Look for the specified data set inside the application bundle	// This should be a subdir of the Resources directory	CFURLRef pluginRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(),												 CFSTR(MAC_BUNDLE_DATADIR), NULL, NULL);	CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef,  kCFURLPOSIXPathStyle);	const char *pathPtr = CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding());	Assert(pathPtr);	StratagusLibPath = pathPtr;#endif	Parameters &parameters = Parameters::Instance;	parameters.SetDefaultValues();	parameters.LocalPlayerName = GetLocalPlayerNameFromEnv();	if (argc > 0) {		parameters.applicationName = argv[0];	}	// FIXME: Parse options before or after scripts?	ParseCommandLine(argc, argv, parameters);	// Init the random number generator.	InitSyncRand();	makedir(parameters.GetUserDirectory().c_str(), 0777);	// Init Lua and register lua functions!	InitLua();	LuaRegisterModules();	// Initialise AI module	InitAiModule();	LoadCcl(parameters.luaStartFilename);	PrintHeader();	PrintLicense();	// Setup video display	InitVideo();	// Setup sound card	if (!InitSound()) {		InitMusic();	}#ifndef DEBUG           // For debug it's better not to have:	srand(time(NULL));  // Random counter = random each start#endif	//  Show title screens.	SetDefaultTextColors(FontYellow, FontWhite);	LoadFonts();	SetClipping(0, 0, Video.Width - 1, Video.Height - 1);	Video.ClearScreen();	ShowTitleScreens();	// Init player data	ThisPlayer = NULL;	//Don't clear the Players strucure as it would erase the allowed units.	// memset(Players, 0, sizeof(Players));	NumPlayers = 0;	UnitManager.Init(); // Units memory management	PreMenuSetup();     // Load everything needed for menus	MenuLoop();	Exit(0);	return 0;}

void StartDebuggingAndDetach(char *udid, char *app_path) {	SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);	if (device) {		CFStringRef bundleId = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)app_path, strlen(app_path), kCFStringEncodingUTF8, false);		CFURLRef relative_url = CFURLCreateWithFileSystemPath(NULL, bundleId, kCFURLPOSIXPathStyle, false);		CFURLRef disk_app_url = CFURLCopyAbsoluteURL(relative_url);		CFStringRef bundle_identifier = copy_disk_app_identifier(disk_app_url);				SDMMD_AMDebugConnectionRef debug = SDMMD_AMDebugConnectionCreateForDevice(device);		SDMMD_AMDebugConnectionStart(debug);				uintptr_t socket = SDMMD_AMDServiceConnectionGetSocket(debug->connection);		CFSocketContext context = { 0, (void*)socket, NULL, NULL, NULL };		CFSocketRef fdvendor = CFSocketCreate(NULL, AF_UNIX, 0, 0, kCFSocketAcceptCallBack, &socket_callback, &context);				int yes = 1;		setsockopt(CFSocketGetNative(fdvendor), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));				struct sockaddr_un address;		memset(&address, 0, sizeof(address));		address.sun_family = AF_UNIX;		strcpy(address.sun_path, SDM_LLDB_SOCKET);		address.sun_len = SUN_LEN(&address);		CFDataRef address_data = CFDataCreate(NULL, (const UInt8 *)&address, sizeof(address));				unlink(SDM_LLDB_SOCKET);				CFSocketSetAddress(fdvendor, address_data);		CFRelease(address_data);		CFRunLoopAddSource(CFRunLoopGetMain(), CFSocketCreateRunLoopSource(NULL, fdvendor, 0), kCFRunLoopCommonModes);				SDMMD_AMDeviceRef device = SDMMD_AMDServiceConnectionGetDevice(debug->connection);		CFMutableStringRef cmds = CFStringCreateMutableCopy(NULL, 0, LLDB_PREP_CMDS);		CFRange range = { 0, CFStringGetLength(cmds) };				CFURLRef device_app_url = copy_device_app_url(device, bundle_identifier);		CFStringRef device_app_path = CFURLCopyFileSystemPath(device_app_url, kCFURLPOSIXPathStyle);		CFStringFindAndReplace(cmds, CFSTR("{DEVICE_PATH}"), device_app_path, range, 0);		range.length = CFStringGetLength(cmds);				CFStringRef disk_app_path = CFURLCopyFileSystemPath(disk_app_url, kCFURLPOSIXPathStyle);		CFStringFindAndReplace(cmds, CFSTR("{APP_PATH}"), disk_app_path, range, 0);		range.length = CFStringGetLength(cmds);				CFURLRef device_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, device_app_url);		CFStringRef device_container_path = CFURLCopyFileSystemPath(device_container_url, kCFURLPOSIXPathStyle);		CFMutableStringRef dcp_noprivate = CFStringCreateMutableCopy(NULL, 0, device_container_path);		range.length = CFStringGetLength(dcp_noprivate);		CFStringFindAndReplace(dcp_noprivate, CFSTR("/private/var/"), CFSTR("/var/"), range, 0);		range.length = CFStringGetLength(cmds);		CFStringFindAndReplace(cmds, CFSTR("{device_container}"), dcp_noprivate, range, 0);		range.length = CFStringGetLength(cmds);				CFURLRef disk_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, disk_app_url);		CFStringRef disk_container_path = CFURLCopyFileSystemPath(disk_container_url, kCFURLPOSIXPathStyle);		CFStringFindAndReplace(cmds, CFSTR("{disk_container}"), disk_container_path, range, 0);				CFDataRef cmds_data = CFStringCreateExternalRepresentation(NULL, cmds, kCFStringEncodingASCII, 0);		FILE *out = fopen(PREP_CMDS_PATH, "w");		fwrite(CFDataGetBytePtr(cmds_data), CFDataGetLength(cmds_data), 1, out);		fclose(out);				CFSafeRelease(cmds);		CFSafeRelease(bundle_identifier);		CFSafeRelease(device_app_url);		CFSafeRelease(device_app_path);		CFSafeRelease(disk_app_path);		CFSafeRelease(device_container_url);		CFSafeRelease(device_container_path);		CFSafeRelease(dcp_noprivate);		CFSafeRelease(disk_container_url);		CFSafeRelease(disk_container_path);		CFSafeRelease(cmds_data);				signal(SIGHUP, exit);				pid_t parent = getpid();		int pid = fork();		if (pid == 0) {			system("xcrun -sdk iphoneos lldb /tmp/sdmmd-lldb-prep");			kill(parent, SIGHUP);			_exit(0);		}		CFRunLoopRun();	}}

__private_extern__ CFArrayRef  _CFPreferencesCreateDomainList(CFStringRef  userName, CFStringRef  hostName) {    CFAllocatorRef prefAlloc = __CFPreferencesAllocator();    CFArrayRef  domains;    CFMutableArrayRef  marray;    CFStringRef  *cachedDomainKeys;    CFPreferencesDomainRef *cachedDomains;    SInt32 idx, cnt;    CFStringRef  suffix;    UInt32 suffixLen;    CFURLRef prefDir = _preferencesDirectoryForUserHost(userName, hostName);        if (!prefDir) {        return NULL;    }    if (hostName == kCFPreferencesAnyHost) {        suffix = CFStringCreateWithCString(prefAlloc, ".plist", kCFStringEncodingASCII);    } else if (hostName == kCFPreferencesCurrentHost) {        CFStringRef hostID = _CFPreferencesGetByHostIdentifierString();        suffix = CFStringCreateWithFormat(prefAlloc, NULL, CFSTR(".%@.plist"), hostID);    } else {        suffix = CFStringCreateWithFormat(prefAlloc, NULL, CFSTR(".%@.plist"), hostName);   // sketchy - this allows someone to create a domain list for an arbitrary hostname.    }    suffixLen = CFStringGetLength(suffix);        domains = (CFArrayRef)CFURLCreatePropertyFromResource(prefAlloc, prefDir, kCFURLFileDirectoryContents, NULL);    CFRelease(prefDir);    if (domains){        marray = CFArrayCreateMutableCopy(prefAlloc, 0, domains);        CFRelease(domains);    } else {        marray = CFArrayCreateMutable(prefAlloc, 0, & kCFTypeArrayCallBacks);    }    for (idx = CFArrayGetCount(marray)-1; idx >= 0; idx --) {        CFURLRef  url = (CFURLRef)CFArrayGetValueAtIndex(marray, idx);        CFStringRef string = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);        if (!CFStringHasSuffix(string, suffix)) {            CFArrayRemoveValueAtIndex(marray, idx);        } else {            CFStringRef  dom = CFStringCreateWithSubstring(prefAlloc, string, CFRangeMake(0, CFStringGetLength(string) - suffixLen));            if (CFEqual(dom, CFSTR(".GlobalPreferences"))) {                CFArraySetValueAtIndex(marray, idx, kCFPreferencesAnyApplication);            } else {                CFArraySetValueAtIndex(marray, idx, dom);            }            CFRelease(dom);        }        CFRelease(string);    }    CFRelease(suffix);        // Now add any domains added in the cache; delete any that have been deleted in the cache    __CFSpinLock(&domainCacheLock);    if (!domainCache) {        __CFSpinUnlock(&domainCacheLock);        return marray;    }    cnt = CFDictionaryGetCount(domainCache);    cachedDomainKeys = (CFStringRef *)CFAllocatorAllocate(prefAlloc, 2 * cnt * sizeof(CFStringRef), 0);    cachedDomains = (CFPreferencesDomainRef *)(cachedDomainKeys + cnt);    CFDictionaryGetKeysAndValues(domainCache, (const void **)cachedDomainKeys, (const void **)cachedDomains);    __CFSpinUnlock(&domainCacheLock);    suffix = _CFPreferencesCachePrefixForUserHost(userName, hostName);    suffixLen = CFStringGetLength(suffix);        for (idx = 0; idx < cnt; idx ++) {        CFStringRef  domainKey = cachedDomainKeys[idx];        CFPreferencesDomainRef domain = cachedDomains[idx];        CFStringRef  domainName;        CFIndex keyCount = 0;                if (!CFStringHasPrefix(domainKey, suffix)) continue;        domainName = CFStringCreateWithSubstring(prefAlloc, domainKey, CFRangeMake(suffixLen, CFStringGetLength(domainKey) - suffixLen));        if (CFEqual(domainName, CFSTR("*"))) {            CFRelease(domainName);            domainName = (CFStringRef)CFRetain(kCFPreferencesAnyApplication);        } else if (CFEqual(domainName, kCFPreferencesCurrentApplication)) {            CFRelease(domainName);            domainName = (CFStringRef)CFRetain(_CFProcessNameString());        }        CFDictionaryRef d = _CFPreferencesDomainDeepCopyDictionary(domain);        keyCount = d ? CFDictionaryGetCount(d) : 0;        if (keyCount) CFRelease(d);        if (keyCount == 0) {            // Domain was deleted            SInt32 firstIndexOfValue = CFArrayGetFirstIndexOfValue(marray, CFRangeMake(0, CFArrayGetCount(marray)), domainName);            if (0 <= firstIndexOfValue) {                CFArrayRemoveValueAtIndex(marray, firstIndexOfValue);            }        } else if (!CFArrayContainsValue(marray, CFRangeMake(0, CFArrayGetCount(marray)), domainName)) {            CFArrayAppendValue(marray, domainName);        }        CFRelease(domainName);    }    CFRelease(suffix);    CFAllocatorDeallocate(prefAlloc, cachedDomainKeys);    return marray;}