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

FskErr FskMuxerTrackNew(FskMuxer muxer, FskMuxerTrack *muxerTrackOut, const char *trackType, UInt32 scale){	FskErr err;	FskMuxerTrack track = NULL;	err = FskMemPtrNewClear(sizeof(FskMuxerTrackRecord) + FskStrLen(trackType) + 1, &track);	BAIL_IF_ERR(err);	track->trackType = (char *)(track + 1);	FskStrCopy(track->trackType, trackType);	track->scale = scale;	track->muxer = muxer;	err = (muxer->dispatch->doNewTrack)(muxer, muxer->state, track, &track->dispatch, &track->state);	BAIL_IF_ERR(err);	FskListAppend((FskList*)(void*)&muxer->tracks, track);bail:	if (kFskErrNone != err) {		FskMuxerTrackDispose(track);		track = NULL;	}	*muxerTrackOut = track;	return err;}

static FskErr FskGPIONew(FskGPIO *gpioOut, int pin, char *pinName, GPIOdirection direction){	FskErr err = kFskErrNone;	FskGPIO gpio = NULL;    err = FskMemPtrNewClear(sizeof(FskGPIORecord), (FskMemPtr *)&gpio);	BAIL_IF_ERR(err);	gpio->pinNum = pin;	gpio->realPin = FskHardwarePinsMux(pin, kFskHardwarePinGPIO);    gpio->thread = FskThreadGetCurrent();	if (gpio->realPin < 0)        BAIL(kFskErrInvalidParameter);    err = FskGPIOPlatformInit(gpio);	BAIL_IF_ERR(err);    if (undefined != direction) {        err = FskGPIOPlatformSetDirection(gpio, direction);        BAIL_IF_ERR(err);    }bail:	if (err && gpio) {        FskGPIOPlatformDispose(gpio);        FskMemPtrDisposeAt(&gpio);	}    *gpioOut = gpio;	return err;}

FskErr FskSemaphoreNew_(FskSemaphore *sem, UInt32 value, FSK_SYNCHRONIZATION_DEBUG_ARGS)#endif{	FskErr err;	err = FskMemPtrNewClear(sizeof(FskSemaphoreRecord), (FskMemPtr *)sem);	BAIL_IF_ERR(err);	err = KplSemaphoreNew((KplSemaphore*)&(*sem)->kplSem, value);	BAIL_IF_ERR(err);	FskInstrumentedItemNew(*sem, NULL, &gFskSemaphoreTypeInstrumentation);#if SUPPORT_INSTRUMENTATION && SUPPORT_SYNCHRONIZATION_DEBUG	if (FskInstrumentedItemHasListeners(*sem)) {		FskSynchronizationInstrMsgRecord msg;		msg.file = file;		msg.line = line;		msg.function = function;		FskInstrumentedItemSendMessage(*sem, kFskSynchronizationInstrMsgSemaphoreNew, &msg);	}#endifbail:	if ((err != kFskErrNone) && (*sem != NULL)) {		KplSemaphoreDispose((*sem)->kplSem);		FskMemPtrDispose(*sem);		*sem = NULL;	}	return err;}

FskErr FskFSVolumeNotifierNew(FskVolumeNotifierCallbackProc callback, void *refCon, FskFSVolumeNotifier *volNtfOut) {	FskErr err;	FskFSVolumeNotifier volNtf = NULL;	FskAndroidFilesPrintfDebug("VolumeNotifierNew/n");	if (NULL == gVolNotifiers) {		err = FskMutexNew(&gVolNotifiersMutex, "volume notifier");		BAIL_IF_ERR(err);	}	err = FskMemPtrNewClear(sizeof(FskFSVolumeNotifierRecord), (FskMemPtr*)(void*)&volNtf);	BAIL_IF_ERR(err);	FskMutexAcquire(gVolNotifiersMutex);	volNtf->dispatch.dispatch = &gFSDispatch;	volNtf->dispatch.refcon = NULL;	volNtf->callback = callback;	volNtf->refCon = refCon;	volNtf->callbackThread = FskThreadGetCurrent();	FskListPrepend(&gVolNotifiers, &volNtf->next);	FskMutexRelease(gVolNotifiersMutex);bail:	*volNtfOut = volNtf;	return err;}

static FskErr sFskNetInterfaceEnumerate(FskNetInterfaceRecord **interfaceList){	FskErr err;	KplNetInterfaceRecord *kplInterfaceList;	*interfaceList = NULL;	err = KplNetInterfaceEnumerate(&kplInterfaceList);	BAIL_IF_ERR(err);	while (kplInterfaceList) {		FskNetInterfaceRecord *nir;		KplNetInterfaceRecord *next = kplInterfaceList->next;		err = FskMemPtrNew(sizeof(FskNetInterfaceRecord), (FskMemPtr*)&nir);		BAIL_IF_ERR(err);		nir->name = FskStrDoCopy(kplInterfaceList->name);		nir->ip = kplInterfaceList->ip;		FskMemMove(nir->MAC, kplInterfaceList->MAC, sizeof(nir->MAC));		nir->status = kplInterfaceList->status;		nir->netmask = kplInterfaceList->netmask;		FskListAppend((FskList*)interfaceList, nir);		FskMemPtrDispose(kplInterfaceList->name);		FskMemPtrDispose(kplInterfaceList);		kplInterfaceList = next;	}bail:	return err;}

FskErr FskMutexNew_uninstrumented(FskMutex *mutex, const char *name){	FskMutex mtx = NULL;	FskErr err;	err = FskMemPtrNewClear(sizeof(FskMutexRecord), (FskMemPtr *)&mtx);	BAIL_IF_ERR(err);	err = KplMutexNew((KplMutex*)&mtx->kplMutex);	BAIL_IF_ERR(err);#if SUPPORT_INSTRUMENTATION	mtx->name = FskStrDoCopy_Untracked(name);#endifbail:	if ((err != kFskErrNone) && (mtx != NULL)) {		KplMutexDispose(mtx->kplMutex);#if SUPPORT_INSTRUMENTATION		FskMemPtrDispose((void*)mtx->name);#endif		FskMemPtrDispose(mtx);		mtx = NULL;	}	*mutex = mtx;	return err;}

FskErr KprDebugMachineNew(KprDebugMachine* it, KprDebug debug, FskSocket skt){	FskErr err = kFskErrNone;	KprDebugMachine self = NULL;	UInt32 ip;	int port;		BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KprDebugMachineRecord), it));	self = *it;	self->debug = debug;	self->socket = skt;	BAIL_IF_ERR(err = FskNetSocketGetRemoteAddress(skt, &ip, &port));	FskNetIPandPortToString(ip, port, self->address);	FskListAppend(&self->debug->machine, self);	FskNetSocketReceiveBufferSetSize(self->socket, kSocketBufferSize);	FskThreadAddDataHandler(&self->reader, (FskThreadDataSource)self->socket, KprDebugMachineDataReader, true, false, self);	bailIfError(KprSocketWriterNew(&self->writer, self->socket, self));	self->writer->errorCallback = KprDebugMachineWriteError;	KprDebugMachineCallbackText(self, "onMachineRegistered", mxNoCommand, NULL);	FskInstrumentedItemNew(self, NULL, &KprDebugMachineInstrumentation);	return err;bail:	KprDebugMachineDispose(self);	return err;}

FskErr FskFSFileRename(const char *fullPath, const char *newName){	int err;	char *p, newPath[PATH_MAX];	FskFileInfo itemInfo;	err = sCheckFullPath(fullPath, kFskPathIsFile);	BAIL_IF_ERR(err);	err = FskFSFileGetFileInfo(fullPath, &itemInfo);	BAIL_IF_ERR(err);	if (itemInfo.filetype == kFskDirectoryItemIsDirectory)		BAIL(kFskErrIsDirectory);	p = FskStrRChr((char *)newName, '/');	if (p)		BAIL(kFskErrOperationFailed);	// newName contains path elements	FskStrCopy(newPath, fullPath);	p = FskStrRChr(newPath, '/');	if (p)		*++p = '/0';	FskStrCat(newPath, newName);	err = rename(fullPath, newPath);	if (err == -1)		BAIL(errnoToFskErr(errno));	err = kFskErrNone;bail:	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;}

static FskErrButtEndCap(const LineSeg *seg, UInt32 end, FskGrowableFixedPoint2DArray array){	FskErr					err;	FskFixedVector2D		v;	FskFixedPoint2D			p;	const FskFixedPoint2D	*center;	v.x = FskFixedNMul(seg->perp.x, seg->strokeWidth, 31);	v.y = FskFixedNMul(seg->perp.y, seg->strokeWidth, 31);	if (!end) {	/* Starting endpoint */		center = &seg->pt[0];	}	else {		/* Ending endpoint */		v.x = -v.x;		v.y = -v.y;		center = &seg->pt[1];	}	p.x = center->x - v.x;	p.y = center->y - v.y;	BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItem(array, &p));	p.x = center->x + v.x;	p.y = center->y + v.y;	BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItem(array, &p));bail:	return err;}

static FskErrBeveledJoin(const LineSeg *seg0, const LineSeg *seg1, FskGrowableFixedPoint2DArray fwdPoly, FskGrowableFixedPoint2DArray revPoly){	FskErr				err			= kFskErrNone;	FskFract			sinAng, cosAng, snmHaf, sinHaf, cosHaf;	FskFixed			bevHafWidth, mitLength, maxElbow;	FskFractVector2D	u;	FskFixedVector2D	b, c, e;	FskFixedPoint2D		p[3];	sinAng = FskFractCrossProduct2D(&seg0->par, &seg1->par);		/* Sine of change in trajectory */	if (sinAng == 0)												/* Collinear */		goto bail;													/* All done */	cosAng = FskFractDotProduct(&seg0->par.x, &seg1->par.x, 2);		/* Cosine of change in trajectory */	if      (cosAng >  FRACT_ONE)	cosAng =  FRACT_ONE;	else if (cosAng < -FRACT_ONE)	cosAng = -FRACT_ONE;	cosHaf =  FskFracSqrt(FRACT_HALF - (cosAng >> 1));				/* Cosine of half the subtended angle */	snmHaf =  FskFracSqrt(FRACT_HALF + (cosAng >> 1));				/* Sine   of half the subtended angle */	if (snmHaf != 0) {		sinHaf = snmHaf;		if (sinAng < 0)	sinHaf = -sinHaf;		u.x = FskFixedNLinear2D(seg0->par.x, cosHaf,  seg0->par.y, sinHaf, 30);	/* Unit vector to elbow, inside or outside */		u.y = FskFixedNLinear2D(seg0->par.y, cosHaf, -seg0->par.x, sinHaf, 30);		bevHafWidth = (FskFixed)(((FskInt64)(seg0->strokeWidth) * cosHaf / (FRACT_ONE + snmHaf) + 1) >> 1);		c.x = FskFixedNMul(seg0->strokeWidth, u.x, 31);				/* Midpoint of bevel */		c.y = FskFixedNMul(seg0->strokeWidth, u.y, 31);		b.x = FskFracMul(bevHafWidth, -u.y);						/* Half-vector of bevel */		b.y = FskFracMul(bevHafWidth,  u.x);		mitLength = FskFixedNDiv(seg0->strokeWidth, snmHaf, 29);		if ((maxElbow = (seg0->strokeWidth)) < seg0->length)		/* Limit the extent of the inside bevel joint */			maxElbow = seg0->length;		if (maxElbow < seg1->length)			maxElbow = seg1->length;		if (mitLength > maxElbow)			mitLength = maxElbow;		e.x = FskFracMul(mitLength, u.x);							/* Scaled vector to elbow, inside */		e.y = FskFracMul(mitLength, u.y);		if (sinAng > 0) {	/* Positive rotation */			p[0].x = seg0->pt[1].x + c.x - b.x;						/* First bevel point */			p[0].y = seg0->pt[1].y + c.y - b.y;			p[1].x = seg0->pt[1].x + c.x + b.x;						/* Second bevel point */			p[1].y = seg0->pt[1].y + c.y + b.y;			p[2].x = seg0->pt[1].x - e.x;							/* Inside elbow */			p[2].y = seg0->pt[1].y - e.y;			BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItems(revPoly, &p[0], 2));			BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItem( fwdPoly, &p[2]));		}		else {				/* Negative rotation */			p[0].x = seg0->pt[1].x + c.x + b.x;						/* First bevel point */			p[0].y = seg0->pt[1].y + c.y + b.y;			p[1].x = seg0->pt[1].x + c.x - b.x;						/* Second bevel point */			p[1].y = seg0->pt[1].y + c.y - b.y;			p[2].x = seg0->pt[1].x - e.x;							/* Inside elbow */			p[2].y = seg0->pt[1].y - e.y;			BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItems(fwdPoly, &p[0], 2));			BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItem( revPoly, &p[2]));		}	}

FskErrFskFramePolygon(	UInt32					nPts,	const FskFixedPoint2D	*pts,	FskFixed				strokeWidth,	FskFixed				jointSharpness,	const FskColorSource	*frameColor,	const FskFixedMatrix3x2	*M,	UInt32					quality,	FskConstRectangle		clipRect,	FskBitmap				dstBM){	FskErr					err;	const FskColorSource	*frameFillColors[2];	if (frameColor->dashCycles != 0)	/* Do special processing for dashed lines: @@@ should have endcap spec for dashes */		return FrameDashedPolyLine(nPts, pts, strokeWidth, jointSharpness, kFskLineEndCapClosed|kFskLineEndCapButt, frameColor, M, quality, clipRect, dstBM);	if (M)	strokeWidth = ScaleStrokeWidth(strokeWidth, M);	if (	(strokeWidth <= FIXED_ONE)		&&	(frameColor->type == kFskColorSourceTypeConstant)	) {		if (quality == 0) {			FskConstColorRGB frColor = (FskConstColorRGB)(void*)(&(((const FskColorSourceConstant*)(void*)frameColor)->color));			err = FrameJaggyNarrowPolyLine(     nPts, pts,   1, frColor,              M, clipRect, dstBM);		} else {			frameFillColors[0] = frameColor;			frameFillColors[1] = NULL;			err = FskAAPolygonContours(1, &nPts, pts, FIXED_ONE, frameFillColors, -1, M, clipRect, dstBM);		}	}	else {		FskGrowableFixedPoint2DArray	pgon		= NULL;		UInt32							n;		FskFixedPoint2D					*p;		BAIL_IF_ERR(err = FskWidePolyLineToPolygon(nPts, pts, strokeWidth, jointSharpness, kFskLineEndCapClosed, M, &pgon));		BAIL_IF_ZERO((n = FskGrowableFixedPoint2DArrayGetItemCount(pgon)), err, kFskErrNothingRendered);		BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayGetPointerToItem(pgon, 0, (void**)(void*)(&p)));		if (quality == 0) {			err = FillJaggyPolygonContours(1, &n, p,     frameColor,      kFskFillRuleNonZero, NULL, clipRect, dstBM);		} else {			frameFillColors[0] = NULL;			frameFillColors[1] = frameColor;			err = FskAAPolygonContours(    1, &n, p, -1, frameFillColors, kFskFillRuleNonZero, NULL, clipRect, dstBM);		}	bail:		if (pgon != NULL)	FskGrowableFixedPoint2DArrayDispose(pgon);	}	return err;}

static FskErr httpServerListenerStart(FskHTTPServerListener listener, FskSocket skt) {	FskErr err = kFskErrNone;	FskHTTPServerRequest request;	if (listener->http->stopped) {		FskInstrumentedItemSendMessage(listener->http, kFskHTTPInstrMsgConnectionRefusedStopped, listener);		listener->http->stats.connectionsRefused++;		FskNetSocketClose(skt);		goto bail;	}			err = FskMemPtrNewClear(sizeof(FskHTTPServerRequestRecord), (FskMemPtr*)&request);	BAIL_IF_ERR(err);	sFskHTTPServerRequestUpUse(request);	request->http = listener->http;	request->skt = skt;		FskNetSocketGetRemoteAddress(skt, (UInt32 *)&request->requesterAddress, &request->requesterPort);	FskNetSocketMakeNonblocking(request->skt);	err = FskHeaderStructNew(&request->requestHeaders);	BAIL_IF_ERR(err);	err = FskHeaderStructNew(&request->responseHeaders);	BAIL_IF_ERR(err);	request->in.bufferSize = request->http->defaultBufferSize;	request->out.bufferSize = request->http->defaultBufferSize;	err = FskMemPtrNew(request->in.bufferSize, (FskMemPtr*)&request->in.buf);	BAIL_IF_ERR(err);	err = FskMemPtrNew(request->out.bufferSize, (FskMemPtr*)&request->out.buf);	BAIL_IF_ERR(err);	FskListAppend((FskList*)&request->http->activeRequests, request);	FskTimeCallbackNew(&request->cycleCallback);	FskTimeCallbackNew(&request->keepAliveKillCallback);	listener->http->stats.connectionsMade++;	request->state = kHTTPNewSession;	FskInstrumentedItemNew(request, NULL, &gFskHTTPServerRequestTypeInstrumentation);	FskInstrumentedItemSetOwner(request, request->http);		FskTimeCallbackScheduleNextRun(request->cycleCallback, httpServerTimeCycle, request);	doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionConnectionInitialized, request->refCon);	FskTimeCallbackNew(&request->timer);	FskTimeCallbackScheduleFuture(request->timer, 1, 0, KprHTTPServerTimerCallback, request);bail:	if (err)		FskHTTPServerRequestDispose(request);	return err;}

FskErr FskAudioDecompressNew(FskAudioDecompress *decoOut, UInt32 audioFormat, const char *mimeType, UInt32 sampleRate, UInt32 channelCount, void *formatInfo, UInt32 formatInfoSize){    FskErr err;    FskAudioDecompressor decoder;    FskAudioDecompress deco;    UInt32 i = 0;    while (true) {        Boolean canHandle = false;        decoder = (FskAudioDecompressor)FskExtensionGetByIndex(kFskExtensionAudioDecompressor, i++);        if (NULL == decoder) {            if (decoOut)                *decoOut = NULL;            return kFskErrExtensionNotFound;        }        if ((kFskErrNone == decoder->doCanHandle(audioFormat, mimeType, &canHandle)) && canHandle)            break;    }    if (NULL == decoOut)        return kFskErrNone;			// can handler    err = FskMemPtrNewClear(sizeof(FskAudioDecompressRecord), &deco);    BAIL_IF_ERR(err);    deco->inputSampleRate = sampleRate;    deco->inputChannelCount = channelCount;    deco->outputChannelCount = channelCount;    deco->formatInfoSize = formatInfoSize;    err = FskMemPtrNewFromData(formatInfoSize, formatInfo, (FskMemPtr*)(void*)&deco->formatInfo);    BAIL_IF_ERR(err);    deco->decoder = decoder;    FskInstrumentedItemNew(deco, FskStrDoCopy_Untracked(mimeType), &gAudioDecompressTypeInstrumentation);    err = deco->decoder->doNew(deco, audioFormat, mimeType);    BAIL_IF_ERR(err);bail:    if (err) {        FskAudioDecompressDispose(deco);        deco = NULL;    }    *decoOut = deco;    return err;}

FskErr FskPinAnalogNew(FskPinAnalog *pin, SInt32 number, const char *name){	FskErr err;	FskPinAnalogDispatch dispatch = NULL;	UInt32 i = 0;	while (true) {		FskPinAnalogDispatch aDispatch = FskExtensionGetByIndex(kFskExtensionPinAnalog, i++);		if (NULL == aDispatch)			BAIL(kFskErrExtensionNotFound);		if ((aDispatch->doCanHandle)(number, name, &number)) {			dispatch = aDispatch;			break;		}	}	err = (dispatch->doNew)(pin, number, name);	BAIL_IF_ERR(err);	(*pin)->dispatch = dispatch;bail:	return err;}

FskErr FskPinI2CNew(FskPinI2C *pin, SInt32 sda, SInt32 sclk, SInt32 bus){	FskErr err;	FskPinI2CDispatch dispatch = NULL;	UInt32 i = 0;	while (true) {		SInt32 remappedBus = kFskPinI2CNoBus;		FskPinI2CDispatch aDispatch = FskExtensionGetByIndex(kFskExtensionPinI2C, i++);		if (NULL == aDispatch)			BAIL(kFskErrExtensionNotFound);		if ((aDispatch->doCanHandle)(sda, sclk, bus, &remappedBus)) {			dispatch = aDispatch;			break;		}		if (kFskPinI2CNoBus != remappedBus)			bus = remappedBus;	}	err = (dispatch->doNew)(pin, sda, sclk, bus);	BAIL_IF_ERR(err);	(*pin)->dispatch = dispatch;bail:	return err;}

FskErr FskAudioCompressFrames(FskAudioCompress comp, const void *inData, UInt32 inDataSize, UInt32 inSampleCount,                              void **outSamples, UInt32 *outDataSize, UInt32 **outFrameSizes, UInt32 *outFrameCount, UInt32 *outSampleCount, UInt32 *outSampleRate, UInt32 *outChannelCount){    FskErr err = kFskErrNone;    UInt32 frameCount;    *outSamples = NULL;    *outFrameSizes = NULL;    if (outFrameCount)        *outFrameCount = 0;    err = (comp->encoder->doCompressFrames)(comp->state, comp, inData, inDataSize, inSampleCount,                                            outSamples, outDataSize, outFrameSizes, &frameCount);    comp->frameNumber += 1;    BAIL_IF_ERR(err);    if (outSampleRate)        *outSampleRate = comp->outputSampleRate;    if (outChannelCount)        *outChannelCount = comp->outputChannelCount;    if (outFrameCount)        *outFrameCount = frameCount;    if (outSampleCount)        *outSampleCount = comp->outputSamplesPerFrame * frameCount;bail:    return err;}

 FskErr amrReaderNew(FskMediaReader reader, void **readerState, const char *mimeType, const char *uri, FskMediaSpooler spooler){	FskErr err;	amrReader state = NULL;    BAIL_IF_NULL(spooler, err, kFskErrUnimplemented);		err = FskMemPtrNewClear(sizeof(amrReaderRecord), &state);	BAIL_IF_ERR(err);	*readerState = state;			// must be set before anything that might issue a callback	state->spooler = spooler;	state->reader = reader;	if (spooler->doOpen) {		err = (spooler->doOpen)(spooler, kFskFilePermissionReadOnly);		BAIL_IF_ERR(err);		state->spoolerOpen = true;	}	state->spooler->onSpoolerCallback = amrSpoolerCallback;	state->spooler->clientRefCon = state;	state->spooler->flags |= kFskMediaSpoolerForwardOnly;	state->duration = kFskUInt32Max;	(reader->doSetState)(reader, kFskMediaPlayerStateInstantiating);	err = amrInstantiate(state);	if (err) {		if (kFskErrNeedMoreTime == err)			err = kFskErrNone;		goto bail;	}bail:	if ((kFskErrNone != err) && (NULL != state)) {		amrReaderDispose(reader, state);		state = NULL;	}	*readerState = state;	return err;}

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

FskErr KprDebugNew(KprDebug* it, UInt32 port){	FskErr err = kFskErrNone;	KprDebug self = NULL;	BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KprDebugRecord), it));	self = *it;	self->port = port;	BAIL_IF_ERR(err = KprSocketServerNew(&self->server, self));	self->server->debugName = "Debug";	self->server->acceptCallback = KprDebugAcceptNewConnection;	BAIL_IF_ERR(err = KprSocketServerListen(self->server, self->port, NULL));	FskListAppend(&gKprDebugList, self);	FskInstrumentedItemNew(self, NULL, &KprDebugInstrumentation);	return err;bail:	KprDebugDispose(self);	return err;}

FskErr FskAudioCompressNew(FskAudioCompress *compOut, const char *outputFormat, const char *inputFormat, UInt32 inputSampleRate, UInt32 inputChannelCount){    FskErr err;    FskAudioCompressor encoder;    FskAudioCompress comp;    UInt32 i = 0;    while (true) {        Boolean canHandle = false;        encoder = (FskAudioCompressor)FskExtensionGetByIndex(kFskExtensionAudioCompressor, i++);        if (NULL == encoder) {            *compOut = NULL;            return kFskErrExtensionNotFound;        }        if ((kFskErrNone == encoder->doCanHandle(outputFormat, &canHandle)) && canHandle)            break;    }    err = FskMemPtrNewClear(sizeof(FskAudioCompressRecord), &comp);    BAIL_IF_ERR(err);    comp->outputFormat = FskStrDoCopy(outputFormat);    comp->inputFormat = FskStrDoCopy(inputFormat);    comp->inputSampleRate = inputSampleRate;    comp->inputChannelCount = inputChannelCount;    comp->outputSampleRate = inputSampleRate;    comp->outputChannelCount = inputChannelCount;    comp->encoder = encoder;    err = comp->encoder->doNew(comp);    BAIL_IF_ERR(err);bail:    if (err) {        FskAudioCompressDispose(comp);        comp = NULL;    }    *compOut = comp;    return err;}

FskErr FskMutexNew_(FskMutex *mutex, const char *name, FSK_SYNCHRONIZATION_DEBUG_ARGS)#endif{	FskMutex mtx = NULL;	FskErr err;	err = FskMemPtrNewClear(sizeof(FskMutexRecord), (FskMemPtr *)&mtx);	BAIL_IF_ERR(err);	err = KplMutexNew((KplMutex*)&mtx->kplMutex);	BAIL_IF_ERR(err);#if SUPPORT_INSTRUMENTATION	mtx->name = FskStrDoCopy_Untracked(name);	FskInstrumentedItemNew(mtx, mtx->name, &gFskMutexTypeInstrumentation);#if SUPPORT_SYNCHRONIZATION_DEBUG	if (FskInstrumentedItemHasListeners(mtx)) {		FskSynchronizationInstrMsgRecord msg;		msg.name = name;		msg.file = file;		msg.line = line;		msg.function = function;		FskInstrumentedItemSendMessage(mtx, kFskSynchronizationInstrMsgMutexNew, &msg);	}#endif#endifbail:	if ((err != kFskErrNone) && (mtx != NULL)) {		KplMutexDispose(mtx->kplMutex);#if SUPPORT_INSTRUMENTATION		FskMemPtrDispose_Untracked((void*)mtx->name);#endif		FskMemPtrDispose(mtx);		mtx = NULL;	}	*mutex = mtx;	return err;}

FskErr FskFSFileRenameDirectory(const char *fullPath, const char *newName){	int err, len;	char *p, newPath[PATH_MAX];	FskFileInfo itemInfo;	err = sCheckFullPath(fullPath, kFskPathIsDirectory);	BAIL_IF_ERR(err);	len = FskStrLen(fullPath);	if (len < 2)		BAIL(kFskErrOperationFailed);			// can't rename root	err = FskFSFileGetFileInfo(fullPath, &itemInfo);	BAIL_IF_ERR(err);	if (itemInfo.filetype != kFskDirectoryItemIsDirectory)		BAIL(kFskErrNotDirectory);	p = FskStrRChr((char *)newName, '/');	if (p)		BAIL(kFskErrOperationFailed);	// newName contains path elements	FskStrCopy(newPath, fullPath);	if (newPath[len - 1] == '/')		newPath[len - 1] = '/0';		// remove trailing slash	p = FskStrRChr(newPath, '/');	if (p)		*++p = '/0';	FskStrCat(newPath, newName);	err = rename(fullPath, newPath);	if (err == -1)		BAIL(errnoToFskErr(errno));	 err = kFskErrNone;bail:	return err;}

FskErr FskCopyFile(char *src, char *dst) {    char buf[4096];    UInt32 amt, amtWrt;    int doit=0;    FskFileInfo info, infoSrc;    FskFile srcFref = NULL, dstFref = NULL;    FskErr err = kFskErrNone;    if (kFskErrFileNotFound == FskFileGetFileInfo(dst, &info)) {        FskAndroidFilesPrintfDebug("dst: %s not found/n", dst);        doit = 1;    }    else if (kFskErrNone == FskFileGetFileInfo(src, &infoSrc)) {        if (infoSrc.filesize != info.filesize) {            FskAndroidFilesPrintfDebug("src size: %d, dstSize: %d/n", infoSrc.filesize, info.filesize);            doit = 1;        }    }    if (doit) {        FskAndroidFilesPrintfDebug("Need to copy it over./n");        err = FskFileOpen(src, kFskFilePermissionReadOnly, &srcFref);		BAIL_IF_ERR(err);        err = FskFileCreate(dst);		BAIL_IF_ERR(err);        err = FskFileOpen(dst, kFskFilePermissionReadWrite, &dstFref);		BAIL_IF_ERR(err);        while (kFskErrNone == err) {            err = FskFileRead(srcFref, 4096, buf, &amt);            BAIL_IF_ERR(err);            if (0 >= amt)                break;            while (amt) {                err = FskFileWrite(dstFref, amt, buf, &amtWrt);				BAIL_IF_ERR(err);                amt -= amtWrt;            }        }        err = FskFileClose(dstFref);        BAIL_IF_ERR(err);		dstFref = NULL;        err = FskFileClose(srcFref);        BAIL_IF_ERR(err);		srcFref = NULL;    }bail:	if(kFskErrEndOfFile == err){		err = kFskErrNone;	}	if(dstFref)		FskFileClose(dstFref);	if(srcFref)		FskFileClose(srcFref);	return err;}

FskErr FskAudioFilterNew(FskAudioFilter *filterOut, const char *filterType){	FskErr err = kFskErrNone;	FskAudioFilter filter = NULL;	UInt32 i = 0;	FskAudioFilterDispatch dispatch;	while (true) {		dispatch = (FskAudioFilterDispatch)FskExtensionGetByIndex(kFskExtensionAudioFilter, i++);		if (NULL == dispatch)			return kFskErrUnimplemented;		if (dispatch->doCanHandle(filterType))			break;	}	if (NULL == filterOut) goto bail;		// "can handle" request	err = FskMemPtrNewClear(sizeof(FskAudioFilterRecord) + FskStrLen(filterType) + 1, &filter);	BAIL_IF_ERR(err);	filter->filterType = (char *)(filter + 1);	FskStrCopy(filter->filterType, filterType);	filter->dispatch = dispatch;	FskInstrumentedItemNew(filter, filter->filterType, &gAudioFilterTypeInstrumentation);	err = (filter->dispatch->doNew)(filter, &filter->state);	BAIL_IF_ERR(err);bail:	if (kFskErrNone != err) {		FskAudioFilterDispose(filter);		filter = NULL;	}	if (NULL != filterOut)		*filterOut = filter;	return err;}

// ---------------------------------------------------------------------// Directory Iterator// ---------------------------------------------------------------------FskErr FskFSDirectoryIteratorNew(const char *directoryPath, FskFSDirectoryIterator *dirIt, UInt32 flags){	FskFSDirectoryIterator di = NULL;	FskErr	err;	FskFileInfo itemInfo;	FskAndroidFilesPrintfDebug("FSDirectoryIteratorNew: %s/n", directoryPath);	if (directoryPath[FskStrLen(directoryPath) -1] != '/')		BAIL(kFskErrInvalidParameter);	err = FskFSFileGetFileInfo(directoryPath, &itemInfo);	BAIL_IF_ERR(err);	if (itemInfo.filetype != kFskDirectoryItemIsDirectory)		BAIL(kFskErrNotDirectory);	err = FskMemPtrNew(sizeof(FskFSDirectoryIteratorRecord), (FskMemPtr*)(void*)&di);	BAIL_IF_ERR(err);	di->root = (unsigned char *)FskStrDoCopy(directoryPath);	di->theDir = opendir(directoryPath);	if (di->theDir == NULL) {		FskMemPtrDisposeAt(&di->root);		BAIL(errnoToFskErr(err));	}	di->device = itemInfo.fileDevice;	*dirIt = (FskFSDirectoryIterator)di;	err = kFskErrNone;bail:	if (err) {		if (di && di->root)			FskMemPtrDispose(di->root);		if (di)			FskMemPtrDispose(di);	}	return err;}

void KPR_system_networkInterfaceIndexToName(xsMachine* the){	SInt32 index = xsToInteger(xsArg(0));	PIP_ADAPTER_ADDRESSES pAddresses = NULL, pAddress;	ULONG flags = GAA_FLAG_INCLUDE_PREFIX;	ULONG family = AF_INET;	ULONG outBufLen = sizeof(IP_ADAPTER_ADDRESSES);	BAIL_IF_ERR(FskMemPtrNewClear(outBufLen, &pAddresses));	if (GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen) == ERROR_BUFFER_OVERFLOW) {		FskMemPtrDispose(pAddresses);		BAIL_IF_ERR(FskMemPtrNewClear(outBufLen, &pAddresses));	}	if (GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen) == NO_ERROR) {		for (pAddress = pAddresses; pAddress; pAddress = pAddress->Next)			if (pAddress->IfIndex == index) break;	}	if (pAddress)		xsResult = xsString(pAddress->AdapterName);bail:	FskMemPtrDispose(pAddresses);	return;}

FskErr FskMuxerNew(FskMuxer *muxerOut, const char *mimeType, UInt32 scale, FskMuxerWriteProc write, void *writeRefCon){	FskErr err;	FskMuxer muxer = NULL;	UInt32 i = 0;	FskMuxerDispatch dispatch;	while (true) {		dispatch = (FskMuxerDispatch)FskExtensionGetByIndex(kFskExtensionMuxer, i++);		if (NULL == dispatch)			return kFskErrExtensionNotFound;		if (dispatch->doCanHandle(mimeType))			break;	}	err = FskMemPtrNewClear(sizeof(FskMuxerRecord) + FskStrLen(mimeType) + 1, &muxer);	BAIL_IF_ERR(err);	muxer->mimeType = (char *)(muxer + 1);	FskStrCopy(muxer->mimeType, mimeType);	muxer->scale = scale;	muxer->write = write;	muxer->writeRefCon = writeRefCon;	muxer->dispatch = dispatch;	err = (muxer->dispatch->doNew)(muxer, &muxer->state);	BAIL_IF_ERR(err);bail:	if (kFskErrNone != err) {		FskMuxerDispose(muxer);		muxer = NULL;	}	*muxerOut = muxer;	return err;}

FskErr KplScreenGetBitmap(KplBitmap *bitmap){	FskErr err = kFskErrNone;	FrameBufferVectorSet fbv;	if (!gKplScreen) {		BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KplScreenRecord), (FskMemPtr *)&gKplScreen));		BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KplBitmapRecord), (FskMemPtr *)&gKplScreen->bitmap));		fbGetScreenDim(&gScreenWidth, &gScreenHeight);fprintf(stderr, "ScreenWidth: %d, ScreenHeight: %d/n", gScreenWidth, gScreenHeight);		gKplScreen->bitmap->width = gScreenWidth;		gKplScreen->bitmap->height = gScreenHeight;		gKplScreen->bitmap->pixelFormat = kScreenPixelFormat;		gKplScreen->bitmap->depth = kScreenDepth;		gKplScreen->bitmap->rowBytes = gScreenWidth * (kScreenDepth / 8);		BAIL_IF_ERR(err = FskMemPtrNewClear(gKplScreen->bitmap->rowBytes * gScreenHeight, (FskMemPtr *)&gKplScreen->bitmap->baseAddress));		initializeLinuxInput(gScreenWidth, gScreenHeight);	}	gKplScreen->vSyncInterval = MAX_FRAMERATE_MS;	gKplScreen->vSyncIntervalTime.useconds = MAX_FRAMERATE_MS * 1000;	FskSemaphoreNew(&gKplScreen->flipSemaphore, 0);	FskThreadCreate(&gKplScreen->flipThread, flipThread, kFskThreadFlagsJoinable | kFskThreadFlagsWaitForInit, gKplScreen, "flip");	FskFrameBufferGetVectors(&fbv);	if (fbv) {		fbv->doHasProperty = KplScreenHasProperty;		fbv->doSetProperty = KplScreenSetProperty;		fbv->doGetProperty = KplScreenGetProperty;	}	*bitmap = gKplScreen->bitmap;bail:	return err;}