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

// ---------------------------------------------------------------------FskErr FskFSFileGetPathInfo(const char *rootpath, const char *filepath, FskFileInfo *itemInfo) {	int err;	STATTYPE statbuf;	char	*fullpath;	err = FskMemPtrNew(FskStrLen(rootpath) + FskStrLen(filepath) + 2, (FskMemPtr*)(void*)&fullpath);	if (err)		return err;	FskStrCopy(fullpath, rootpath);	FskStrCat(fullpath, "/");	FskStrCat(fullpath, filepath);	err = STAT(fullpath, &statbuf);	if (err == -1) {		err = errnoToFskErr(errno);		goto bail;	}	GetFileInfoFromStat(&statbuf, itemInfo);bail:	FskMemPtrDispose(fullpath);	if (err)		FskMemSet(itemInfo, 0, sizeof(*itemInfo));	return err;}

// ---------------------------------------------------------------------FskErr FskFSFileOpen(const char *fullPath, UInt32 permissions, FskFSFile *frefOut) {	FskErr		err;	FskFSFile	fref;	FskFileInfo itemInfo;	if (frefOut)		*frefOut = NULL;	err = sCheckFullPath(fullPath, kFskPathIsFile);	BAIL_IF_ERR(err);	err = FskFSFileGetFileInfo(fullPath, &itemInfo);	BAIL_IF_ERR(err);	if (itemInfo.filetype == kFskDirectoryItemIsDirectory)		BAIL(kFskErrIsDirectory);	err = FskMemPtrNewClear(sizeof(FskFSFileRecord), (FskMemPtr*)(void*)&fref);	BAIL_IF_NONZERO(err, err, kFskErrMemFull);	fref->thePermissions = permissions;	fref->theFile = FOPEN(fullPath, sPermsToPermStr(permissions));	if (!fref->theFile) {		FskMemPtrDispose(fref);		BAIL(errnoToFskErr(errno));	}	*frefOut = fref;	bail:	return err;}

// ---------------------------------------------------------------------FskErr FskFSVolumeIteratorDispose(FskFSVolumeIterator volIt){	if (volIt)		FskMemPtrDispose(volIt);	return kFskErrNone;}

void unpackAndroid() {	char * src, *dst, buf[4096];	int doit=0;	UInt32 amt, amtWrt;	FskFileInfo info, infoSrc;	FskFile srcFref, dstFref;	FskErr err;	dst = FskStrDoCat(gAndroidCallbacks->getStaticDataDirCB(), "ca-bundle.crt");	src = FskStrDoCat(gAndroidCallbacks->getStaticAppDirCB(), "/res/raw/kinoma.jet/ca-bundle.crt");	if (kFskErrFileNotFound == FskFileGetFileInfo(dst, &info)) {		fprintf(stderr, "dst: %s not found/n", dst);		doit = 1;	}	else if (kFskErrNone == FskFileGetFileInfo(src, &infoSrc)) {		if (infoSrc.filesize != info.filesize) {			fprintf(stderr, "src size: %lld, dstSize: %lld/n", infoSrc.filesize, info.filesize);			doit = 1;		}	}	if (doit) {		fprintf(stderr, "Need to copy it over./n");		err = FskFileOpen(src, kFskFilePermissionReadOnly, &srcFref);		if (err) fprintf(stderr, "open %s failed %d/n", src, err);		err = FskFileCreate(dst);		if (err) fprintf(stderr, "create %s failed %d/n", dst, err);		err = FskFileOpen(dst, kFskFilePermissionReadWrite, &dstFref);		if (err) fprintf(stderr, "open %s failed %d/n", dst, err);		while (kFskErrNone == err) {			err = FskFileRead(srcFref, 4096, buf, &amt);			if (err) fprintf(stderr, "read %s (%lu bytes) failed %d/n", src, amt, err);			if (0 >= amt)				break;			while (amt) {				err = FskFileWrite(dstFref, amt, buf, &amtWrt);				if (err) fprintf(stderr, "write %s (%lu bytes) failed %d/n", dst, amt, err);				amt -= amtWrt;			}		}		err = FskFileClose(dstFref);		if (err) fprintf(stderr, "close %s failed %d/n", src, err);		err = FskFileClose(srcFref);		if (err) fprintf(stderr, "close %s failed %d/n", src, err);	}	FskMemPtrDispose(src);	FskMemPtrDispose(dst);}

FskErr loadGrammar(const char *xsbPath, xsGrammar *theGrammar){	FskErr err;	FskFile fref = NULL;	UInt32 atom[2];	err = FskFileOpen(xsbPath, kFskFilePermissionReadOnly, &fref);	if (err) goto bail;	err = FskFileRead(fref, sizeof(atom), atom, NULL);	if (err) goto bail;	atom[0] = FskEndianU32_BtoN(atom[0]);	atom[1] = FskEndianU32_BtoN(atom[1]);	if (atom[1] == 'XS11') {		SInt32 totalSize = (SInt32)atom[0] - sizeof(atom);		while (totalSize > 0) {			UInt32 blockSize;			char *block;			err = FskFileRead(fref, sizeof(atom), atom, NULL);			if (err) break;			atom[0] = FskEndianU32_BtoN(atom[0]);			atom[1] = FskEndianU32_BtoN(atom[1]);			totalSize -= atom[0];			blockSize = atom[0] - sizeof(atom);			err = FskMemPtrNew(blockSize, &block);			if (err) break;			err = FskFileRead(fref, blockSize, block, NULL);			if (err) break;			switch (atom[1]) {				case 'SYMB':					theGrammar->symbols = block;					theGrammar->symbolsSize = blockSize;					break;				case 'CODE':					theGrammar->code = block;					theGrammar->codeSize = blockSize;					break;				default:					FskMemPtrDispose(block);					err = kFskErrBadData;					break;			}		}	}	else		err = kFskErrBadData;bail:	FskFileClose(fref);	return err;}

static FskErrFillJaggyPolygonContours(	UInt32					nContours,	const UInt32			*nPts,	const FskFixedPoint2D	*pts,	const FskColorSource	*colorSource,	SInt32					fillRule,	const FskFixedMatrix3x2	*M,	FskConstRectangle		clipRect,	FskBitmap				dstBM){	FskRectangleRecord	dstRect;	LinkedEdge			edges[MAX_EDGES], *pEdges = edges;	/* Small polygons use auto edges, large ones need to be alloc'ed */	UInt32				numEdges, totPts;	FskSpan				span;	FskErr				err = kFskErrNone;	SInt32				n;	const UInt32		*np;	LinkedEdge			*pe;	static FskInitSpanProc	initProcs[] = {								FskInitSolidColorSpan,								FskInitLinearGradientSpan,								FskInitRadialGradientSpan,								FskInitTextureSpan,								NULL						/* Procedure span is not yet implemented */							};	FskInitSpanProc		initSpan;	if (clipRect == NULL)	dstRect = dstBM->bounds;	else					if (!FskRectangleIntersect(&dstBM->bounds, clipRect, &dstRect)) return kFskErrNothingRendered;	for (n = nContours, np = nPts, totPts = 0; n--; )		totPts += *np++;	FskInitSpan(&span, dstBM, sizeof(LinkedEdge));										/* Generic span init */	initSpan =  initProcs[((n = colorSource->type) <= kFskColorSourceTypeMax) ? n : 0];	if ((err = (*initSpan)(&span, dstBM, M, 0, colorSource)) != kFskErrNone)			/* Specialized span init - this may bump up the edge size */		return err;	span.edgeBytes = (span.edgeBytes + 3) & ~3;											/* Ceil up to multiple of 4 bytes */	if (	CANT_USE_AUTO_EDGES(totPts)																							/* Either small enough for auto storage ... */		&&	(err = (FskMemPtrNew(totPts * CLIP_MULTIPLIER * sizeof(LinkedEdge), (FskMemPtr*)(void*)(&pEdges))) != kFskErrNone)	/* ... or we can allocate memory */	)		return err;																		/* Polygon is too big to render */	for (numEdges = 0, pe = pEdges; nContours--; pts += *nPts++, numEdges += n, pe += n)		BAIL_IF_NEGATIVE(n = TransformClipAndMakeEdges(*nPts, pts, M, &dstRect, &span, pe), err, kFskErrMemFull);	BAIL_IF_FALSE(numEdges >= 2, err, kFskErrNothingRendered);	err = ScanConvertLinkedEdges(numEdges, pEdges, fillRule, &span);bail:	if (pEdges != edges)		FskMemPtrDispose(pEdges);	/* Deallocate big polygon edges */	if ((span.disposeSpanData != NULL) && (span.spanData != NULL))		span.disposeSpanData(span.spanData);	return err;}

static voidkcl_int_free(cint_t *ai){	if (ai->cint_data != NULL) {		FskMemPtrDispose(ai->cint_data);		ai->cint_data = NULL;	}}

void mraaPWMDispose(FskPinPWM pin){	mraaPWM mpwm = (mraaPWM)pin;	mraaPWMSetDutyCycle(pin, 0);	mraa_pwm_enable(mpwm->context, 0);	mraa_pwm_close(mpwm->context);	FskMemPtrDispose(mpwm);}

FskErr androidAudioOutDispose(FskAudioOut audioOut) {	androidAudioExt *ext;	FskAudioNativePrintfVerbose("audioOutDispose %x", audioOut);	if (audioOut == NULL)		return kFskErrNone;	ext = (androidAudioExt*)audioOut->ext;	FskAudioNativePrintfVerbose("audioOutDispose ext is %x", ext);	if (ext) {		androidAudioOutStop(audioOut);audioOut->ext = 0;		FskListMutexRemove(audioOuts, audioOut);		FskAudioNativePrintfDebug("removing audioOut->blocks list %x", audioOut->blocks);		FskListMutexDispose(audioOut->blocks);		FskMutexDispose(ext->getSamplePositionMutex);		if (ext->playItf) {			SLresult	res; 			FskAudioNativePrintfDebug("before delete ext->playItf: %x", ext->playItf);			res = (*ext->playItf)->SetPlayState(ext->playItf, SL_PLAYSTATE_STOPPED);			CheckErr("audioOutDispose - set playstate STOPPED", res);			res = (*ext->bufferQueueItf)->Clear(ext->bufferQueueItf);			CheckErr("audioOutDispose - calling clear on bufferQueue", res); 			FskAudioNativePrintfDebug("after delete ext->playItf: %x", ext->playItf); 		}		if (ext->audioBuf[0])			FskMemPtrDispose(ext->audioBuf[0]);		if (ext->audioBuf[1])			FskMemPtrDispose(ext->audioBuf[1]);		if (ext->player != NULL)			(*ext->player)->Destroy(ext->player);		if (ext->outputMixObject != NULL)			(*ext->outputMixObject)->Destroy(ext->outputMixObject);		FskMemPtrDispose(ext);	}	FskMemPtrDispose(audioOut);	return kFskErrNone;}

void xs_i2c(void *data){    if (data) {        xsI2C i2c = data;        FskPinI2CDispose(i2c->pin);        FskMemPtrDispose(i2c);    }}

FskErr KplSemaphoreDispose(KplSemaphore sem){	if (sem) {		sem_destroy(&sem->hSem);		FskMemPtrDispose(sem);	}	return kFskErrNone;}

// ---------------------------------------------------------------------FskErr FskFSFileClose(FskFSFile fref) {	if (fref) {		fclose(fref->theFile);		FskMemPtrDispose(fref);	}	return kFskErrNone;}

FskErr FskFSFileTerminate(){	if (gStatFS != NULL) {		FskMemPtrDispose(gStatFS);		gStatFS = NULL;	}	return kFskErrNone;}

void KplTimeCallbackDispose(KplTimeCallback callback){	if (NULL == callback)		return;	KplTimeCallbackCancel(callback);	FskMemPtrDispose(callback);}

void KprHTTPConnectionDispose(KprHTTPConnection self){	if (self->client) {		KprHTTPConnectionClose(self);	}	FskInstrumentedItemDispose(self);	FskMemPtrDispose(self);}

FskErr KplAudioDispose(KplAudio audio){	FskErr err = kFskErrNone;    if (!audio) goto bail;	if (audio->thread) {		audio->stopping = true;		FskThreadJoin(audio->thread);	}	KplMutexDispose(audio->mutex);	audio->mutex = NULL;	FskMemPtrDispose(audio->data);	FskMemPtrDispose(audio);bail:	return err;}

void KprDebugDispose(KprDebug self){	if (self) {		KprDebugClose(self);		FskInstrumentedItemDispose(self);		FskMemPtrDispose(self);	}}

void KPR_Message(xsMachine* the){	xsStringValue url = NULL;	KprMessage self = NULL;	xsTry {		xsThrowIfFskErr(KprMessageURL(xsGetContext(the), xsToString(xsArg(0)), &url));		xsThrowIfFskErr(KprMessageNew(&self, url));		xsSetHostData(xsThis, self);		FskInstrumentedItemSendMessageDebug(self, kprInstrumentedMessageConstruct, self);		self->usage++; // host		FskMemPtrDispose(url);	}	xsCatch {		FskMemPtrDispose(url);		xsThrow(xsException);	}}

void on_drag_data_received(GtkWidget* widget, GdkDragContext* context, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data){	FskGtkWindow gtkWin = user_data;	gboolean dnd_success = FALSE;	FskDragDropFile dropFileList = NULL;	FskDragDropFile droppedFile = NULL;	char* path = NULL;	if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_COPY) {		char* string = (char*)gtk_selection_data_get_data(data);		char* end;		FskFileInfo itemInfo;		for (end = FskStrStr(string, "/r/n"); end; end = FskStrStr(string, "/r/n")) {			BAIL_IF_ERR(FskMemPtrNewClear(sizeof(FskDragDropFileRecord), (FskMemPtr*)&droppedFile));			FskListAppend((FskList *)&dropFileList, droppedFile);			*end = 0;			BAIL_IF_ERR(KprURLToPath(string, &path));			BAIL_IF_ERR(FskFileGetFileInfo(path, &itemInfo));			if (itemInfo.filetype == kFskDirectoryItemIsDirectory) {				int length = FskStrLen(path);				BAIL_IF_ERR(FskMemPtrNew(length + 2, &droppedFile->fullPathName));				FskMemCopy(droppedFile->fullPathName, path, length);				droppedFile->fullPathName[length] = '/';				droppedFile->fullPathName[length + 1] = 0;				FskMemPtrDispose(path);			}			else {				droppedFile->fullPathName = path;			}			path = NULL;			string = end + 2;			*end = '/r';		}		(*gDropTargetProc)(kFskDragDropTargetEnterWindow, x, y, dropFileList, gtkWin->owner);		(*gDropTargetProc)(kFskDragDropTargetDropInWindow, x, y, dropFileList, gtkWin->owner);		dnd_success = TRUE;	}bail:	gtk_drag_finish(context, dnd_success, TRUE, time);	FskMemPtrDispose(path);	while (NULL != dropFileList) {		droppedFile = dropFileList;		FskListRemove((FskList *)&dropFileList, droppedFile);		FskMemPtrDispose(droppedFile->fullPathName);		FskMemPtrDispose(droppedFile);	}}

void KprSSDPClientDispose(KprSSDPClient self){	if (!self) return;	if (FskListContains(&gKprSSDPClients, self)) {		(void)KprSSDPClientStop(self);	}	if (self->services) {		UInt32 i;		for (i = 0; self->services[i]; i++) {			FskMemPtrDispose(self->services[i]);		}		FskMemPtrDispose(self->services);	}	FskMemPtrDispose(self->type);	FskInstrumentedItemDispose(self);	FskMemPtrDispose(self);}

FskErr KplDirectoryIteratorNew(const char *directoryPath, UInt32 flags, KplDirectoryIterator *dirIt){	KplDirectoryIterator di = NULL;	FskErr	err;	KplFileInfo itemInfo;	if (directoryPath[FskStrLen(directoryPath) -1] != '/') {		err = kFskErrInvalidParameter;		goto bail;	}	err = KplFileGetFileInfo(directoryPath, &itemInfo);	if (err) goto bail;	if (itemInfo.filetype != kKplDirectoryItemIsDirectory) {		err = kFskErrNotDirectory;		goto bail;	}	err = FskMemPtrNew(sizeof(KplDirectoryIteratorRecord), (FskMemPtr*)&di);	if (err != kFskErrNone)		return err;    di->flags = flags;	di->root = (unsigned char *)FskStrDoCopy(directoryPath);	di->theDir = opendir(directoryPath);	if (di->theDir == NULL) {		FskMemPtrDispose(di->root);		err = errnoToFskErr(err);		goto bail;	}	*dirIt = (KplDirectoryIterator)di;	err = kFskErrNone;bail:	if (err) {		if (di && di->root)			FskMemPtrDispose(di->root);		if (di)			FskMemPtrDispose(di);	}	return err;}

    // t7 like platform - TODOvoid scanVolumes() {	int err;	volInfo	vi, walker;	struct statfs fsinfo;// ROOT	FskMemPtrNewClear(sizeof(volInfoRec), &vi);	vi->type = kKplVolumeTypeFixed;	vi->removable = false;	vi->mounted = true;	vi->typeStr = FskStrDoCopy("ext4");	vi->mountPoint = FskStrDoCopy("//0");	vi->name = FskStrDoCopy("//0");	err = statfs("/", &fsinfo);	vi->capacity = fsinfo.f_blocks * fsinfo.f_bsize;	vi->remaining = fsinfo.f_bavail * fsinfo.f_bsize;	vi->fsid = fsinfo.f_fsid;	FskListAppend(&volumeList, vi);//fprintf(stderr, " fsid: %d:%d, capacity: %d, remaining: %d/n", vi->fsid.__val[0], vi->fsid.__val[1], vi->capacity, vi->remaining);// SDCARD - there may be a better way to do this	FskMemPtrNewClear(sizeof(volInfoRec), &vi);	vi->type = kKplVolumeTypeSDMemory;	vi->removable = true;	vi->mounted = true;	vi->typeStr = FskStrDoCopy("vfat");	vi->mountPoint = FskStrDoCopy("/mnt/external_sdcard//0");	vi->name = FskStrDoCopy("sdcard/0");	vi->fsid.__val[0] = -1;	vi->fsid.__val[1] = -1;	err = statfs("/mnt/sdcard", &fsinfo);	if (0 == err) {		walker = volumeList;		while (walker) {			if ((fsinfo.f_fsid.__val[0] == walker->fsid.__val[0])				&& (fsinfo.f_fsid.__val[1] == walker->fsid.__val[1])) {				// same fsid - it's not a different mount				break;			}			walker = walker->next;		}		if (!walker) {		// didn't find an entry with the same fsid			vi->mounted = true;			vi->fsid = fsinfo.f_fsid;			vi->capacity = fsinfo.f_blocks * fsinfo.f_bsize;			vi->remaining = fsinfo.f_bavail * fsinfo.f_bsize;//fprintf(stderr, " fsid: %d:%d, capacity: %d, remaining: %d/n", vi->fsid.__val[0], vi->fsid.__val[1], vi->capacity, vi->remaining);		}	}	if (vi->fsid.__val[0] == -1 && vi->fsid.__val[1] == -1) {		FskMemPtrDispose(vi);	}	else		FskListAppend(&volumeList, vi);}

void mraaDigitalDispose(FskPinDigital pin){	mraaDigital md = (mraaDigital)pin;	if (md->context)		mraa_gpio_close(md->context);	FskMemPtrDispose(pin);}

void KPR_mergeURI(xsMachine *the){	xsStringValue base = xsToString(xsArg(0));	xsStringValue url = xsToString(xsArg(1));	xsStringValue target;	xsThrowIfFskErr(KprURLMerge(base, url, &target));	xsResult = xsString(target);	FskMemPtrDispose(target);}

FskErr KplMutexDispose(KplMutex mutex){	if (mutex) {		pthread_mutex_destroy(&mutex->mutex);		FskMemPtrDispose(mutex);	}	return kFskErrNone;}

FskErr winTextDispose(FskTextEngineState state){	if (state) {		DeleteDC(state->dc);		FskMemPtrDispose(state);	}	return kFskErrNone;}

FskErr FskHTTPServerListenerDispose(FskHTTPServerListener listener) {	FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerListenerDispose - listener: %p/n", listener);	if (listener) {		if (listener->http && listener->http->listeners)			FskListRemove((FskList*)&listener->http->listeners, listener);		if (listener->handshaking) {			FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerListenerDispose - listener: %p - wait for handshaking/n", listener);			listener->http = NULL;		}		else {			FskThreadRemoveDataHandler(&listener->dataHandler);			FskNetSocketClose(listener->skt);			FskMemPtrDispose(listener->ifcName);			FskMemPtrDispose(listener);		}	}	return kFskErrNone;}

void KprZeroconfServiceForget(KprService self, char* authority, char* id){	FskErr err = kFskErrNone;	char* type = NULL;	KprZeroconfBrowser browser = NULL;	bailIfError(KprZeroconfServiceNewType(id, &type));	browser = KprZeroconfBrowserFind(gKprZeroconfBrowsers, type);	if (browser) {		FskListRemove(&gKprZeroconfBrowsers, browser);		bailIfError(KprZeroconfBrowserStop(browser));		KprZeroconfBrowserDispose(browser);	}bail:	FskMemPtrDispose(type);	FskMemPtrDispose(authority);	FskMemPtrDispose(id);	return;}

void KprLibrarySessionDispose(KprLibrarySession self){    if (self) {        if (self->file.file)            KprFileServerClose(self);        else if (self->http.client)            KprProxyServerClose(self);        else            KprDataServerClose(self);        FskMemPtrDispose(self->authorization);        FskMemPtrDispose(self->url);        FskMemPtrDispose(self->mime);        FskMemPtrDispose(self->info);        FskHTTPServerRequestSetRefcon(self->request, NULL);        FskInstrumentedItemDispose(self);        KprMemPtrDispose(self);    }}

void fxOpenProfileFile(txMachine* the, char* theName){ 	FskFile fref;	char *applicationPath = NULL;	char *profilePath = NULL;	if (the->profileDirectory)		profilePath = FskStrDoCat(the->profileDirectory, theName);	else {		applicationPath = FskEnvironmentDoApply(FskStrDoCopy("[applicationPath]"));		profilePath = FskStrDoCat(applicationPath, theName);	}	FskFileDelete(profilePath);	FskFileCreate(profilePath);	if (kFskErrNone == FskFileOpen(profilePath, kFskFilePermissionReadWrite, &fref))		the->profileFile = fref;	FskMemPtrDispose(profilePath);	FskMemPtrDispose(applicationPath);}