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

void SetBasePath(void){	OSErr			error;	FSSpec		where;	//Handle		theString;	Str255		name;	short			vRef;	long			dirID;	long			nDirID;	error = FindFolder(kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder, &vRef, &dirID);	GetIndString(name, kTransportPath, 1);	if (name[0] != '0') {		error = FSMakeFSSpec(vRef, dirID, name, &where);	// First, check to see if the directory exists		if (error != noErr) {			// Create it			error = FSpDirCreate(&where, smSystemScript, &nDirID);		}		p2cstr(name);		strncat((char *)name, "Serial", 63);	// It won't matter if this exists or not; we'll get the parent directory ID this way		c2pstr((char *)name);		error = FSMakeFSSpec(vRef, dirID, name, &where);		gvRef = where.vRefNum;		gparID = where.parID;	}}

short file_attr(const char *path) {#ifdef TARGET_API_MAC_CARBON	Str255			fname;	FSSpec			fss;	FSRef			fsr;	FSCatalogInfo	fsci;	short			ret;	mkstr255(fname, path);	if ((FSMakeFSSpec(0, 0, fname, &fss) != noErr) ||		(FSpMakeFSRef(&fss, &fsr) != noErr) ||		(FSGetCatalogInfo(&fsr, kFSCatInfoNodeFlags, &fsci,										NULL, NULL, NULL) != noErr)) {		return(-1);	}	if (fsci.nodeFlags & kFSNodeIsDirectoryMask) {		ret = FILEATTR_DIRECTORY;	}	else {		ret = FILEATTR_ARCHIVE;	}	if (fsci.nodeFlags & kFSNodeLockedMask) {		ret |= FILEATTR_READONLY;	}	return(ret);#else	Str255		fname;	FSSpec		fss;	CInfoPBRec	pb;	short		ret;	mkstr255(fname, path);	FSMakeFSSpec(0, 0, fname, &fss);	pb.dirInfo.ioNamePtr = fss.name;	pb.dirInfo.ioVRefNum = fss.vRefNum;	pb.dirInfo.ioDrDirID = fss.parID;	if (fss.name[0] == 0) {		pb.dirInfo.ioFDirIndex = -1;	}	else {		pb.dirInfo.ioFDirIndex = 0;	}	if (PBGetCatInfo(&pb, false) != noErr) {		return(-1);	}	if (pb.hFileInfo.ioFlAttrib & ioDirMask) {		ret = FILEATTR_DIRECTORY;	}	else {		ret = FILEATTR_ARCHIVE;	}	if (pb.hFileInfo.ioFlAttrib & 0x01) {		ret |= FILEATTR_READONLY;	}	return(ret);#endif}

void CleanTemp(void){    OSErr   err = noErr;    short   vRefNum;    long    dirID;    FSSpec  viewerFSp;    XPISpec *xpiList, *currXPI = 0, *nextXPI = 0;#ifdef MIW_DEBUG    Boolean isDir = false;#endif    #ifndef MIW_DEBUG    /* get "viewer" in "Temporary Items" folder */    ERR_CHECK(FindFolder(kOnSystemDisk, kTemporaryFolderType, kCreateFolder, &vRefNum, &dirID));    err = FSMakeFSSpec(vRefNum, dirID, kViewerFolder, &viewerFSp);#else    /* for DEBUG builds temp is "<currProcessVolume>:Temp NSInstall:" */    ERR_CHECK(GetCWD(&dirID, &vRefNum)); 	err = FSMakeFSSpec(vRefNum, 0, kTempFolder, &viewerFSp);	if (err == fnfErr)	    return; /* no debug temp exists */	err = FSpGetDirectoryID(&viewerFSp, &dirID, &isDir);	if (err != noErr || !isDir)	    return;    err = FSMakeFSSpec(vRefNum, dirID, kViewerFolder, &viewerFSp);#endif        /* whack the viewer folder if it exists */    if (err == noErr)    {        ERR_CHECK(DeleteDirectory(viewerFSp.vRefNum, viewerFSp.parID, viewerFSp.name));    }        /* clean out the zippies (.xpi's) */    xpiList = (XPISpec *) NewPtrClear(sizeof(XPISpec));    if (!xpiList)        return;    IterateDirectory(vRefNum, dirID, "/p", 1, CheckIfXPI, (void*)&xpiList);        if (xpiList)    {        currXPI = xpiList;        while(currXPI)        {            nextXPI = currXPI->next; /* save nextXPI before we blow away currXPI */            if (currXPI->FSp)            {                FSpDelete(currXPI->FSp);                DisposePtr((Ptr)currXPI->FSp);            }            DisposePtr((Ptr)currXPI);            currXPI = nextXPI;        }    }}

/* This function is an adaptation of the function FSpLocationFromPath in   tclMacUtils.c in the Tcl 8.0 distribution */OSErr FSMakeFSSpecFromPath(ConstStr255Param fileName, FSSpecPtr spec){  Boolean isDir, wasAlias;  int pos, end;  OSErr err;  Str255 Name;  short vRefNum;  long dirID;    /* get the initial directory information and set up first path component */  CopyNamePart(Name, fileName, 1);  if (Name[0] < fileName[0] && Name[1] != ':') { /* absolute path */    Name[0]++;    Name[Name[0]] = ':';    if ((err = FSMakeFSSpec(0, 0, Name, spec)) != noErr)      return err;    if ((err = FSpGetDirectoryID(spec, &dirID, &isDir)) != noErr)      return err;    if (! isDir)      return dirNFErr;    vRefNum = spec->vRefNum;    pos = Name[0] + 1;    CopyNamePart(Name, fileName, pos);  }  else {    dirID = 0;    vRefNum = 0;    pos = 1;    isDir = true;  }    /* process remaining path parts */  end = fileName[0] + 1;  while (true) {    if ((err = FSMakeFSSpec(vRefNum, dirID, Name[0] == 0 ? NULL : Name,                            spec)) != noErr ||        (err = ResolveAliasFile(spec, true, &isDir, &wasAlias)) != noErr)      return err;    pos += Name[0];    if (pos < end) {      if ((err = FSpGetDirectoryID(spec, &dirID, &isDir)) != noErr)        return err;      if (! isDir)        return dirNFErr;      vRefNum = spec->vRefNum;      CopyNamePart(Name, fileName, pos);    }    else      return noErr;  }}

pascal	OSErr	FSMakeFSSpecCompat(short vRefNum,                                   long dirID,                                   ConstStr255Param fileName,                                   FSSpec *spec){    OSErr	result;#if !__MACOSSEVENORLATER    if ( !FSHasFSSpecCalls() && !QTHasFSSpecCalls() )    {        Boolean	isDirectory;        result = GetObjectLocation(vRefNum, dirID, fileName,                                   &(spec->vRefNum), &(spec->parID), spec->name,                                   &isDirectory);    }    else#endif	/* !__MACOSSEVENORLATER */    {        /* Let the file system create the FSSpec if it can since it does the job */        /* much more efficiently than I can. */        result = FSMakeFSSpec(vRefNum, dirID, fileName, spec);        /* Fix a bug in Macintosh PC Exchange's MakeFSSpec code where 0 is */        /* returned in the parID field when making an FSSpec to the volume's */        /* root directory by passing a full pathname in MakeFSSpec's */        /* fileName parameter. Fixed in Mac OS 8.1 */        if ( (result == noErr) && (spec->parID == 0) )            spec->parID = fsRtParID;    }    return ( result );}

/*---------------------------------------------------------------------- Called internally to load a code fragment.----------------------------------------------------------------------*/OSErr preloadTransport(StringPtr transportName, CFragConnectionID* connID){	OSErr anErr;	FSSpec spec;	Ptr mainAddr;	Str255 errName;	Str255 fragName;	CFragSymbolClass symClass;	//	we need to setup our function pointers for the selected	//	transport. We do this by looking for a file with a code	//	fragment and then we load all of the function pointers	//	from it for later use throughout the application	//	create a pascal string which is the file name which has the	//	fragment in it	anErr = FSMakeFSSpec(gvRef, gparID, transportName, &spec);	if (anErr == noErr) {		anErr = GetDiskFragment(			&spec,			0,			kCFragGoesToEOF,			fragName,			kLoadCFrag,			connID,			&mainAddr,			errName		);	}	return anErr;}

int __PHYSFS_platformIsSymLink(const char *fname){    OSErr err;    FSSpec spec;    Boolean a = 0;    Boolean f = 0;    CInfoPBRec infoPB;    char *ptr;    char *dir = alloca(strlen(fname) + 1);    BAIL_IF_MACRO(dir == NULL, ERR_OUT_OF_MEMORY, 0);    strcpy(dir, fname);    ptr = strrchr(dir, ':');    if (ptr == NULL)  /* just a volume name? Can't be a symlink. */        return(0);    /* resolve aliases up to the actual file... */    *ptr = '/0';    BAIL_IF_MACRO(fnameToFSSpec(dir, &spec) != noErr, NULL, 0);    *ptr = strlen(ptr + 1);  /* ptr is now a pascal string. Yikes! */    memset(&infoPB, '/0', sizeof (CInfoPBRec));    infoPB.dirInfo.ioNamePtr = spec.name;    infoPB.dirInfo.ioVRefNum = spec.vRefNum;    infoPB.dirInfo.ioDrDirID = spec.parID;    infoPB.dirInfo.ioFDirIndex = 0;    BAIL_IF_MACRO(oserr(PBGetCatInfoSync(&infoPB)) != noErr, NULL, 0);    err = FSMakeFSSpec(spec.vRefNum, infoPB.dirInfo.ioDrDirID,                       (const unsigned char *) ptr, &spec);    BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0);    BAIL_IF_MACRO(oserr(IsAliasFile(&spec, &a, &f)) != noErr, NULL, 0);    return(a);} /* __PHYSFS_platformIsSymlink */

void *file_list1st(const char *dir, FLINFO *fli) {	FLISTH		ret;	Str255		fname;	FSSpec		fss;	FSRef		fsr;	FSIterator	fsi;	mkstr255(fname, dir);	if ((FSMakeFSSpec(0, 0, fname, &fss) != noErr) ||		(FSpMakeFSRef(&fss, &fsr) != noErr) ||		(FSOpenIterator(&fsr, kFSIterateFlat, &fsi) != noErr)) {		goto ff1_err1;	}	ret = _MALLOC(sizeof(_FLHDL), dir);	if (ret == NULL) {		goto ff1_err2;	}	((FLHDL)ret)->eoff = FALSE;	((FLHDL)ret)->fsi = fsi;	if (file_listnext(ret, fli) == SUCCESS) {		return(ret);	}ff1_err2:	FSCloseIterator(fsi);ff1_err1:	return(NULL);}

/*------------------------------------------------------------------- *   XPI Stub Load/Unload *-------------------------------------------------------------------*/OSErrLoadXPIStub(XPI_InitProc* pfnInit, XPI_InstallProc* pfnInstall, XPI_ExitProc* pfnExit, 			CFragConnectionID* connID, FSSpec& aTargetDir, Str255 errName){	OSErr				err;	FSSpec				fslib;	Str63 				fragName = XPISTUB_DLL;	Ptr					mainAddr, symAddr;	CFragSymbolClass	symClass;	long				tgtDirID;	Boolean 			isDir;		err = FSpGetDirectoryID( &aTargetDir, &tgtDirID, &isDir );	if (err!=noErr)		return err;	else if (!isDir)		return paramErr;			err = FSMakeFSSpec(aTargetDir.vRefNum, tgtDirID, fragName, &fslib);	if (err!=noErr)		return err;			err = GetDiskFragment(&fslib, 0, kCFragGoesToEOF, nil, /*kPrivateCFragCopy*/kReferenceCFrag, connID, &mainAddr, errName);										   	if ( err == noErr && *connID != NULL)	{		ERR_CHECK_RET( FindSymbol(*connID, "/pXPI_Init", &symAddr, &symClass), err );		*pfnInit = (XPI_InitProc) symAddr;				ERR_CHECK_RET( FindSymbol(*connID, "/pXPI_Install", &symAddr, &symClass), err);		*pfnInstall = (XPI_InstallProc) symAddr;				ERR_CHECK_RET( FindSymbol(*connID, "/pXPI_Exit", &symAddr, &symClass), err);		*pfnExit = (XPI_ExitProc) symAddr;	}

/*__________________________________________________________________________*/Boolean SaveDriverState (short refnum, StringPtr file, OSType creator, OSType type){	FSSpec spec; OSErr err; TDriverInfos dInfos;	long size, dirID; short vrefNum, ref;	Ptr ptr;		if (FindMidiShareFolder (true, &vrefNum, &dirID) != noErr) return false;	if (!MidiGetDriverInfos (refnum, &dInfos)) return false;	size = Get1DriverStateSize (dInfos.slots);	if (!size) return true;		ptr = NewPtrSys(size);	if (!ptr) return false;			Get1DriverState (refnum, dInfos.slots, ptr, size);	err = FSMakeFSSpec(vrefNum, dirID, file, &spec);	if (err == fnfErr)		err = FSpCreate (&spec, creator, type, smSystemScript);	if (err != noErr) goto err;		err = FSpOpenDF (&spec, fsWrPerm, &ref);	if (err != noErr) goto err;		err = FSWrite (ref, &size, ptr);	FSClose (ref);	DisposePtr (ptr);	return err == noErr;err:	DisposePtr (ptr);	return false;}

extern char* vr_findVerRegName(){    FSSpec  regSpec;    OSErr   err;    short   foundVRefNum;    long    foundDirID;    int     bCreate = 0;        /* quick exit if we have the info */    if ( verRegName != NULL )        return verRegName;    err = FindFolder(kOnSystemDisk,'pref', false, &foundVRefNum, &foundDirID);    if (err == noErr)    {        err = FSMakeFSSpec(foundVRefNum, foundDirID, MAC_VERREG, &regSpec);        if (err == -43) /* if file doesn't exist */        {            err = FSpCreate(&regSpec, 'MOSS', 'REGS', smSystemScript);            bCreate = 1;        }        if (err == noErr)        {            Handle thePath;            short pathLen;            err = FSpGetFullPath(&regSpec, &pathLen, &thePath);            if (err == noErr && thePath)            {                /* we have no idea if this moves memory, so better lock the handle */             #if defined(STANDALONE_REGISTRY) || defined(USE_STDIO_MODES)                HLock(thePath);                verRegName = (char *)XP_ALLOC(pathLen + 1);                XP_STRNCPY(verRegName, *thePath, pathLen);                verRegName[pathLen] = '/0';            #else                /* Since we're now using NSPR, this HAS to be a unix path! */                const char* src;                char* dst;                HLock(thePath);                verRegName = (char*)XP_ALLOC(pathLen + 2);                src = *(char**)thePath;                dst = verRegName;                *dst++ = '/';                while (pathLen--)                {                    char c = *src++;                    *dst++ = (c == ':') ? '/' : c;                }                *dst = '/0';            #endif            }            DisposeHandle(thePath);        }    }    return verRegName;}

static pascal voidGetSharedLibraryFilterProc(const CInfoPBRec* const inCpb, Boolean* inWantQuit, void *inFilterData){	GetSharedLibraryFilterProcData* pFilterData = (GetSharedLibraryFilterProcData*) inFilterData;	if ((inCpb->hFileInfo.ioFlAttrib & (1 << ioDirFlg)) == 0)	{		FSSpec	fragSpec;		OSErr	tempErr;		Str255	errName;		Boolean	crap;		UInt32	codeOffset;		UInt32	codeLength;				// it's a file				// 
C++ FSPathMakeRef函数代码示例
C++ FSMDEBUG函数代码示例