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

static recDevice *HIDBuildDevice (io_object_t hidDevice){	recDevice *pDevice = (recDevice *) NewPtrClear (sizeof (recDevice));	if (pDevice)	{		/* get dictionary for HID properties */		CFMutableDictionaryRef hidProperties = 0;		kern_return_t result = IORegistryEntryCreateCFProperties (hidDevice, &hidProperties, kCFAllocatorDefault, kNilOptions);		if ((result == KERN_SUCCESS) && hidProperties)		{			/* create device interface */			result = HIDCreateOpenDeviceInterface (hidDevice, pDevice);			if (kIOReturnSuccess == result)			{				HIDGetDeviceInfo (hidDevice, hidProperties, pDevice); /* hidDevice used to find parents in registry tree */				HIDGetCollectionElements (hidProperties, pDevice);			}			else			{				DisposePtr((Ptr)pDevice);				pDevice = NULL;			}			CFRelease (hidProperties);		}		else		{			DisposePtr((Ptr)pDevice);			pDevice = NULL;		}	}	return pDevice;}

OSErr NetDDPCloseSocket(    short socketNumber){    OSErr error= noErr;    if (ddpPacketBuffer)    {        MPPPBPtr myMPPPBPtr= (MPPPBPtr) NewPtrClear(sizeof(MPPParamBlock));        error= MemError();        if (error==noErr)        {            myMPPPBPtr->DDP.socket= socketNumber;            error= PCloseSkt(myMPPPBPtr, FALSE);            DisposePtr((Ptr)ddpPacketBuffer);            ddpPacketBuffer= (DDPPacketBufferPtr) NULL;            DisposePtr((Ptr)myMPPPBPtr);        }    }    return error;}

int asyncFileClose(AsyncFile *f) {  /* Close the given asynchronous file. */	AsyncFileState *state;	short int volRefNum;	OSErr err;	if (!asyncFileValid(f)) return 0;  /* already closed */	state = f->state;	err = GetVRefNum(state->refNum, &volRefNum);	success(err == noErr);	err = FSClose(state->refNum);	success(err == noErr);	if (!interpreterProxy->failed()) err = FlushVol(NULL, volRefNum);	success(err == noErr);    if (asyncFileCompletionProc != nil)        DisposeIOCompletionUPP(asyncFileCompletionProc);  	asyncFileCompletionProc = nil;	if (state->bufferPtr != nil) DisposePtr(state->bufferPtr);	DisposePtr((void *) f->state);	f->state = nil;	f->sessionID = 0;	return 0;}

/*__________________________________________________________________________*/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;}

Boolean RemoveElement(LinkedList *listPtr,unsigned long num){	ElementHandle	moo=listPtr,last=0L;	unsigned long	count=0;		while((*moo) && (count!=num))	{		count++;		last=moo;		moo=(ElementHandle)&((**moo).next);	}		if (*moo) // if this is 0L then n wasn't in the list	{		Ptr		dataPtr=(**moo).data;		Ptr		entityPtr=(Ptr)*moo;				// got it, delete it		if (last==0L) // if last==0L then this was the first element in the list			*listPtr=(ElementPtr)(**moo).next; // the start is the next one (which is null if this was also the last one in the list)		else			(**last).next=(**moo).next; // bypass element moo (element n)				// Free up the ram		DisposePtr(dataPtr);		DisposePtr(entityPtr);		return true; // it's gone	}	else		return false;}

OSErr PPMADInfoFile( char	*AlienFile, PPInfoRec	*InfoRec){	MADSpec		*theMAD;	long			fileSize;	short			fileID;		theMAD = (MADSpec*) NewPtr( sizeof( MADSpec) + 200);			fileID = iFileOpen( AlienFile);	if( !fileID)	{		DisposePtr( (Ptr) theMAD);		return -1;	}	fileSize = iGetEOF( fileID);			iRead( sizeof( MADSpec), (Ptr) theMAD, fileID);	iClose( fileID);			strcpy( InfoRec->internalFileName, theMAD->name);		InfoRec->totalPatterns = theMAD->numPat;	InfoRec->partitionLength = theMAD->numPointers;	InfoRec->totalTracks = theMAD->numChn;	InfoRec->signature = 'MADK';	strcpy( InfoRec->formatDescription, "MADK");	InfoRec->totalInstruments = theMAD->numInstru;	InfoRec->fileSize = fileSize;			DisposePtr( (Ptr) theMAD);		theMAD = NULL;			return noErr;}

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;        }    }}

void ottcp_free(OTTCP *x) {	freeobject(x->o_clock);	freeobject(x->o_connectedclock);    if (x->o_tcp_ep != 0) {		OTCloseProvider(x->o_tcp_ep);	}		DisposePtr(x->o_ReadBufA);	DisposePtr(x->o_ReadBufB);	DisposePtr(x->o_WriteBuf);}

void*SinkerNew(	SymbolPtr,	short		iArgC,	Atom		iArgV[])		{	const float kDefVal = 0.0;		short			valCount = (iArgC > 0) ? iArgC : 1;	objSinker*		me	= NIL;	tCurPendPair*	vals = (tCurPendPair*) NewPtrClear(valCount * sizeof(tCurPendPair));	tSampleVector*	inSigs = (tSampleVector*) NewPtrClear(valCount * sizeof(tSampleVector));	tSampleVector*	outSigs = (tSampleVector*) NewPtrClear(valCount * sizeof(tSampleVector));		if (vals == NIL || inSigs == NIL || outSigs == NIL) {		// Quick punt before any damage can be done		if (vals != NIL) DisposePtr((Ptr) vals);		if (inSigs != NIL) DisposePtr((Ptr) inSigs);		if (outSigs != NIL) DisposePtr((Ptr) outSigs);		return NIL;			}							// Let Max/MSP allocate us and inlets	me = (objSinker*) newobject(gObjectClass);		// Add outlets, right to left, and initialize values	if (iArgC == 0) {		// Default to two inlets, one outlet		dsp_setup(&me->coreObject, 2);		outlet_new(me, "signal");		// Don't actually need to initialize as long as kDefVal is zero		// vals[0].current = vals[0].pending = kDefVal;				}	else {		dsp_setup(&me->coreObject, iArgC + 1);		while (--iArgC >= 0) {			outlet_new(me, "signal");			vals[iArgC].current = vals[iArgC].pending = AtomGetFloat(&iArgV[iArgC]);			}		}		// My own initialization. Do this now before we lose the value of iArgCount	me->lastSync	= 0.0;	me->valCount	= valCount;	me->mode		= trigDef;	me->vals		= vals;	me->inSigs		= inSigs;	me->outSigs		= outSigs;	punt:	return me;	}

voidTclMacExitHandler(){    ExitToShellUPPListPtr curProc;    /*     * Loop through all installed Exit handlers     * and call them.  Always make sure we are in     * a clean state in case we are recursivly called.     */    if ((gExitToShellData) != NULL && (gExitToShellData->userProcs != NULL)){    	/*	 * Call the installed exit to shell routines.	 */	curProc = gExitToShellData->userProcs;	do {	    gExitToShellData->userProcs = curProc->nextProc;	    CallExitToShellProc(curProc->userProc);	    DisposeExitToShellProc(curProc->userProc);	    DisposePtr((Ptr) curProc);	    curProc = gExitToShellData->userProcs;	} while (curProc != (ExitToShellUPPListPtr) NULL);    }    return;}

/* Do a gamma fade to the color provided over the time period desired	*/OSStatus FadeToColorMultiple( 	ScreenRef *screens, 								unsigned int count, 								const RGBColor *color, 								float seconds ){	RLGammaTable	*newGammas = (RLGammaTable*) NewPtr( count * sizeof( RLGammaTable ) );	if( NULL == newGammas )		return rlOutOfMemory;		//Generate new gamma tables from the provided color	float red = float( color->red ) / 65535.0;	float green = float( color->green ) / 65535.0;	float blue = float( color->blue ) / 65535.0;	for( int i = 0; i < count; i++ )	{		for( int j = 0; j < kGammaTableEntryCount; j++ )		{			newGammas[i].red[j] = red;			newGammas[i].green[j] = green;			newGammas[i].blue[j] = blue;			}	}		OSStatus err = FadeToGammaMultiple( screens, count, newGammas, seconds );	DisposePtr( (Ptr) newGammas );	return err;}

ALAPI ALvoid ALAPIENTRY alSourceStop (ALuint source){	QueueEntry *pQE;	#ifndef MAC_OS_X	smSourceFlushAndQuiet(source);#endif		gSource[source].state = AL_STOPPED;	gSource[source].readOffset = 0;        if (gSource[source].pCompHdr != NULL) {#ifdef MAC_OS_X            free(gSource[source].pCompHdr);#else            DisposePtr(gSource[source].pCompHdr);#endif            gSource[source].pCompHdr = NULL;        }        gSource[source].uncompressedReadOffset = 0;#ifdef MAC_OS_X        gSource[source].uncompressedBufferOffset = 0;#endif		pQE = gSource[source].ptrQueue; // reset all processed flags	while (pQE != NULL)	{	    gSource[source].srcBufferNum = 0; // will play the null-buffer, then process queue...	 	pQE->processed = AL_FALSE;	 	pQE = pQE->pNext;	}}

OSErr BigSendAppleEvent(TargetID *targ,AEEventClass aeClass,AEEventID aeID,Ptr *data,short dataLen,DescType dataType,Boolean returnData,Boolean checkForHandlerErr){	AEAddressDesc	targDesc={typeNull, nil};	// Desc for target	AppleEvent		appOut={typeNull, nil},appIn={typeNull, nil};	short			sendMode=kAENeverInteract;	OSErr			err;										if (returnData || checkForHandlerErr)		sendMode+=kAEWaitReply;	else		sendMode+=kAENoReply;										// Create the address desriptor	err=AECreateDesc(typeTargetID,(Ptr)targ,sizeof(TargetID), &targDesc);	if (err)		return err;			// now create the apple event which will be sent	err=AECreateAppleEvent(aeClass,aeID,&targDesc,kAutoGenerateReturnID,kAnyTransactionID,&appOut);		if (err)	{		AEDisposeDesc(&targDesc);		return err;	}		if (data && *data)	{		err=AEPutParamPtr(&appOut,keyDirectObject,typeChar,*data,dataLen);		DisposePtr(*data);		*data=0L;		if (err)		{			AEDisposeDesc(&appOut);			AEDisposeDesc(&targDesc);		}	}			// Send the apple event		err=AESend(&appOut,&appIn,sendMode,kAENormalPriority,kAEDefaultTimeout,0L,0L);			if (err)	{		AEDisposeDesc(&appOut); 		// get rid of the apple events		AEDisposeDesc(&appIn);		AEDisposeDesc(&targDesc);	// and the address descriptor	}			if (returnData) // get info from reply event		err=FetchParamAnySize(keyDirectObject,&appIn,data,dataType);		// Get the error returned if any	if (!err && checkForHandlerErr)		err=FetchAEErr(&appIn);		// The apple event has been sent, dispose of descriptors	AEDisposeDesc(&appOut); 		// get rid of the apple events	AEDisposeDesc(&appIn);	AEDisposeDesc(&targDesc);	// and the address descriptor		return err;}

void NetDDPDisposeFrame(    DDPFramePtr frame){    DisposePtr((Ptr)frame);    return;}

/*	KillPopMenus(theDialog) 	Call when exiting the dialog, before calling DisposeXOPDialog. 	 	The menu handles associated with popup controls are automatically deleted 	by the controls because we use SetControlData(...kControlPopupButtonOwnedMenuRefTag...). 	However, we need to do some bookkeeping here to keep track of which menu IDs are 	free for use in popup menus. This bookkeeping is complicated by the possibility 	of subdialogs.	Thread Safety: KillPopMenus is not thread-safe.*/voidKillPopMenus(DialogPtr theDialog){	int i;		if (gPopMenuInfoP == NULL)		return;								// Would happen if you did not create any popup menus.		// Mark menu IDs used for this dialog as free so they can be reused for another dialog.	for(i=0; i<MAX_POPUP_MENUS; i++) {		if (gPopMenuInfoP[i].theDialog == theDialog) {	// This is the dialog for which the menu was created?			gPopMenuInfoP[i].theDialog = NULL;			gPopMenuInfoP[i].menuID = 0;		}	}	/*	Now see if gPopMenuInfoP is no longer needed. If we just disposed a subdialog,		it is still needed for the parent dialog.	*/	{		int infoStillNeeded;		infoStillNeeded = 0;		for(i=0; i<MAX_POPUP_MENUS; i++) {			if (gPopMenuInfoP[i].menuID != 0) {				infoStillNeeded = 1;				break;					}		}		if (!infoStillNeeded) {			DisposePtr((Ptr)gPopMenuInfoP);			gPopMenuInfoP = NULL;		}	}}

static recDevice *HIDDisposeDevice(recDevice ** ppDevice){    kern_return_t result = KERN_SUCCESS;    recDevice *pDeviceNext = NULL;    if (*ppDevice) {        /* save next device prior to disposing of this device */        pDeviceNext = (*ppDevice)->pNext;        /* free posible io_service_t */        if ((*ppDevice)->ffservice) {            IOObjectRelease((*ppDevice)->ffservice);            (*ppDevice)->ffservice = 0;        }        /* free element lists */        HIDDisposeElementList(&(*ppDevice)->firstAxis);        HIDDisposeElementList(&(*ppDevice)->firstButton);        HIDDisposeElementList(&(*ppDevice)->firstHat);        result = HIDCloseReleaseInterface(*ppDevice);   /* function sanity checks interface value (now application does not own device) */        if (kIOReturnSuccess != result)            HIDReportErrorNum                ("HIDCloseReleaseInterface failed when trying to dipose device.",                 result);        DisposePtr((Ptr) * ppDevice);        *ppDevice = NULL;    }    return pDeviceNext;}

static pascal voidExitToShellPatchRoutine(){    ExitToShellUPP oldETS;    long oldA5;    /*     * Set up our A5 world.  This allows us to have     * access to our global variables in the 68k world.     */    oldA5 = SetCurrentA5();    SetA5(gExitToShellData->a5);    /*     * Call the function that invokes all     * of the handlers.     */    TclMacExitHandler();    /*     * Call the origional ExitToShell routine.     */    oldETS = gExitToShellData->oldProc;    DisposePtr((Ptr) gExitToShellData);    SetA5(oldA5);    CallExitToShellProc(oldETS);    return;}

void __cdecl _heap_free_region (	REG1 int index	){	struct _heap_region_ *pHeapRegions;	/*	 * Give the memory back to the OS	 */	pHeapRegions = (struct _heap_region_ *)(*hHeapRegions);	if ((pHeapRegions + index)->_regbase)		{		DisposePtr((pHeapRegions + index)->_regbaseCopy);		}	/*	 * Zero out the heap region entry	 */	pHeapRegions = (struct _heap_region_ *)(*hHeapRegions);	(pHeapRegions + index)->_regbase = NULL;	(pHeapRegions + index)->_currsize = 0;	(pHeapRegions + index)->_totalsize = 0;}

// --------------------------------------------------------------------------------------static OSErr getCurrentResourceFSSpec(FSSpec *curResSpec){	OSErr error;	FCBPBPtr fileInfo;		// file control block parameter block pointer	StrFileName fileName;			/* In the age of application packages and bundles, it's less likely that the 		   current resource file is the application file itself.  It's more likely to be 		   a flattened resource file in a bundle so we need a generic method instead of 		   the traditional Process Manager method of getting the current application's 		   FSSpec of it's executable file */	fileInfo = (FCBPBPtr)NewPtr(sizeof(FCBPBRec));		fileInfo->ioNamePtr = fileName;		// to hold the resource file's name	fileInfo->ioVRefNum = 0;			// 0 to search through all open files on all volumes	fileInfo->ioRefNum = CurResFile();	// get info about the main resource file 										// by using its reference number	fileInfo->ioFCBIndx = 0;			// 0 to ignore this parameter and use the 										// ioRefNum parameter instead		error = PBGetFCBInfoSync(fileInfo);	// synchronous because we don't have 						// anything else to do while we're waiting on the filesystem		if (error == noErr)		// if we got the necessary file info, make an FSSpec out of it		FSMakeFSSpec(fileInfo->ioFCBVRefNum, fileInfo->ioFCBParID, fileName, curResSpec);							DisposePtr((Ptr)fileInfo);		return error;}

void QTDR_CloseDownHandlers (void){	if (gDataReader != NULL) {		DataHCloseForRead(gDataReader);		CloseComponent(gDataReader);		gDataReader = NULL;	}	if (gDataWriter != NULL) {		DataHCloseForWrite(gDataWriter);		CloseComponent(gDataWriter);		gDataWriter = NULL;	}		// dispose of the data buffer	if (gDataBuffer != NULL)		DisposePtr(gDataBuffer);			// dispose of the routine descriptors	if (gReadDataHCompletionUPP != NULL)		DisposeDataHCompletionUPP(gReadDataHCompletionUPP);			if (gWriteDataHCompletionUPP != NULL)		DisposeDataHCompletionUPP(gWriteDataHCompletionUPP);		gDoneTransferring = false;	#if TARGET_OS_WIN32	// kill the timer that tasks the data handlers	KillTimer(NULL, gTimerID);#endif}

OSErr grow_buffer(Theora_Globals glob, UInt32 min_size) {    /* increase the size of the packet buffer, in       kPacketBufferAllocIncrement blocks, preserving the content of       the used part of the buffer */    OSErr err = noErr;    UInt32 new_size = glob->p_buffer_len;    dbg_printf("--:Theora:-  _grow_buffer(%08lx, %ld)/n", (long)glob, min_size);    while (new_size < min_size)        new_size += kPacketBufferAllocIncrement;    /* first try to resize in-place */    SetPtrSize((Ptr) glob->p_buffer, new_size);    if (err = MemError()) {        /* resizing failed: allocate new block, memcpy, release the old block */        Ptr p = NewPtr(new_size);        if (err = MemError()) goto bail;        BlockMoveData(glob->p_buffer, p, glob->p_buffer_used);        DisposePtr((Ptr) glob->p_buffer);        glob->p_buffer = (UInt8 *) p;    }    glob->p_buffer_len = new_size; bail:    if (err)        dbg_printf("--:Theora:-  _grow_buffer(%08lx, %ld) failed = %d/n", (long)glob, min_size, err);    return err;}

pascal OSErr MoreFESetComment(const FSSpecPtr pFSSpecPtr, const Str255 pCommentStr, const AEIdleUPP pIdleProcUPP){	AppleEvent tAppleEvent = {		typeNull, nil	};                                              // If you always init AEDescs, it's always safe to dispose of them.	AEBuildError tAEBuildError;	AEDesc tAEDesc = {		typeNull, nil	};	OSErr anErr = noErr;	anErr = MoreAEOCreateObjSpecifierFromFSSpec(pFSSpecPtr, &tAEDesc);	if (noErr == anErr) {		char *dataPtr = NewPtr(pCommentStr[ 0 ]);		CopyPascalStringToC(pCommentStr, dataPtr);		anErr = AEBuildAppleEvent(		        kAECoreSuite, kAESetData,		        typeApplSignature, &gFinderSignature, sizeof( OSType ),		        kAutoGenerateReturnID, kAnyTransactionID,		        &tAppleEvent, &tAEBuildError,		        "'----':obj {form:prop,want:type(prop),seld:type(comt),from:(@)},data:'TEXT'(@)",		        &tAEDesc, dataPtr);		DisposePtr(dataPtr);		if (noErr == anErr) {			// Send the event. In this case we don't care about the reply			anErr = MoreAESendEventNoReturnValue(pIdleProcUPP, &tAppleEvent);			(void) MoreAEDisposeDesc(&tAppleEvent); // always dispose of AEDescs when you are finished with them		}	}	return anErr;}

pascal OSErr MoreAEGetCFStringFromDescriptor(const AEDesc* pAEDesc, CFStringRef* pCFStringRef){  AEDesc    uniAEDesc = {typeNull, NULL};  OSErr    anErr;  if (NULL == pCFStringRef)    return paramErr;  anErr = AECoerceDesc(pAEDesc, typeUnicodeText, &uniAEDesc);  if (noErr == anErr)  {    if (typeUnicodeText == uniAEDesc.descriptorType)    {          Size bufSize = AEGetDescDataSize(&uniAEDesc);          Ptr buf = NewPtr(bufSize);          if ((noErr == (anErr = MemError())) && (NULL != buf))          {              anErr = AEGetDescData(&uniAEDesc, buf, bufSize);              if (noErr == anErr)                  *pCFStringRef = CFStringCreateWithCharacters(kCFAllocatorDefault, (UniChar*) buf, bufSize / (Size) sizeof(UniChar));              DisposePtr(buf);          }    }    MoreAEDisposeDesc(&uniAEDesc);  }  return (anErr);}//end MoreAEGetCFStringFromDescriptor

// Removes a ListElement from the end of the list, copying data if wantedBoolean RemoveLastElement(LinkedList *listPtr){	ElementHandle	moo=listPtr; // address of linked list	if (!*moo) // if the list is empty		return false;		while((**moo).next) // go through list until found second to last element		moo=(ElementHandle)&((**moo).next);			DisposePtr((**moo).data);	DisposePtr((Ptr)*moo);	*moo=0L;		return true;}

boolean openabout (boolean flzoom, long ctreservebytes) {		/*	2.1b5 dmb: added ctreservebytes parameter. of non-zero, caller wants us to 	reserve space in the heap below the dialog record (during initialization)	*/		hdlwindowinfo hinfo;	#ifdef MACVERSION	Ptr ptemp = nil;		if (ctreservebytes > 0)		ptemp = NewPtr (ctreservebytes); /*force about window to load high*/#endif	aboutstart ();		shellpatchnilroutines ();	//	aboutwindow = newmodaldialog (128, -1);	newaboutwindow (true);		if (findaboutwindow (&hinfo))		shellupdatenow ((**hinfo).macwindow);	#ifdef MACVERSION	if (ptemp != nil)		DisposePtr (ptemp); /*restore heap space for remaining code segments*/#endif		aboutopenticks = gettickcount ();		return (true);	} /*openabout*/

OSErr PAS_encodeData(FSSpec *inFile, short outRefNum){	OSErr 		err;		short		inRefNum;	Ptr 		buffer;	SInt32 		currentRead = 	PAS_BUFFER_SIZE;			buffer	=	NewPtr(currentRead);	err = FSpOpenDF(inFile, fsRdPerm, &inRefNum);	if (err != noErr)	return err;		while ( currentRead > 0 )    {		err	= FSRead( inRefNum, &currentRead, buffer);		if (err != noErr && err != eofErr)	return err;				err = FSWrite(outRefNum, &currentRead, buffer);		if (err != noErr)	return err;	}		FSClose(inRefNum);		DisposePtr(buffer);		return noErr;}

int sqCopyFilesizetosize(char *srcNameIndex, int srcNameSize, char *dstNameIndex, int dstNameSize) {	OSErr error;	FSSpec	srcSpec,dstFileSpec,dstSpec;	char *pointer;	const int desiredBufferSize = 64*1024;	FSpLocationFromFullPath(srcNameSize,srcNameIndex,&srcSpec);	FSpLocationFromFullPath(dstNameSize,dstNameIndex,&dstFileSpec);	FSMakeFSSpecCompat(dstFileSpec.vRefNum, dstFileSpec.parID, "/p:", &dstSpec);#if TARGET_API_MAC_CARBON		pointer = NewPtr(desiredBufferSize);#else	    pointer = NewPtr(desiredBufferSize);	    if (pointer == NULL) 		    pointer = NewPtrSys(desiredBufferSize);	    if (pointer == NULL)   			return false; #endif	error = FSpFileCopy(&srcSpec,						&dstSpec,						dstFileSpec.name,						pointer,						desiredBufferSize,						false);	DisposePtr((void *)pointer);	return error;} 

OSErr PAS_encodeResource(FSSpec *inFile, short outRefNum){	OSErr 			err;		short			inRefNum;	PASResFork		resInfo;	SInt32			currentWrite;		ResType 		*resTypes;	long			typeCount;		short			*ids;	long			idCount;		short			oldResFile;		oldResFile=CurResFile();	inRefNum = FSpOpenResFile(inFile, fsRdPerm);	if (inRefNum < noErr)	return inRefNum;	UseResFile(inRefNum);			memset(&resInfo, 0, sizeof(PASResFork));   		PAS_sortTypes(inRefNum, &resTypes, &typeCount);	resInfo.NumberOfTypes	=	typeCount;		currentWrite	= sizeof(PASResFork);		err = FSWrite(outRefNum, &currentWrite, &resInfo);	if (err != noErr)	return err;		for (typeCount = 0; ((typeCount < resInfo.NumberOfTypes) && (err == noErr)); typeCount++)	{		PAS_sortIDs(inRefNum, resTypes[typeCount], &ids, &idCount);		err = PAS_flattenResource(resTypes[typeCount], ids, idCount, inRefNum, outRefNum);		DisposePtr((Ptr)ids);	}		DisposePtr((Ptr)resTypes);			UseResFile(oldResFile);			CloseResFile(inRefNum);		return err;}