ejsvar.c

samba最新软件

	dest->cMethod.userData = userData;
	dest->flags = flags;
	dest->allocatedData = 0;

	return dest;
}

/******************************************************************************/
#if BLD_FEATURE_FLOATING_POINT
/*
 *	Set a var using a new float value
 */

EjsVar *ejsWriteVarAsFloat(Ejs *ep, EjsVar *dest, double value)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_TYPE_FLOAT;
	dest->floating = value;
	dest->allocatedData = 0;
	dest->flags = 0;

	return dest;
}

#endif
/******************************************************************************/
/*
 *	Set a var using a new integer value
 */

EjsVar *ejsWriteVarAsInteger(Ejs *ep, EjsVar *dest, int value)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_TYPE_INT;
	dest->integer = value;
	dest->allocatedData = 0;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
#if BLD_FEATURE_INT64
/*
 *	Set a var using a new integer value
 */

EjsVar *ejsWriteVarAsInteger64(Ejs *ep, EjsVar *dest, int64 value)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_TYPE_INT64;
	dest->integer64 = value;
	dest->allocatedData = 0;
	dest->flags = 0;

	return dest;
}

#endif
/******************************************************************************/
/*
 *	Set a var using a new Method
 */

EjsVar *ejsWriteVarAsMethod(Ejs *ep, EjsVar *dest, const char *body,
	MprArray *args)
{
	EjsVar		**srcArgs, *arg;
	int			i;

	mprAssert(ep);
	mprAssert(dest);
	mprAssert(body);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->method.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
	if (dest->method.args == 0) {
		return 0;
	}

	dest->type = EJS_TYPE_METHOD;

	if (args) {
		srcArgs = (EjsVar**) args->items;
		for (i = 0; i < args->length; i++) {
			arg = ejsDupVar(ep, srcArgs[i], EJS_SHALLOW_COPY);
			if (arg == 0) {
				return 0;
			}
			if (mprAddItem(dest->method.args, arg) < 0) {
				return 0;
			}
		}
	}

	dest->method.body = mprStrdup(dest->method.args, body);
	if (dest->method.body == 0) {
		return 0;
	}

	dest->allocatedData = 1;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Set a var to null
 */

EjsVar *ejsWriteVarAsNull(Ejs *ep, EjsVar *dest)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_TYPE_NULL;
	dest->allocatedData = 0;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Set a var using a new number value
 */

EjsVar *ejsWriteVarAsNumber(Ejs *ep, EjsVar *dest, EjsNum value)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_NUM_VAR;
	dest->ejsNumber = value;
	dest->allocatedData = 0;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Set a var using a new C Method
 */

EjsVar *ejsWriteVarAsStringCMethod(Ejs *ep, EjsVar *dest, EjsStringCMethod fn, 
	void *userData, int flags)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_TYPE_CMETHOD;
	dest->cMethodWithStrings.fn = fn;
	dest->cMethodWithStrings.userData = userData;
	dest->flags = flags;
	dest->allocatedData = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Set a var using a new string value
 */

EjsVar *ejsWriteVarAsStringInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest, 
	const char *value)
{
	mprAssert(dest);
	mprAssert(value);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->string = mprStrdupInternal(EJS_LOC_PASS(ep, loc), value);
	if (dest->string == 0) {
		return 0;
	}

	dest->length = strlen(dest->string);

	dest->type = EJS_TYPE_STRING;
	dest->allocatedData = 1;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Set a var using a new string value
 */

EjsVar *ejsWriteVarAsBinaryString(Ejs *ep, EjsVar *dest, const uchar *value,
	int len)
{
	mprAssert(dest);
	mprAssert(value);

	ejsClearVar(ep, dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->length = dupString(MPR_LOC_ARGS(ep), &dest->ustring, value, len);
	if (dest->length < 0) {
		return 0;
	}

	dest->type = EJS_TYPE_STRING;
	dest->allocatedData = 1;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Set a var to undefined
 */

EjsVar *ejsWriteVarAsUndefined(Ejs *ep, EjsVar *dest)
{
	mprAssert(dest);

	if (dest->type != EJS_TYPE_UNDEFINED) {
		ejsClearVar(ep, dest);
	}

	dest->type = EJS_TYPE_UNDEFINED;
	dest->allocatedData = 0;
	dest->flags = 0;

	return dest;
}

/******************************************************************************/
/*
 *	Convert a value to a text based representation of its value
 *	If you provide a format, you MUST ensure you know the type.
 *	Caller must free the result.
 */

char *ejsFormatVar(Ejs *ep, const char *fmt, EjsVar *vp)
{
	char	*buf, *src, *value, *allocValue;
	uchar	*ubuf;
	int		len;

	buf = 0;
	allocValue = 0;
	value = 0;

	switch (vp->type) {
	case EJS_TYPE_UNDEFINED:
		value = "undefined";
		break;

	case EJS_TYPE_NULL:
		value = "null";
		break;

	case EJS_TYPE_PTR:
		if (fmt == NULL || *fmt == '\0') {
			len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, 
				"[Opaque Pointer %p]", vp->ptr.userPtr);
		} else {
			len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->ptr);
		}
		goto done;

	case EJS_TYPE_BOOL:
		value = (vp->boolean) ? "true" : "false";
		break;

#if BLD_FEATURE_FLOATING_POINT
	case EJS_TYPE_FLOAT:
		if (fmt == NULL || *fmt == '\0') {
			fmt = "%f";
		}
		len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->floating);
		goto done;
#endif

	case EJS_TYPE_INT:
		if (fmt == NULL || *fmt == '\0') {
			fmt = "%d";
		}
		mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->integer);
		goto done;

#if BLD_FEATURE_INT64
	case EJS_TYPE_INT64:
		if (fmt == NULL || *fmt == '\0') {
			fmt = "%Ld";
		}
		mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->integer64);
		goto done;
#endif

	case EJS_TYPE_CMETHOD:
		value = "[C Method]";
		break;

	case EJS_TYPE_STRING_CMETHOD:
		value = "[C StringMethod]";
		break;

	case EJS_TYPE_METHOD:
		value = ejsVarToString(ep, vp);
		break;

	case EJS_TYPE_OBJECT:
		value = ejsVarToString(ep, vp);
		break;

	case EJS_TYPE_STRING:
		src = vp->string;
		mprAssert(src);

		if (fmt && *fmt && src) {
			mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, src);

		} else if (src == NULL) {
			buf = mprStrdup(ep, "null");

		} else {
			ubuf = (uchar*) buf;
			if (dupString(MPR_LOC_ARGS(ep), &ubuf, src, vp->length) < 0) {
				return mprStrdup(ep, "");
			}
			buf = (char*) ubuf;
		}
		break;

	default:
		mprAssert(0);
	}

	if (fmt == NULL || *fmt == '\0') {
		len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, "%s", value);
	} else {
		len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, value);
	}

done:
	if (allocValue) {
		mprFree(allocValue);
	}
	return buf;
}

/******************************************************************************/
/*
 *	Convert the variable to a boolean. Only for primitive types.
 */

int ejsVarToBoolean(EjsVar *vp)
{
	mprAssert(vp);

	switch (vp->type) {
	case EJS_TYPE_UNDEFINED:
	case EJS_TYPE_NULL:
	case EJS_TYPE_STRING_CMETHOD:
	case EJS_TYPE_CMETHOD:
	case EJS_TYPE_METHOD:
		return 0;

	case EJS_TYPE_OBJECT:
		return (vp->objectState != NULL);

	case EJS_TYPE_PTR:
		return (vp->ptr.userPtr != NULL);

	case EJS_TYPE_BOOL:
		return vp->boolean;

#if BLD_FEATURE_FLOATING_POINT
	case EJS_TYPE_FLOAT:
		return (vp->floating != 0 && !ejsIsNan(vp->floating));
#endif

	case EJS_TYPE_INT:
		return (vp->integer != 0);

#if BLD_FEATURE_INT64
	case EJS_TYPE_INT64:
		return (vp->integer64 != 0);
#endif

	case EJS_TYPE_STRING:
		return (vp->length > 0);
#if UNUSED
		if (strcmp(vp->string, "true") == 0 || 
				strcmp(vp->string, "TRUE") == 0) {
			return 1;

		} else if (strcmp(vp->string, "false") == 0 || 
				strcmp(vp->string, "FALSE") == 0) {
			return 0;

		} else {
			return atoi(vp->string);
		}
#endif
	}

	/* Not reached */
	return 0;
}

/******************************************************************************/
#if BLD_FEATURE_FLOATING_POINT
/*
 *	Convert the variable to a floating point number. Only for primitive types.
 */

double ejsVarToFloat(EjsVar *vp)
{
	mprAssert(vp);

	switch (vp->type) {
	case EJS_TYPE_UNDEFINED:
	case EJS_TYPE_NULL:
	case EJS_TYPE_STRING_CMETHOD:
	case EJS_TYPE_CMETHOD:
	case EJS_TYPE_METHOD:
	case EJS_TYPE_OBJECT:
	case EJS_TYPE_PTR:
		return 0;

	case EJS_TYPE_BOOL:
		return (vp->boolean) ? 1.0 : 0.0;

	case EJS_TYPE_FLOAT:
		return vp->floating;

	case EJS_TYPE_INT:
		return (double) vp->integer;

#if BLD_FEATURE_INT64
	case EJS_TYPE_INT64:
		return (double) vp->integer64;
#endif

	case EJS_TYPE_STRING:
		if (vp->length == 0) {
			return 0.0;
		} else {
			return atof(vp->string);
		}
	}

	/* Not reached */
	return 0;
}

#endif
/******************************************************************************/
/*
 *	Convert the variable to an Integer type. Only works for primitive types.
 */

int ejsVarToInteger(EjsVar *vp)
{
	mprAssert(vp);

	switch (vp->type) {
	case EJS_TYPE_UNDEFINED:
	case EJS_TYPE_NULL:
	case EJS_TYPE_STRING_CMETHOD:
	case EJS_TYPE_CMETHOD:
	case EJS_TYPE_METHOD:
	case EJS_TYPE_OBJECT:
		return 0;

	case EJS_TYPE_BOOL:
		return (vp->boolean) ? 1 : 0;

#if BLD_FEATURE_FLOATING_POINT
	case EJS_TYPE_FLOAT:
		if (ejsIsNan(vp->floating)) {
			return 0;
		}
		return (int) vp->floating;
#endif

	case EJS_TYPE_INT:
		return vp->integer;

#if BLD_FEATURE_INT64
	case EJS_TYPE_INT64:
		return (int) vp->integer64;
#endif

	case EJS_TYPE_STRING:
		if (vp->length == 0) {
			return 0;
		} else {
			return ejsParseInteger(vp->string);
		}
	}

	/* Not reached */
	return 0;
}

/******************************************************************************/
#if BLD_FEATURE_INT64
/*
 *	Convert the variable to an Integer64 type. Only works for primitive types.
 */

int64 ejsVarToInteger64(EjsVar *vp)
{
	mprAssert(vp);

	switch (vp->type) {
	case EJS_TYPE_UNDEFINED:
	case EJS_TYPE_NULL:
	case EJS_TYPE_STRING_CMETHOD:
	case EJS_TYPE_CMETHOD:
	case EJS_TYPE_METHOD:
	case EJS_TYPE_OBJECT:
	case EJS_TYPE_PTR:
		return 0;

	case EJS_TYPE_BOOL:
		return (vp->boolean) ? 1 : 0;

#if BLD_FEATURE_FLOATING_POINT
	case EJS_TYPE_FLOAT:
		if (ejsIsNan(vp->floating)) {
			return 0;
		}
		return (int64) vp->floating;
#endif

	case EJS_TYPE_INT:
		return vp->integer;

	case EJS_TYPE_INT64:
		return vp->integer64;

	case EJS_TYPE_STRING:
		if (vp->length == 0) {
			return 0;
		} else {
			return ejsParseInteger64(vp->string);
		}
	}

	/* Not reached */
	return 0;
}

#endif /* BLD_FEATURE_INT64 */
/******************************************************************************/
/*
 *	Convert the variable to a number type. Only works for primitive types.
 */

EjsNum ejsVarToNumber(EjsVar *vp)
{
#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64
	return ejsVarToInteger64(vp);
#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT
	return ejsVarToFloat(vp);
#else 
	return ejsVarToInteger(vp);
#endif
}