jsvalue.c

#include "jsi.h"
#include "utf.h"

#define JSV_ISSTRING(v) (v->t.type == JS_TSHRSTR || v->t.type == JS_TMEMSTR || v->t.type == JS_TLITSTR)
#define JSV_TOSTRING(v) (v->t.type == JS_TSHRSTR ? v->u.shrstr : v->t.type == JS_TLITSTR ? v->u.litstr    \
															 : v->t.type == JS_TMEMSTR	 ? v->u.memstr->p \
																						 : "")

double js_strtol(const char *s, char **p, int base)
{
	/* ascii -> digit value. max base is 36. */
	static const unsigned char table[256] = {
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 80, 80, 80, 80, 80, 80,
		80, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
		25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 80, 80, 80, 80, 80,
		80, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
		25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80};
	double x;
	unsigned char c;
	if (base == 10)
		for (x = 0, c = *s++; (0 <= c - '0') && (c - '0' < 10); c = *s++)
			x = x * 10 + (c - '0');
	else
		for (x = 0, c = *s++; table[c] < base; c = *s++)
			x = x * base + table[c];
	if (p)
		*p = (char *)s - 1;
	return x;
}

int jsV_numbertointeger(double n)
{
	if (n == 0)
		return 0;
	if (isnan(n))
		return 0;
	n = (n < 0) ? -floor(-n) : floor(n);
	if (n < INT_MIN)
		return INT_MIN;
	if (n > INT_MAX)
		return INT_MAX;
	return (int)n;
}

int jsV_numbertoint32(double n)
{
	double two32 = 4294967296.0;
	double two31 = 2147483648.0;

	if (!isfinite(n) || n == 0)
		return 0;

	n = fmod(n, two32);
	n = n >= 0 ? floor(n) : ceil(n) + two32;
	if (n >= two31)
		return n - two32;
	else
		return n;
}

unsigned int jsV_numbertouint32(double n)
{
	return (unsigned int)jsV_numbertoint32(n);
}

short jsV_numbertoint16(double n)
{
	return jsV_numbertoint32(n);
}

unsigned short jsV_numbertouint16(double n)
{
	return jsV_numbertoint32(n);
}

/* obj.toString() */
static int jsV_toString(js_State *J, js_Object *obj)
{
	js_pushobject(J, obj);
	js_getproperty(J, -1, "toString");
	if (js_iscallable(J, -1))
	{
		js_rot2(J);
		js_call(J, 0);
		if (js_isprimitive(J, -1))
			return 1;
		js_pop(J, 1);
		return 0;
	}
	js_pop(J, 2);
	return 0;
}

/* obj.valueOf() */
static int jsV_valueOf(js_State *J, js_Object *obj)
{
	js_pushobject(J, obj);
	js_getproperty(J, -1, "valueOf");
	if (js_iscallable(J, -1))
	{
		js_rot2(J);
		js_call(J, 0);
		if (js_isprimitive(J, -1))
			return 1;
		js_pop(J, 1);
		return 0;
	}
	js_pop(J, 2);
	return 0;
}

/* ToPrimitive() on a value */
void jsV_toprimitive(js_State *J, js_Value *v, int preferred)
{
	js_Object *obj;

	if (v->t.type != JS_TOBJECT)
		return;

	obj = v->u.object;

	if (preferred == JS_HNONE)
		preferred = obj->type == JS_CDATE ? JS_HSTRING : JS_HNUMBER;

	if (preferred == JS_HSTRING)
	{
		if (jsV_toString(J, obj) || jsV_valueOf(J, obj))
		{
			*v = *js_tovalue(J, -1);
			js_pop(J, 1);
			return;
		}
	}
	else
	{
		if (jsV_valueOf(J, obj) || jsV_toString(J, obj))
		{
			*v = *js_tovalue(J, -1);
			js_pop(J, 1);
			return;
		}
	}

	if (J->strict)
		js_typeerror(J, "cannot convert object to primitive");

	v->t.type = JS_TLITSTR;
	v->u.litstr = "[object]";
	return;
}

/* ToBoolean() on a value */
int jsV_toboolean(js_State *J, js_Value *v)
{
	switch (v->t.type)
	{
	default:
	case JS_TSHRSTR:
		return v->u.shrstr[0] != 0;
	case JS_TUNDEFINED:
		return 0;
	case JS_TNULL:
		return 0;
	case JS_TBOOLEAN:
		return v->u.boolean;
	case JS_TNUMBER:
		return v->u.number != 0 && !isnan(v->u.number);
	case JS_TLITSTR:
		return v->u.litstr[0] != 0;
	case JS_TMEMSTR:
		return v->u.memstr->p[0] != 0;
	case JS_TOBJECT:
		return 1;
	}
}

const char *js_itoa(char *out, int v)
{
	char buf[32], *s = out;
	unsigned int a;
	int i = 0;
	if (v < 0)
	{
		a = -v;
		*s++ = '-';
	}
	else
	{
		a = v;
	}
	while (a)
	{
		buf[i++] = (a % 10) + '0';
		a /= 10;
	}
	if (i == 0)
		buf[i++] = '0';
	while (i > 0)
		*s++ = buf[--i];
	*s = 0;
	return out;
}

double js_stringtofloat(const char *s, char **ep)
{
	char *end;
	double n;
	const char *e = s;
	int isflt = 0;
	if (*e == '+' || *e == '-')
		++e;
	while (*e >= '0' && *e <= '9')
		++e;
	if (*e == '.')
	{
		++e;
		isflt = 1;
	}
	while (*e >= '0' && *e <= '9')
		++e;
	if (*e == 'e' || *e == 'E')
	{
		++e;
		if (*e == '+' || *e == '-')
			++e;
		while (*e >= '0' && *e <= '9')
			++e;
		isflt = 1;
	}
	if (isflt)
		n = js_strtod(s, &end);
	else
	{
		/* js_strtol doesn't parse the sign */
		if (*s == '-')
			n = -js_strtol(s + 1, &end, 10);
		else if (*s == '+')
			n = js_strtol(s + 1, &end, 10);
		else
			n = js_strtol(s, &end, 10);
	}
	if (end == e)
	{
		*ep = (char *)e;
		return n;
	}
	*ep = (char *)s;
	return 0;
}

/* ToNumber() on a string */
double jsV_stringtonumber(js_State *J, const char *s)
{
	char *e;
	double n;
	while (jsY_iswhite(*s) || jsY_isnewline(*s))
		++s;
	if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && s[2] != 0)
		n = js_strtol(s + 2, &e, 16);
	else if (!strncmp(s, "Infinity", 8))
		n = INFINITY, e = (char *)s + 8;
	else if (!strncmp(s, "+Infinity", 9))
		n = INFINITY, e = (char *)s + 9;
	else if (!strncmp(s, "-Infinity", 9))
		n = -INFINITY, e = (char *)s + 9;
	else
		n = js_stringtofloat(s, &e);
	while (jsY_iswhite(*e) || jsY_isnewline(*e))
		++e;
	if (*e)
		return NAN;
	return n;
}

/* ToNumber() on a value */
double jsV_tonumber(js_State *J, js_Value *v)
{
	switch (v->t.type)
	{
	default:
	case JS_TSHRSTR:
		return jsV_stringtonumber(J, v->u.shrstr);
	case JS_TUNDEFINED:
		return NAN;
	case JS_TNULL:
		return 0;
	case JS_TBOOLEAN:
		return v->u.boolean;
	case JS_TNUMBER:
		return v->u.number;
	case JS_TLITSTR:
		return jsV_stringtonumber(J, v->u.litstr);
	case JS_TMEMSTR:
		return jsV_stringtonumber(J, v->u.memstr->p);
	case JS_TOBJECT:
		jsV_toprimitive(J, v, JS_HNUMBER);
		return jsV_tonumber(J, v);
	}
}

double jsV_tointeger(js_State *J, js_Value *v)
{
	return jsV_numbertointeger(jsV_tonumber(J, v));
}

/* ToString() on a number */
const char *jsV_numbertostring(js_State *J, char buf[32], double f)
{
	char digits[32], *p = buf, *s = digits;
	int exp, ndigits, point;

	if (f == 0)
		return "0";
	if (isnan(f))
		return "NaN";
	if (isinf(f))
		return f < 0 ? "-Infinity" : "Infinity";

	/* Fast case for integers. This only works assuming all integers can be
	 * exactly represented by a float. This is true for 32-bit integers and
	 * 64-bit floats. */
	if (f >= INT_MIN && f <= INT_MAX)
	{
		int i = (int)f;
		if ((double)i == f)
			return js_itoa(buf, i);
	}

	ndigits = js_grisu2(f, digits, &exp);
	point = ndigits + exp;

	if (signbit(f))
		*p++ = '-';

	if (point < -5 || point > 21)
	{
		*p++ = *s++;
		if (ndigits > 1)
		{
			int n = ndigits - 1;
			*p++ = '.';
			while (n--)
				*p++ = *s++;
		}
		js_fmtexp(p, point - 1);
	}

	else if (point <= 0)
	{
		*p++ = '0';
		*p++ = '.';
		while (point++ < 0)
			*p++ = '0';
		while (ndigits-- > 0)
			*p++ = *s++;
		*p = 0;
	}

	else
	{
		while (ndigits-- > 0)
		{
			*p++ = *s++;
			if (--point == 0 && ndigits > 0)
				*p++ = '.';
		}
		while (point-- > 0)
			*p++ = '0';
		*p = 0;
	}

	return buf;
}

/* ToString() on a value */
const char *jsV_tostring(js_State *J, js_Value *v)
{
	char buf[32];
	const char *p;
	switch (v->t.type)
	{
	default:
	case JS_TSHRSTR:
		return v->u.shrstr;
	case JS_TUNDEFINED:
		return "undefined";
	case JS_TNULL:
		return "null";
	case JS_TBOOLEAN:
		return v->u.boolean ? "true" : "false";
	case JS_TLITSTR:
		return v->u.litstr;
	case JS_TMEMSTR:
		return v->u.memstr->p;
	case JS_TNUMBER:
		p = jsV_numbertostring(J, buf, v->u.number);
		if (p == buf)
		{
			int n = strlen(p);
			if (n <= soffsetof(js_Value, t.type))
			{
				char *s = v->u.shrstr;
				while (n--)
					*s++ = *p++;
				*s = 0;
				v->t.type = JS_TSHRSTR;
				return v->u.shrstr;
			}
			else
			{
				v->u.memstr = jsV_newmemstring(J, p, n);
				v->t.type = JS_TMEMSTR;
				return v->u.memstr->p;
			}
		}
		return p;
	case JS_TOBJECT:
		jsV_toprimitive(J, v, JS_HSTRING);
		return jsV_tostring(J, v);
	}
}

/* Objects */

static js_Object *jsV_newboolean(js_State *J, int v)
{
	js_Object *obj = jsV_newobject(J, JS_CBOOLEAN, J->Boolean_prototype);
	obj->u.boolean = v;
	return obj;
}

static js_Object *jsV_newnumber(js_State *J, double v)
{
	js_Object *obj = jsV_newobject(J, JS_CNUMBER, J->Number_prototype);
	obj->u.number = v;
	return obj;
}

static js_Object *jsV_newstring(js_State *J, const char *v)
{
	js_Object *obj = jsV_newobject(J, JS_CSTRING, J->String_prototype);
	size_t n = strlen(v);
	if (n < sizeof(obj->u.s.shrstr))
	{
		obj->u.s.string = obj->u.s.shrstr;
		memcpy(obj->u.s.shrstr, v, n + 1);
	}
	else
	{
		obj->u.s.string = js_strdup(J, v);
	}
	obj->u.s.length = js_utflen(v);
	return obj;
}

/* ToObject() on a value */
js_Object *jsV_toobject(js_State *J, js_Value *v)
{
	js_Object *o;
	switch (v->t.type)
	{
	default:
	case JS_TUNDEFINED:
		js_typeerror(J, "cannot convert undefined to object");
	case JS_TNULL:
		js_typeerror(J, "cannot convert null to object");
	case JS_TOBJECT:
		return v->u.object;
	case JS_TSHRSTR:
		o = jsV_newstring(J, v->u.shrstr);
		break;
	case JS_TLITSTR:
		o = jsV_newstring(J, v->u.litstr);
		break;
	case JS_TMEMSTR:
		o = jsV_newstring(J, v->u.memstr->p);
		break;
	case JS_TBOOLEAN:
		o = jsV_newboolean(J, v->u.boolean);
		break;
	case JS_TNUMBER:
		o = jsV_newnumber(J, v->u.number);
		break;
	}
	v->t.type = JS_TOBJECT;
	v->u.object = o;
	return o;
}

void js_newobjectx(js_State *J)
{
	js_Object *prototype = NULL;
	if (js_isobject(J, -1))
		prototype = js_toobject(J, -1);
	js_pop(J, 1);
	js_pushobject(J, jsV_newobject(J, JS_COBJECT, prototype));
}

void js_newobject(js_State *J)
{
	js_pushobject(J, jsV_newobject(J, JS_COBJECT, J->Object_prototype));
}

void js_newarguments(js_State *J)
{
	js_pushobject(J, jsV_newobject(J, JS_CARGUMENTS, J->Object_prototype));
}

void js_newarray(js_State *J)
{
	js_Object *obj = jsV_newobject(J, JS_CARRAY, J->Array_prototype);
	obj->u.a.simple = 1;
	js_pushobject(J, obj);
}

void js_newboolean(js_State *J, int v)
{
	js_pushobject(J, jsV_newboolean(J, v));
}

void js_newnumber(js_State *J, double v)
{
	js_pushobject(J, jsV_newnumber(J, v));
}

void js_newstring(js_State *J, const char *v)
{
	js_pushobject(J, jsV_newstring(J, v));
}

void js_newfunction(js_State *J, js_Function *fun, js_Environment *scope)
{
	js_Object *obj = jsV_newobject(J, JS_CFUNCTION, J->Function_prototype);
	obj->u.f.function = fun;
	obj->u.f.scope = scope;
	js_pushobject(J, obj);
	{
		js_pushnumber(J, fun->numparams);
		js_defproperty(J, -2, "length", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
		js_newobject(J);
		{
			js_copy(J, -2);
			js_defproperty(J, -2, "constructor", JS_DONTENUM);
		}
		js_defproperty(J, -2, "prototype", JS_DONTENUM | JS_DONTCONF);
	}
}

void js_newscript(js_State *J, js_Function *fun, js_Environment *scope)
{
	js_Object *obj = jsV_newobject(J, JS_CSCRIPT, NULL);
	obj->u.f.function = fun;
	obj->u.f.scope = scope;
	js_pushobject(J, obj);
}

void js_newcfunctionx(js_State *J, js_CFunction cfun, const char *name, int length, void *data, js_Finalize finalize)
{
	js_Object *obj;

	if (js_try(J))
	{
		if (finalize)
			finalize(J, data);
		js_throw(J);
	}

	obj = jsV_newobject(J, JS_CCFUNCTION, J->Function_prototype);
	obj->u.c.name = name;
	obj->u.c.function = cfun;
	obj->u.c.constructor = NULL;
	obj->u.c.length = length;
	obj->u.c.data = data;
	obj->u.c.finalize = finalize;

	js_endtry(J);

	js_pushobject(J, obj);
	{
		js_pushnumber(J, length);
		js_defproperty(J, -2, "length", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
		js_newobject(J);
		{
			js_copy(J, -2);
			js_defproperty(J, -2, "constructor", JS_DONTENUM);
		}
		js_defproperty(J, -2, "prototype", JS_DONTENUM | JS_DONTCONF);
	}
}

void js_newcfunction(js_State *J, js_CFunction cfun, const char *name, int length)
{
	js_newcfunctionx(J, cfun, name, length, NULL, NULL);
}

/* prototype -- constructor */
void js_newcconstructor(js_State *J, js_CFunction cfun, js_CFunction ccon, const char *name, int length)
{
	js_Object *obj = jsV_newobject(J, JS_CCFUNCTION, J->Function_prototype);
	obj->u.c.name = name;
	obj->u.c.function = cfun;
	obj->u.c.constructor = ccon;
	obj->u.c.length = length;
	js_pushobject(J, obj); /* proto obj */
	{
		js_pushnumber(J, length);
		js_defproperty(J, -2, "length", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
		js_rot2(J);		/* obj proto */
		js_copy(J, -2); /* obj proto obj */
		js_defproperty(J, -2, "constructor", JS_DONTENUM);
		js_defproperty(J, -2, "prototype", JS_DONTENUM | JS_DONTCONF);
	}
}

void js_newuserdatax(js_State *J, const char *tag, void *data, js_HasProperty has, js_Put put, js_Delete delete, js_Finalize finalize)
{
	js_Object *prototype = NULL;
	js_Object *obj;

	if (js_isobject(J, -1))
		prototype = js_toobject(J, -1);
	js_pop(J, 1);

	if (js_try(J))
	{
		if (finalize)
			finalize(J, data);
		js_throw(J);
	}

	obj = jsV_newobject(J, JS_CUSERDATA, prototype);
	obj->u.user.tag = tag;
	obj->u.user.data = data;
	obj->u.user.has = has;
	obj->u.user.put = put;
	obj->u.user.delete = delete;
	obj->u.user.finalize = finalize;

	js_endtry(J);

	js_pushobject(J, obj);
}

void js_newuserdata(js_State *J, const char *tag, void *data, js_Finalize finalize)
{
	js_newuserdatax(J, tag, data, NULL, NULL, NULL, finalize);
}

/* Non-trivial operations on values. These are implemented using the stack. */

int js_instanceof(js_State *J)
{
	js_Object *O, *V;

	if (!js_iscallable(J, -1))
		js_typeerror(J, "instanceof: invalid operand");

	if (!js_isobject(J, -2))
		return 0;

	js_getproperty(J, -1, "prototype");
	if (!js_isobject(J, -1))
		js_typeerror(J, "instanceof: 'prototype' property is not an object");
	O = js_toobject(J, -1);
	js_pop(J, 1);

	V = js_toobject(J, -2);
	while (V)
	{
		V = V->prototype;
		if (O == V)
			return 1;
	}

	return 0;
}

void js_concat(js_State *J)
{
	js_toprimitive(J, -2, JS_HNONE);
	js_toprimitive(J, -1, JS_HNONE);

	if (js_isstring(J, -2) || js_isstring(J, -1))
	{
		const char *sa = js_tostring(J, -2);
		const char *sb = js_tostring(J, -1);
		char *volatile sab = NULL;
		/* TODO: create js_String directly */
		if (js_try(J))
		{
			js_free(J, sab);
			js_throw(J);
		}
		sab = js_malloc(J, strlen(sa) + strlen(sb) + 1);
		strcpy(sab, sa);
		strcat(sab, sb);
		js_pop(J, 2);
		js_pushstring(J, sab);
		js_endtry(J);
		js_free(J, sab);
	}
	else
	{
		double x = js_tonumber(J, -2);
		double y = js_tonumber(J, -1);
		js_pop(J, 2);
		js_pushnumber(J, x + y);
	}
}

int js_compare(js_State *J, int *okay)
{
	js_toprimitive(J, -2, JS_HNUMBER);
	js_toprimitive(J, -1, JS_HNUMBER);

	*okay = 1;
	if (js_isstring(J, -2) && js_isstring(J, -1))
	{
		return strcmp(js_tostring(J, -2), js_tostring(J, -1));
	}
	else
	{
		double x = js_tonumber(J, -2);
		double y = js_tonumber(J, -1);
		if (isnan(x) || isnan(y))
			*okay = 0;
		return x < y ? -1 : x > y ? 1
								  : 0;
	}
}

int js_equal(js_State *J)
{
	js_Value *x = js_tovalue(J, -2);
	js_Value *y = js_tovalue(J, -1);

retry:
	if (JSV_ISSTRING(x) && JSV_ISSTRING(y))
		return !strcmp(JSV_TOSTRING(x), JSV_TOSTRING(y));
	if (x->t.type == y->t.type)
	{
		if (x->t.type == JS_TUNDEFINED)
			return 1;
		if (x->t.type == JS_TNULL)
			return 1;
		if (x->t.type == JS_TNUMBER)
			return x->u.number == y->u.number;
		if (x->t.type == JS_TBOOLEAN)
			return x->u.boolean == y->u.boolean;
		if (x->t.type == JS_TOBJECT)
			return x->u.object == y->u.object;
		return 0;
	}

	if (x->t.type == JS_TNULL && y->t.type == JS_TUNDEFINED)
		return 1;
	if (x->t.type == JS_TUNDEFINED && y->t.type == JS_TNULL)
		return 1;

	if (x->t.type == JS_TNUMBER && JSV_ISSTRING(y))
		return x->u.number == jsV_tonumber(J, y);
	if (JSV_ISSTRING(x) && y->t.type == JS_TNUMBER)
		return jsV_tonumber(J, x) == y->u.number;

	if (x->t.type == JS_TBOOLEAN)
	{
		x->t.type = JS_TNUMBER;
		x->u.number = x->u.boolean ? 1 : 0;
		goto retry;
	}
	if (y->t.type == JS_TBOOLEAN)
	{
		y->t.type = JS_TNUMBER;
		y->u.number = y->u.boolean ? 1 : 0;
		goto retry;
	}
	if ((JSV_ISSTRING(x) || x->t.type == JS_TNUMBER) && y->t.type == JS_TOBJECT)
	{
		jsV_toprimitive(J, y, JS_HNONE);
		goto retry;
	}
	if (x->t.type == JS_TOBJECT && (JSV_ISSTRING(y) || y->t.type == JS_TNUMBER))
	{
		jsV_toprimitive(J, x, JS_HNONE);
		goto retry;
	}

	return 0;
}

int js_strictequal(js_State *J)
{
	js_Value *x = js_tovalue(J, -2);
	js_Value *y = js_tovalue(J, -1);

	if (JSV_ISSTRING(x) && JSV_ISSTRING(y))
		return !strcmp(JSV_TOSTRING(x), JSV_TOSTRING(y));

	if (x->t.type != y->t.type)
		return 0;
	if (x->t.type == JS_TUNDEFINED)
		return 1;
	if (x->t.type == JS_TNULL)
		return 1;
	if (x->t.type == JS_TNUMBER)
		return x->u.number == y->u.number;
	if (x->t.type == JS_TBOOLEAN)
		return x->u.boolean == y->u.boolean;
	if (x->t.type == JS_TOBJECT)
		return x->u.object == y->u.object;
	return 0;
}