static EjsAny *invokeNamespaceOperator(Ejs *ejs, EjsNamespace *lhs, int opCode, EjsNamespace *rhs)
{
bool boolResult;
switch (opCode) {
case EJS_OP_COMPARE_EQ:
if (!ejsIsDefined(ejs, rhs)) {
return ((opCode == EJS_OP_COMPARE_EQ) ? ESV(false): ESV(true));
}
boolResult = ejsCompareString(ejs, lhs->value, rhs->value) == 0;
break;
case EJS_OP_COMPARE_STRICTLY_EQ:
boolResult = lhs == rhs;
break;
case EJS_OP_COMPARE_NE:
if (!ejsIsDefined(ejs, rhs)) {
return ((opCode == EJS_OP_COMPARE_EQ) ? ESV(false): ESV(true));
}
boolResult = !(ejsCompareString(ejs, lhs->value, rhs->value) == 0);
break;
case EJS_OP_COMPARE_STRICTLY_NE:
boolResult = !(lhs == rhs);
break;
default:
ejsThrowTypeError(ejs, "Operation is not valid on this type");
return 0;
}
return ejsCreateBoolean(ejs, boolResult);
}
static EjsVar *coerceVoidOperands(Ejs *ejs, EjsVoid *lhs, int opcode, EjsVoid *rhs)
{
switch (opcode) {
case EJS_OP_ADD:
if (!ejsIsNumber(rhs)) {
return ejsInvokeOperator(ejs, (EjsVar*) ejsToString(ejs, lhs), opcode, rhs);
}
/* Fall through */
case EJS_OP_AND: case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_OR: case EJS_OP_REM:
case EJS_OP_SHL: case EJS_OP_SHR: case EJS_OP_SUB: case EJS_OP_USHR: case EJS_OP_XOR:
return ejsInvokeOperator(ejs, (EjsVar*) ejs->nanValue, opcode, rhs);
/*
* Comparision
*/
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_LT:
case EJS_OP_COMPARE_GE: case EJS_OP_COMPARE_GT:
return (EjsVar*) ejs->falseValue;
case EJS_OP_COMPARE_NE:
case EJS_OP_COMPARE_STRICTLY_NE:
if (ejsIsNull(rhs)) {
return (EjsVar*) ejs->falseValue;
}
return (EjsVar*) ejs->trueValue;
case EJS_OP_COMPARE_EQ:
case EJS_OP_COMPARE_STRICTLY_EQ:
if (ejsIsNull(rhs)) {
return (EjsVar*) ejs->trueValue;
}
return (EjsVar*) ejs->falseValue;
/*
* Unary operators
*/
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return 0;
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_NULL:
return (EjsVar*) ejs->trueValue;
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return (EjsVar*) ejs->falseValue;
default:
ejsThrowTypeError(ejs, "Opcode %d not valid for type %s", opcode, lhs->type->qname.name);
return ejs->undefinedValue;
}
return 0;
}
/*
* Coerce operands for invokeOperator
*/
static EjsVar *coerceBooleanOperands(Ejs *ejs, EjsVar *lhs, int opcode, EjsVar *rhs)
{
switch (opcode) {
case EJS_OP_ADD:
if (ejsIsUndefined(rhs)) {
return (EjsVar*) ejs->nanValue;
} else if (ejsIsNull(rhs) || ejsIsNumber(rhs) || ejsIsDate(rhs)) {
return ejsInvokeOperator(ejs, (EjsVar*) ejsToNumber(ejs, lhs), opcode, rhs);
} else {
return ejsInvokeOperator(ejs, (EjsVar*) ejsToString(ejs, lhs), opcode, rhs);
}
break;
case EJS_OP_AND: case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_OR: case EJS_OP_REM:
case EJS_OP_SHL: case EJS_OP_SHR: case EJS_OP_SUB: case EJS_OP_USHR: case EJS_OP_XOR:
return ejsInvokeOperator(ejs, (EjsVar*) ejsToNumber(ejs, lhs), opcode, rhs);
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_LT:
case EJS_OP_COMPARE_GE: case EJS_OP_COMPARE_GT:
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_NE:
if (ejsIsString(rhs)) {
return ejsInvokeOperator(ejs, (EjsVar*) ejsToString(ejs, lhs), opcode, rhs);
}
return ejsInvokeOperator(ejs, (EjsVar*) ejsToNumber(ejs, lhs), opcode, rhs);
case EJS_OP_COMPARE_STRICTLY_NE:
return (EjsVar*) ejs->trueValue;
case EJS_OP_COMPARE_STRICTLY_EQ:
return (EjsVar*) ejs->falseValue;
/*
* Unary operators
*/
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return 0;
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_TRUE:
return (EjsVar*) (((EjsBoolean*) lhs)->value ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_ZERO:
case EJS_OP_COMPARE_FALSE:
return (EjsVar*) (((EjsBoolean*) lhs)->value ? ejs->falseValue : ejs->trueValue);
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
return (EjsVar*) ejs->falseValue;
default:
ejsThrowTypeError(ejs, "Opcode %d not valid for type %s", opcode, lhs->type->qname.name);
return ejs->undefinedValue;
}
}
/*
Cast the object operand to a primitive type
*/
static EjsObj *xlCast(Ejs *ejs, EjsXML *vp, EjsType *type)
{
MprBuf *buf;
EjsObj *result;
EjsXML *elt, *item;
int next;
if (type == ESV(XML)) {
return (EjsObj*) vp;
}
switch (type->sid) {
case S_Object:
case S_Boolean:
return (EjsObj*) ejsCreateBoolean(ejs, 1);
case S_Number:
result = xlCast(ejs, vp, ESV(String));
result = (EjsObj*) ejsToNumber(ejs, result);
return result;
case S_String:
buf = mprCreateBuf(MPR_BUFSIZE, -1);
if (mprGetListLength(vp->elements) == 1) {
elt = mprGetFirstItem(vp->elements);
if (elt->kind == EJS_XML_ELEMENT) {
if (elt->elements == 0) {
return (EjsObj*) ESV(empty);
}
if (elt->elements && mprGetListLength(elt->elements) == 1) {
// TODO - what about PI and comments?
item = mprGetFirstItem(elt->elements);
if (item->kind == EJS_XML_TEXT) {
return (EjsObj*) item->value;
}
}
}
}
for (next = 0; (elt = mprGetNextItem(vp->elements, &next)) != 0; ) {
if (ejsXMLToBuf(ejs, buf, elt, -1) < 0) {
return 0;
}
if (next < vp->elements->length) {
mprPutStringToBuf(buf, " ");
}
}
return (EjsObj*) ejsCreateStringFromAsc(ejs, (char*) buf->start);
default:
ejsThrowTypeError(ejs, "Cannot cast to this type");
return 0;
}
}
/*
Cast operands as required for invokeArrayOperator
*/
static EjsObj *coerceArrayOperands(Ejs *ejs, EjsObj *lhs, int opcode, EjsObj *rhs)
{
switch (opcode) {
/*
Binary operators
*/
case EJS_OP_ADD:
return ejsInvokeOperator(ejs, arrayToString(ejs, (EjsArray*) lhs, 0, 0), opcode, rhs);
case EJS_OP_AND: case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_OR: case EJS_OP_REM:
case EJS_OP_SHL: case EJS_OP_SHR: case EJS_OP_SUB: case EJS_OP_USHR: case EJS_OP_XOR:
return ejsInvokeOperator(ejs, ESV(zero), opcode, rhs);
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_NE:
if (!ejsIsDefined(ejs, rhs)) {
return ((opcode == EJS_OP_COMPARE_EQ) ? ESV(false): ESV(true));
} else if (ejsIs(ejs, rhs, Number)) {
return ejsInvokeOperator(ejs, ejsToNumber(ejs, lhs), opcode, rhs);
}
return ejsInvokeOperator(ejs, ejsToString(ejs, lhs), opcode, rhs);
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_LT:
case EJS_OP_COMPARE_GE: case EJS_OP_COMPARE_GT:
if (ejsIs(ejs, rhs, Number)) {
return ejsInvokeOperator(ejs, ejsToNumber(ejs, lhs), opcode, rhs);
}
return ejsInvokeOperator(ejs, ejsToString(ejs, lhs), opcode, rhs);
case EJS_OP_COMPARE_STRICTLY_NE:
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_NULL:
return ESV(true);
case EJS_OP_COMPARE_STRICTLY_EQ:
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return ESV(false);
/*
Unary operators
*/
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return 0;
default:
ejsThrowTypeError(ejs, "Opcode %d not valid for type %@", opcode, TYPE(lhs)->qname.name);
return ESV(undefined);
}
}
static EjsAny *invokeNullOperator(Ejs *ejs, EjsObj *lhs, int opcode, EjsObj *rhs)
{
EjsObj *result;
if (rhs == 0 || TYPE(lhs) != TYPE(rhs)) {
if ((result = coerceNullOperands(ejs, lhs, opcode, rhs)) != 0) {
return result;
}
}
/*
Types now match. Both left and right types are both "null"
*/
switch (opcode) {
/*
NOTE: strict eq is the same as eq
*/
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_STRICTLY_EQ:
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_GE:
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_NULL:
return ESV(true);
case EJS_OP_COMPARE_NE: case EJS_OP_COMPARE_STRICTLY_NE:
case EJS_OP_COMPARE_LT: case EJS_OP_COMPARE_GT:
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return ESV(false);
/*
Unary operators
*/
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return ESV(one);
/*
Binary operators. Reinvoke with left = zero
*/
case EJS_OP_ADD: case EJS_OP_AND: case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_OR: case EJS_OP_REM:
case EJS_OP_SHL: case EJS_OP_SHR: case EJS_OP_SUB: case EJS_OP_USHR: case EJS_OP_XOR:
return ejsInvokeOperator(ejs, ESV(zero), opcode, rhs);
default:
ejsThrowTypeError(ejs, "Opcode %d not implemented for type %@", opcode, TYPE(lhs)->qname.name);
return 0;
}
}
static EjsAny *castNamespace(Ejs *ejs, EjsNamespace *vp, EjsType *type)
{
switch (type->sid) {
case S_Boolean:
return ejsCreateBoolean(ejs, 1);
case S_String:
return vp->value;
default:
ejsThrowTypeError(ejs, "Cannot cast to this type");
return 0;
}
}
static EjsVar *invokeVoidOperator(Ejs *ejs, EjsVoid *lhs, int opcode, EjsVoid *rhs)
{
EjsVar *result;
if (rhs == 0 || lhs->type != rhs->type) {
if ((result = coerceVoidOperands(ejs, lhs, opcode, rhs)) != 0) {
return result;
}
}
/*
* Types match, left and right types are both "undefined"
*/
switch (opcode) {
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_STRICTLY_EQ:
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_GE:
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_NULL:
return (EjsVar*) ejs->trueValue;
case EJS_OP_COMPARE_NE: case EJS_OP_COMPARE_STRICTLY_NE:
case EJS_OP_COMPARE_LT: case EJS_OP_COMPARE_GT:
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return (EjsVar*) ejs->falseValue;
/*
* Unary operators
*/
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return (EjsVar*) ejs->nanValue;
/*
* Binary operators
*/
case EJS_OP_ADD: case EJS_OP_AND: case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_OR: case EJS_OP_REM:
case EJS_OP_SHL: case EJS_OP_SHR: case EJS_OP_SUB: case EJS_OP_USHR: case EJS_OP_XOR:
return (EjsVar*) ejs->nanValue;
default:
ejsThrowTypeError(ejs, "Opcode %d not implemented for type %s", opcode, lhs->type->qname.name);
return 0;
}
mprAssert(0);
}
static EjsAny *coerceUriOperands(Ejs *ejs, EjsUri *lhs, int opcode, EjsAny *rhs)
{
HttpUri *uri;
char *ustr;
switch (opcode) {
/*
Binary operators
*/
case EJS_OP_ADD:
uri = lhs->uri;
ustr = httpFormatUri(uri->scheme, uri->host, uri->port, uri->path, uri->reference, uri->query, 0);
return ejsInvokeOperator(ejs, ejsCreateStringFromAsc(ejs, ustr), opcode, rhs);
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_NE:
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_LT:
case EJS_OP_COMPARE_GE: case EJS_OP_COMPARE_GT:
if (!ejsIsDefined(ejs, rhs)) {
return ((opcode == EJS_OP_COMPARE_EQ) ? ESV(false): ESV(true));
}
uri = lhs->uri;
ustr = httpFormatUri(uri->scheme, uri->host, uri->port, uri->path, uri->reference, uri->query, 0);
return ejsInvokeOperator(ejs, ejsCreateStringFromAsc(ejs, ustr), opcode, rhs);
case EJS_OP_COMPARE_STRICTLY_NE:
return ESV(true);
case EJS_OP_COMPARE_STRICTLY_EQ:
return ESV(false);
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_TRUE:
return ESV(true);
case EJS_OP_COMPARE_ZERO:
case EJS_OP_COMPARE_FALSE:
return ESV(false);
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
return ESV(false);
default:
ejsThrowTypeError(ejs, "Opcode %d not valid for type %@", opcode, TYPE(lhs)->qname.name);
return ESV(undefined);
}
return 0;
}
/*
Cast the object operand to a primitive type
*/
static EjsAny *castXml(Ejs *ejs, EjsXML *xml, EjsType *type)
{
EjsXML *item;
EjsObj *result;
MprBuf *buf;
assert(ejsIsXML(ejs, xml));
if (type == ESV(XMLList)) {
return xml;
}
switch (type->sid) {
case S_Object:
case S_Boolean:
return ejsCreateBoolean(ejs, 1);
case S_Number:
result = castXml(ejs, xml, ESV(String));
return ejsToNumber(ejs, result);
case S_String:
if (xml->kind == EJS_XML_ELEMENT) {
if (xml->elements == 0) {
return ESV(empty);
}
if (xml->elements && mprGetListLength(xml->elements) == 1) {
// TODO - what about PI and comments?
item = mprGetFirstItem(xml->elements);
if (item->kind == EJS_XML_TEXT) {
return item->value;
}
}
}
buf = mprCreateBuf(BIT_MAX_BUFFER, -1);
if (ejsXMLToBuf(ejs, buf, xml, -1) < 0) {
return 0;
}
return ejsCreateStringFromAsc(ejs, (char*) buf->start);
default:
ejsThrowTypeError(ejs, "Cannot cast to this type");
return 0;
}
return 0;
}
static EjsVar *castArray(Ejs *ejs, EjsArray *vp, EjsType *type)
{
switch (type->id) {
case ES_Boolean:
return (EjsVar*) ejs->trueValue;
case ES_Number:
return (EjsVar*) ejs->zeroValue;
case ES_String:
return arrayToString(ejs, vp, 0, 0);
default:
ejsThrowTypeError(ejs, "Can't cast to this type");
return 0;
}
}
/*
Cast the object operand to a primitive type
*/
static EjsAny *castArray(Ejs *ejs, EjsArray *vp, EjsType *type)
{
switch (type->sid) {
case ES_Boolean:
return ESV(true);
case ES_Number:
return ESV(zero);
case ES_String:
return arrayToString(ejs, vp, 0, 0);
default:
ejsThrowTypeError(ejs, "Cannot cast to this type");
return 0;
}
}
static EjsVar *castBooleanVar(Ejs *ejs, EjsBoolean *vp, EjsType *type)
{
mprAssert(ejsIsBoolean(vp));
switch (type->id) {
case ES_Number:
return (EjsVar*) ((vp->value) ? ejs->oneValue: ejs->zeroValue);
case ES_String:
return (EjsVar*) ejsCreateString(ejs, (vp->value) ? "true" : "false");
default:
ejsThrowTypeError(ejs, "Can't cast to this type");
return 0;
}
}
/*
Cast the operand to the specified type
function cast(type: Type) : Object
*/
static EjsAny *castRegExp(Ejs *ejs, EjsRegExp *rp, EjsType *type)
{
char *flags;
switch (type->sid) {
case S_Boolean:
return ESV(true);
case S_String:
flags = makeFlags(rp);
return ejsSprintf(ejs, "/%w/%s", rp->pattern, flags);
default:
ejsThrowTypeError(ejs, "Can't cast to this type");
return 0;
}
return 0;
}
static EjsVar *castVoid(Ejs *ejs, EjsVoid *vp, EjsType *type)
{
switch (type->id) {
case ES_Boolean:
return (EjsVar*) ejs->falseValue;
case ES_Number:
return (EjsVar*) ejs->nanValue;
case ES_Object:
return vp;
case ES_String:
return (EjsVar*) ejsCreateString(ejs, "undefined");
default:
ejsThrowTypeError(ejs, "Can't cast to this type");
return 0;
}
}
static int checkSlot(Ejs *ejs, EjsArray *ap, int slotNum)
{
if (slotNum < 0) {
if (!ap->obj.var.dynamic) {
ejsThrowTypeError(ejs, "Object is not dynamic");
return EJS_ERR;
}
slotNum = ap->length;
if (growArray(ejs, ap, ap->length + 1) < 0) {
ejsThrowMemoryError(ejs);
return EJS_ERR;
}
} else if (slotNum >= ap->length) {
if (growArray(ejs, ap, slotNum + 1) < 0) {
ejsThrowMemoryError(ejs);
return EJS_ERR;
}
}
return slotNum;
}
/*
Cast the operand to the specified type
function cast(type: Type) : Object
*/
static EjsAny *castRegExp(Ejs *ejs, EjsRegExp *rp, EjsType *type)
{
wchar *pattern;
char *flags;
ssize len, flen;
int i, j;
switch (type->sid) {
case S_Boolean:
return ESV(true);
case S_String:
flags = makeFlags(rp);
len = wlen(rp->pattern);
flen = wlen(flags);
pattern = mprAlloc((len * 2 + flen + 1) * sizeof(wchar));
/*
Convert to a form that is a valid, parsable as regular expression literal
*/
pattern[0] = '/';
for (i = 0, j = 1; i < len; i++) {
if (rp->pattern[i] == '/') {
pattern[j++] = '\\';
}
pattern[j++] = rp->pattern[i];
}
pattern[j++] = '/';
for (i = 0; i < flen; i++) {
pattern[j++] = flags[i];
}
pattern[j] = 0;
return ejsCreateStringFromAsc(ejs, pattern);
default:
ejsThrowTypeError(ejs, "Cannot cast to this type");
return 0;
}
return 0;
}
static EjsAny *castVoid(Ejs *ejs, EjsVoid *vp, EjsType *type)
{
switch (type->sid) {
case S_Boolean:
return ESV(false);
case S_Number:
return ESV(nan);
case S_Object:
return vp;
case S_String:
return ejsCreateStringFromAsc(ejs, "undefined");
case S_Uri:
return ejsCreateUriFromAsc(ejs, "undefined");
default:
ejsThrowTypeError(ejs, "Cannot cast to this type");
return 0;
}
}
static EjsVar *castError(Ejs *ejs, EjsError *vp, EjsType *type)
{
EjsVar *sp;
char *buf;
switch (type->id) {
case ES_Boolean:
return (EjsVar*) ejsCreateBoolean(ejs, 1);
case ES_String:
if ((buf = mprAsprintf(ejs, -1,
"%s Exception: %s\nStack:\n%s\n", vp->obj.var.type->qname.name, vp->message, vp->stack)) == NULL) {
ejsThrowMemoryError(ejs);
}
sp = (EjsVar*) ejsCreateString(ejs, buf);
mprFree(buf);
return sp;
default:
ejsThrowTypeError(ejs, "Unknown type");
return 0;
}
}
/*
Cast the operand to the specified type
function cast(type: Type) : Object
*/
static EjsAny *castError(Ejs *ejs, EjsError *error, EjsType *type)
{
EjsString *stack, *msg;
EjsString *us;
char *buf;
switch (type->sid) {
case S_Boolean:
return ejsCreateBoolean(ejs, 1);
case S_String:
stack = (EjsString*) ejsRunFunctionBySlot(ejs, error, ES_Error_formatStack, 0, NULL);
us = ejsIs(ejs, stack, String) ? stack : ESV(empty);
msg = ejsGetProperty(ejs, error, ES_Error_message);
if ((buf = sfmt("%@ Exception: %@\nStack:\n%@\n", TYPE(error)->qname.name, msg, us)) == NULL) {
ejsThrowMemoryError(ejs);
}
return ejsCreateStringFromAsc(ejs, buf);
default:
ejsThrowTypeError(ejs, "Unknown type");
}
return 0;
}
static EjsAny *invokeUriOperator(Ejs *ejs, EjsUri *lhs, int opcode, EjsUri *rhs, void *data)
{
EjsAny *result;
if (rhs == 0 || TYPE(lhs) != TYPE(rhs)) {
if ((result = coerceUriOperands(ejs, lhs, opcode, rhs)) != 0) {
return result;
}
}
/* Types now match, both Uris
*/
switch (opcode) {
case EJS_OP_COMPARE_STRICTLY_EQ:
case EJS_OP_COMPARE_EQ:
if (lhs == rhs || (lhs->uri == rhs->uri)) {
return ESV(true);
}
return ejsCreateBoolean(ejs, same(ejs, lhs->uri, rhs->uri, 1));
case EJS_OP_COMPARE_NE:
case EJS_OP_COMPARE_STRICTLY_NE:
return ejsCreateBoolean(ejs, !same(ejs, lhs->uri, rhs->uri, 1));
/* NOTE: these only compare the paths */
case EJS_OP_COMPARE_LT:
return ejsCreateBoolean(ejs, scmp(lhs->uri->path, rhs->uri->path) < 0);
case EJS_OP_COMPARE_LE:
return ejsCreateBoolean(ejs, scmp(lhs->uri->path, rhs->uri->path) <= 0);
case EJS_OP_COMPARE_GT:
return ejsCreateBoolean(ejs, scmp(lhs->uri->path, rhs->uri->path) > 0);
case EJS_OP_COMPARE_GE:
return ejsCreateBoolean(ejs, scmp(lhs->uri->path, rhs->uri->path) >= 0);
/*
Unary operators
*/
case EJS_OP_COMPARE_NOT_ZERO:
return ((lhs->uri->path) ? ESV(true): ESV(false));
case EJS_OP_COMPARE_ZERO:
return ((lhs->uri->path == 0) ? ESV(true): ESV(false));
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
return ESV(false);
/*
Binary operators
*/
case EJS_OP_ADD:
return uri_join(ejs, lhs, 1, (EjsObj**) &rhs);
default:
ejsThrowTypeError(ejs, "Opcode %d not implemented for type %@", opcode, TYPE(lhs)->qname.name);
return 0;
}
assure(0);
}
static EjsString *serialize(Ejs *ejs, EjsAny *vp, Json *json)
{
EjsName qname;
EjsFunction *fn;
EjsString *result, *sv;
EjsTrait *trait;
EjsObj *pp, *obj, *replacerArgs[2];
wchar *cp;
cchar *key;
int c, isArray, i, count, slotNum, quotes;
/*
The main code below can handle Arrays, Objects, objects derrived from Object and also native classes with properties.
All others just use toString.
*/
count = ejsIsPot(ejs, vp) ? ejsGetLength(ejs, vp) : 0;
if (count == 0 && TYPE(vp) != ESV(Object) && TYPE(vp) != ESV(Array)) {
// OPT - need some flag for this test.
if (!ejsIsDefined(ejs, vp) || ejsIs(ejs, vp, Boolean) || ejsIs(ejs, vp, Number)) {
return ejsToString(ejs, vp);
} else if (json->regexp) {
return ejsToString(ejs, vp);
} else {
return ejsToLiteralString(ejs, vp);
}
}
obj = vp;
json->nest++;
if (json->buf == 0) {
json->buf = mprCreateBuf(0, 0);
mprAddRoot(json->buf);
}
isArray = ejsIs(ejs, vp, Array);
mprPutCharToWideBuf(json->buf, isArray ? '[' : '{');
if (json->pretty) {
mprPutCharToWideBuf(json->buf, '\n');
}
if (++ejs->serializeDepth <= json->depth && !VISITED(obj)) {
SET_VISITED(obj, 1);
for (slotNum = 0; slotNum < count && !ejs->exception; slotNum++) {
trait = ejsGetPropertyTraits(ejs, obj, slotNum);
if (trait && (trait->attributes & (EJS_TRAIT_HIDDEN | EJS_TRAIT_DELETED | EJS_FUN_INITIALIZER |
EJS_FUN_MODULE_INITIALIZER)) && !json->hidden) {
continue;
}
pp = ejsGetProperty(ejs, obj, slotNum);
if (ejs->exception) {
SET_VISITED(obj, 0);
json->nest--;
return 0;
}
if (pp == 0) {
continue;
}
if (isArray) {
key = itos(slotNum);
qname.name = ejsCreateStringFromAsc(ejs, key);
qname.space = ESV(empty);
} else {
qname = ejsGetPropertyName(ejs, vp, slotNum);
}
quotes = json->quotes;
if (!quotes) {
// UNICODE
for (cp = qname.name->value; cp < &qname.name->value[qname.name->length]; cp++) {
if (!isalnum((uchar) *cp) && *cp != '_') {
quotes = 1;
break;
}
}
}
if (json->pretty) {
for (i = 0; i < ejs->serializeDepth; i++) {
mprPutStringToWideBuf(json->buf, json->indent);
}
}
if (!isArray) {
if (json->namespaces) {
if (qname.space != ESV(empty)) {
mprPutToBuf(json->buf, "\"%@\"::", qname.space);
}
}
if (quotes) {
mprPutCharToWideBuf(json->buf, '"');
}
for (cp = qname.name->value; cp && *cp; cp++) {
c = *cp;
if (c == '"' || c == '\\') {
mprPutCharToWideBuf(json->buf, '\\');
mprPutCharToWideBuf(json->buf, c);
} else {
mprPutCharToWideBuf(json->buf, c);
}
}
if (quotes) {
mprPutCharToWideBuf(json->buf, '"');
}
mprPutCharToWideBuf(json->buf, ':');
if (json->pretty) {
mprPutCharToWideBuf(json->buf, ' ');
}
}
fn = (EjsFunction*) ejsGetPropertyByName(ejs, TYPE(pp)->prototype, N(NULL, "toJSON"));
// OPT - check that this is going directly to serialize most of the time
if (!ejsIsFunction(ejs, fn) || (fn->isNativeProc && fn->body.proc == (EjsProc) ejsObjToJSON)) {
sv = serialize(ejs, pp, json);
} else {
sv = (EjsString*) ejsRunFunction(ejs, fn, pp, 1, &json->options);
}
if (sv == 0 || !ejsIs(ejs, sv, String)) {
if (ejs->exception) {
ejsThrowTypeError(ejs, "Cannot serialize property %@", qname.name);
SET_VISITED(obj, 0);
return 0;
}
} else {
if (json->replacer) {
replacerArgs[0] = (EjsObj*) qname.name;
replacerArgs[1] = (EjsObj*) sv;
/* function replacer(key: String, value: String): String */
sv = ejsRunFunction(ejs, json->replacer, obj, 2, (EjsObj**) replacerArgs);
}
mprPutBlockToBuf(json->buf, sv->value, sv->length * sizeof(wchar));
}
if ((slotNum + 1) < count || json->commas) {
mprPutCharToWideBuf(json->buf, ',');
}
if (json->pretty) {
mprPutCharToWideBuf(json->buf, '\n');
}
}
SET_VISITED(obj, 0);
}
--ejs->serializeDepth;
if (json->pretty) {
for (i = ejs->serializeDepth; i > 0; i--) {
mprPutStringToWideBuf(json->buf, json->indent);
}
}
mprPutCharToWideBuf(json->buf, isArray ? ']' : '}');
mprAddNullToWideBuf(json->buf);
if (--json->nest == 0) {
result = ejsCreateString(ejs, mprGetBufStart(json->buf), mprGetBufLength(json->buf) / sizeof(wchar));
mprRemoveRoot(json->buf);
} else {
result = 0;
}
return result;
}
/*
Process a message sent from postMessage. This may run inside the worker or outside in the parent depending on the
direction of the message. But it ALWAYS runs in the appropriate thread for the interpreter.
*/
static int doMessage(Message *msg, MprEvent *mprEvent)
{
Ejs *ejs;
EjsObj *event, *frame;
EjsWorker *worker;
EjsFunction *callback;
EjsObj *argv[1];
worker = msg->worker;
worker->gotMessage = 1;
ejs = worker->ejs;
assert(!ejs->exception);
event = 0;
ejsBlockGC(ejs);
callback = ejsGetProperty(ejs, worker, msg->callbackSlot);
switch (msg->callbackSlot) {
case ES_Worker_onerror:
event = ejsCreateObj(ejs, ESV(ErrorEvent), 0);
break;
case ES_Worker_onclose:
case ES_Worker_onmessage:
event = ejsCreateObj(ejs, ESV(Event), 0);
break;
default:
assert(msg->callbackSlot == 0);
return 0;
}
worker->event = event;
if (msg->data) {
ejsSetProperty(ejs, event, ES_Event_data, ejsCreateStringFromAsc(ejs, msg->data));
}
if (msg->message) {
ejsSetProperty(ejs, event, ES_ErrorEvent_message, msg->message);
}
if (msg->stack) {
ejsSetProperty(ejs, event, ES_ErrorEvent_stack, msg->stack);
if ((frame = ejsGetProperty(ejs, msg->stack, 0)) != 0 && !ejsIs(ejs, frame, Void)) {
ejsSetProperty(ejs, event, ES_ErrorEvent_filename, ejsGetPropertyByName(ejs, frame, EN("filename")));
ejsSetProperty(ejs, event, ES_ErrorEvent_lineno, ejsGetPropertyByName(ejs, frame, EN("lineno")));
}
}
assert(!ejs->exception);
if (callback == 0 || ejsIs(ejs, callback, Null)) {
if (msg->callbackSlot == ES_Worker_onmessage) {
mprTrace(6, "Discard message as no onmessage handler defined for worker");
} else if (msg->callbackSlot == ES_Worker_onerror) {
if (ejsIs(ejs, msg->message, String)) {
ejsThrowError(ejs, "Exception in Worker: %@", ejsToString(ejs, msg->message));
} else {
ejsThrowError(ejs, "Exception in Worker: %s", ejsGetErrorMsg(worker->pair->ejs, 1));
}
} else {
/* Ignore onclose message */
}
} else if (!ejsIsFunction(ejs, callback)) {
ejsThrowTypeError(ejs, "Worker callback %s is not a function", msg->callback);
} else {
assert(!ejs->exception);
argv[0] = event;
ejsRunFunction(ejs, callback, worker, 1, argv);
}
if (msg->callbackSlot == ES_Worker_onclose) {
assert(!worker->inside);
worker->state = EJS_WORKER_COMPLETE;
mprTrace(5, "Worker.doMessage: complete");
/* Worker and insider interpreter are now eligible for garbage collection */
removeWorker(worker);
}
mprSignalDispatcher(ejs->dispatcher);
worker->event = 0;
return 0;
}
/*
Delete an instance property by name.
*/
static int deletePropertyByName(Ejs *ejs, EjsObject *obj, EjsName *qname)
{
ejsThrowTypeError(ejs, "Can't delete properties for this type");
return EJS_ERR;
}
/*
Delete the property at the specified slot.
@param ejs VM handle.
@param sp is set to the object instance.
@returns 0 if the delete is successful. Otherwise a negative error code.
*/
static int deleteProperty(Ejs *ejs, Shape *sp, const char *prop)
{
ejsThrowTypeError(ejs, "Can't delete properties for this type");
return EJS_ERR;
}
static EjsAny *coerceNullOperands(Ejs *ejs, EjsObj *lhs, int opcode, EjsObj *rhs)
{
switch (opcode) {
case EJS_OP_ADD:
if (!ejsIs(ejs, rhs, Number)) {
return ejsInvokeOperator(ejs, ejsToString(ejs, lhs), opcode, rhs);
}
/* Fall through */
case EJS_OP_AND: case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_OR: case EJS_OP_REM:
case EJS_OP_SHL: case EJS_OP_SHR: case EJS_OP_SUB: case EJS_OP_USHR: case EJS_OP_XOR:
return ejsInvokeOperator(ejs, ESV(zero), opcode, rhs);
/*
Comparision
*/
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_LT:
case EJS_OP_COMPARE_GE: case EJS_OP_COMPARE_GT:
if (ejsIs(ejs, rhs, Number)) {
return ejsInvokeOperator(ejs, ESV(zero), opcode, rhs);
} else if (ejsIs(ejs, rhs, String)) {
return ejsInvokeOperator(ejs, ejsToString(ejs, lhs), opcode, rhs);
}
break;
case EJS_OP_COMPARE_NE:
if (ejsIs(ejs, rhs, Void)) {
return ESV(false);
}
return ESV(true);
case EJS_OP_COMPARE_STRICTLY_NE:
return ESV(true);
case EJS_OP_COMPARE_EQ:
if (ejsIs(ejs, rhs, Void)) {
return ESV(true);
}
return ESV(false);
case EJS_OP_COMPARE_STRICTLY_EQ:
return ESV(false);
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_NULL:
return ESV(true);
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return ESV(false);
/*
Unary operators
*/
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return 0;
default:
ejsThrowTypeError(ejs, "Opcode %d not valid for type %@", opcode, TYPE(lhs)->qname.name);
return ESV(undefined);
}
return 0;
}
static EjsAny *invokeArrayOperator(Ejs *ejs, EjsAny *lhs, int opcode, EjsAny *rhs)
{
EjsAny *result;
if (rhs == 0 || TYPE(lhs) != TYPE(rhs)) {
if ((result = coerceArrayOperands(ejs, lhs, opcode, rhs)) != 0) {
return result;
}
}
switch (opcode) {
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_STRICTLY_EQ:
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_GE:
return ejsCreateBoolean(ejs, (lhs == rhs));
case EJS_OP_COMPARE_NE: case EJS_OP_COMPARE_STRICTLY_NE:
case EJS_OP_COMPARE_LT: case EJS_OP_COMPARE_GT:
return ejsCreateBoolean(ejs, !(lhs == rhs));
/*
Unary operators
*/
case EJS_OP_COMPARE_NOT_ZERO:
return ESV(true);
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return ESV(false);
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return ESV(one);
/*
Binary operators
*/
case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_REM:
case EJS_OP_SHR: case EJS_OP_USHR: case EJS_OP_XOR:
return ESV(zero);
/*
Operator overload
*/
case EJS_OP_ADD:
result = ejsCreateArray(ejs, 0);
pushArray(ejs, result, 1, &lhs);
pushArray(ejs, result, 1, &rhs);
return result;
case EJS_OP_AND:
return makeIntersection(ejs, lhs, rhs);
case EJS_OP_OR:
return makeUnion(ejs, lhs, rhs);
case EJS_OP_SHL:
return pushArray(ejs, lhs, 1, &rhs);
case EJS_OP_SUB:
return ejsRemoveItems(ejs, lhs, rhs);
default:
ejsThrowTypeError(ejs, "Opcode %d not implemented for type %@", opcode, TYPE(lhs)->qname.name);
return 0;
}
assert(0);
}
static EjsVar *invokeArrayOperator(Ejs *ejs, EjsVar *lhs, int opcode, EjsVar *rhs)
{
EjsVar *result;
if (rhs == 0 || lhs->type != rhs->type) {
if ((result = coerceArrayOperands(ejs, lhs, opcode, rhs)) != 0) {
return result;
}
}
switch (opcode) {
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_STRICTLY_EQ:
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_GE:
return (EjsVar*) ejsCreateBoolean(ejs, (lhs == rhs));
case EJS_OP_COMPARE_NE: case EJS_OP_COMPARE_STRICTLY_NE:
case EJS_OP_COMPARE_LT: case EJS_OP_COMPARE_GT:
return (EjsVar*) ejsCreateBoolean(ejs, !(lhs == rhs));
/*
* Unary operators
*/
case EJS_OP_COMPARE_NOT_ZERO:
return (EjsVar*) ejs->trueValue;
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
case EJS_OP_COMPARE_FALSE:
case EJS_OP_COMPARE_TRUE:
case EJS_OP_COMPARE_ZERO:
return (EjsVar*) ejs->falseValue;
case EJS_OP_LOGICAL_NOT: case EJS_OP_NOT: case EJS_OP_NEG:
return (EjsVar*) ejs->oneValue;
/*
* Binary operators
*/
case EJS_OP_DIV: case EJS_OP_MUL: case EJS_OP_REM:
case EJS_OP_SHR: case EJS_OP_USHR: case EJS_OP_XOR:
return (EjsVar*) ejs->zeroValue;
#if BLD_FEATURE_EJS_LANG >= EJS_SPEC_PLUS
/*
* Operator overload
*/
case EJS_OP_ADD:
result = (EjsVar*) ejsCreateArray(ejs, 0);
pushArray(ejs, (EjsArray*) result, 1, (EjsVar**) &lhs);
pushArray(ejs, (EjsArray*) result, 1, (EjsVar**) &rhs);
return result;
case EJS_OP_AND:
return (EjsVar*) makeIntersection(ejs, (EjsArray*) lhs, (EjsArray*) rhs);
case EJS_OP_OR:
return (EjsVar*) makeUnion(ejs, (EjsArray*) lhs, (EjsArray*) rhs);
case EJS_OP_SHL:
return pushArray(ejs, (EjsArray*) lhs, 1, &rhs);
case EJS_OP_SUB:
return (EjsVar*) removeArrayElements(ejs, (EjsArray*) lhs, (EjsArray*) rhs);
#endif
default:
ejsThrowTypeError(ejs, "Opcode %d not implemented for type %s", opcode, lhs->type->qname.name);
return 0;
}
mprAssert(0);
}
/*
Set a property by name
There are 7 kinds of qname's: prop, @att, [prop], *, @*, .name, .@name
*/
static int setXmlPropertyByName(Ejs *ejs, EjsXML *xml, EjsName qname, EjsObj *value)
{
EjsXML *elt, *xvalue, *rp, *lastElt;
EjsObj *originalValue;
int index, last;
last = 0;
lastElt = 0;
if (isdigit((uchar) qname.name->value[0]) && allDigitsForXml(qname.name)) {
ejsThrowTypeError(ejs, "Integer indicies for set are not allowed");
return EJS_ERR;
}
if (xml->kind != EJS_XML_ELEMENT) {
// TODO spec requires this -- but why? -- surely throw?
return 0;
}
/*
Massage the value type.
*/
originalValue = value;
xvalue = (EjsXML*) value;
if (ejsIsXML(ejs, xvalue)) {
if (xvalue->kind == EJS_XML_LIST) {
value = cloneXml(ejs, xvalue, 1);
} else if (xvalue->kind == EJS_XML_TEXT || xvalue->kind == EJS_XML_ATTRIBUTE) {
value = ejsCast(ejs, originalValue, String);
} else {
value = cloneXml(ejs, xvalue, 1);
}
} else {
value = ejsCast(ejs, value, String);
}
if (qname.name->value[0] == '@') {
return setXmlPropertyAttributeByName(ejs, xml, qname, value);
}
/*
Delete redundant elements by the same name.
*/
if (xml->elements) {
for (last = -1, index = -1; (elt = mprGetPrevItem(xml->elements, &index)) != 0; ) {
if (qname.name->value[0] == '*' || (elt->kind == EJS_XML_ELEMENT && elt->qname.name == qname.name)) {
/*
Must remove all redundant elements of the same name except the first one
*/
if (last >= 0) {
rp = mprGetItem(xml->elements, last);
rp->parent = 0;
mprRemoveItemAtPos(xml->elements, last);
}
last = index;
lastElt = elt;
}
}
}
if (xml->elements == 0) {
// TODO - need routine to do this centrally so we can control the default number of elements in the list?
xml->elements = mprCreateList(-1, 0);
}
elt = lastElt;
index = last;
if (qname.name->value[0] == '*') {
/*
Special case when called from XMLList to update the value of an element
*/
xml = createValueNode(ejs, xml, value);
} else if (elt == 0) {
/*
Not found. New node required.
*/
elt = ejsCreateXML(ejs, EJS_XML_ELEMENT, qname, xml, NULL);
if (elt == 0) {
return 0;
}
index = mprGetListLength(xml->elements);
xml = ejsAppendToXML(ejs, xml, createValueNode(ejs, elt, value));
} else {
/*
Update existing element.
*/
xml = ejsSetXMLElement(ejs, xml, index, createValueNode(ejs, elt, value));
}
if (xml == 0) {
return EJS_ERR;
}
return index;
}
/*
* Run an operator on the operands
*/
static EjsVar *invokeBooleanOperator(Ejs *ejs, EjsBoolean *lhs, int opcode, EjsBoolean *rhs)
{
EjsVar *result;
if (rhs == 0 || lhs->var.type != rhs->var.type) {
if ((result = coerceBooleanOperands(ejs, (EjsVar*) lhs, opcode, (EjsVar*) rhs)) != 0) {
return result;
}
}
/*
* Types now match
*/
switch (opcode) {
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_STRICTLY_EQ:
return (EjsVar*) ((lhs->value == rhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_NE: case EJS_OP_COMPARE_STRICTLY_NE:
return (EjsVar*) ((lhs->value != rhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_LT:
return (EjsVar*) ((lhs->value < rhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_LE:
return (EjsVar*) ((lhs->value <= rhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_GT:
return (EjsVar*) ((lhs->value > rhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_GE:
return (EjsVar*) ((lhs->value >= rhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_NOT_ZERO:
return (EjsVar*) ((lhs->value) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_ZERO:
return (EjsVar*) ((lhs->value == 0) ? ejs->trueValue: ejs->falseValue);
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
return (EjsVar*) ejs->falseValue;
case EJS_OP_COMPARE_FALSE:
return (EjsVar*) ((lhs->value) ? ejs->falseValue: ejs->trueValue);
case EJS_OP_COMPARE_TRUE:
return (EjsVar*) ((lhs->value) ? ejs->trueValue: ejs->falseValue);
/*
* Unary operators
*/
case EJS_OP_NEG:
return (EjsVar*) ejsCreateNumber(ejs, - lhs->value);
case EJS_OP_LOGICAL_NOT:
return (EjsVar*) ejsCreateBoolean(ejs, !lhs->value);
case EJS_OP_NOT:
return (EjsVar*) ejsCreateBoolean(ejs, ~lhs->value);
/*
* Binary operations
*/
case EJS_OP_ADD:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value + rhs->value);
case EJS_OP_AND:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value & rhs->value);
case EJS_OP_DIV:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value / rhs->value);
case EJS_OP_MUL:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value * rhs->value);
case EJS_OP_OR:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value | rhs->value);
case EJS_OP_REM:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value % rhs->value);
case EJS_OP_SUB:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value - rhs->value);
case EJS_OP_USHR:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value >> rhs->value);
case EJS_OP_XOR:
return (EjsVar*) ejsCreateBoolean(ejs, lhs->value ^ rhs->value);
default:
ejsThrowTypeError(ejs, "Opcode %d not implemented for type %s", opcode, lhs->var.type->qname.name);
return 0;
}
}
