// --------------------------------------------------------------------- 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 FskErr FillJaggyPolygonContours( 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 void kcl_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 - TODO void 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); }