Attachment #586029 for bug #715359

Attachment #586029: WIP v1 for bug #715359

View | Details | Raw Unified | Return to bug 715359
Collapse All | Expand All





      case PNK_ADD:
      case PNK_SUB:
      case PNK_BITOR:
      case PNK_BITXOR:
      case PNK_BITAND:
      case PNK_STRICTEQ:
      case PNK_EQ:
      case PNK_STRICTNE:
      case PNK_IS:
      case PNK_ISNT:
      case PNK_NE:
      case PNK_LT:
      case PNK_LE:
      case PNK_GT:
      case PNK_GE:
      case PNK_IN:
      case PNK_INSTANCEOF:
      case PNK_LSH:





     */

    /* Equality operators. */
    PNK_STRICTEQ,
    PNK_EQ,
    PNK_STRICTNE,
    PNK_NE,

    /* Harmony is/isnt */
    PNK_IS,
    PNK_ISNT,

    /* Unary operators. */
    PNK_TYPEOF,
    PNK_VOID,
    PNK_NOT,
    PNK_BITNOT,

    /* Relational operators (< <= > >=). */
    PNK_LT,





      case TOK_STRICTNE:
        return PNK_STRICTNE;
      default:
        JS_ASSERT(token.type == TOK_NE);
        return PNK_NE;
    }
}

bool
TokenIsHarmonyEquality(const Token &token, JSContext *cx)
{
    if (token.type != TOK_NAME)
        return false;
    if (token.name() == cx->runtime->atomState.isAtom)
        return true;
    if (token.name() == cx->runtime->atomState.isntAtom)
        return true;
    return false;
}

BEGIN_EXPR_PARSER(eqExpr1)
{
    ParseNode *left = relExpr1i();
    while (left) {
        if (TokenIsHarmonyEquality(tokenStream.currentToken(), context)) {
            /* Is defined as [no LineTerminator here]. */
            if (left->pn_pos.end.lineno < tokenStream.currentToken().pos.begin.lineno) {
                reportErrorNumber(NULL, JSREPORT_ERROR, JSMSG_NEW_LINE_BEFORE_IS);
                return NULL;
            }

            JSOp op;
            ParseNodeKind kind;
            if (tokenStream.currentToken().name() == context->runtime->atomState.isAtom) {
                op = JSOP_IS;
                kind = PNK_IS;
            } else {
                op = JSOP_ISNT;
                kind = PNK_ISNT;
            }

            ParseNode *right = relExpr1n();
            if (!right)
                return NULL;
            left = tc->parser->new_<BinaryNode>(kind, op, left, right);
        } else if (tokenStream.isCurrentTokenEquality()) {
            ParseNodeKind kind = EqualityTokenToParseNodeKind(tokenStream.currentToken());
            JSOp op = tokenStream.currentToken().t_op;
            ParseNode *right = relExpr1n();
            if (!right)
                return NULL;
            left = tc->parser->new_<BinaryNode>(kind, op, left, right);
        } else {
            break;
        }
    }
    return left;
}
END_EXPR_PARSER(eqExpr1)

BEGIN_EXPR_PARSER(bitAndExpr1)
{
    ParseNode *pn = eqExpr1i();

-      Line
+  Link Here
-      Line 0
+  Link Here
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+assertEq(1 is 1, true);
+assertEq(0 is 1, false);
+assertEq(NaN is NaN, true);
+assertEq(NaN is undefined, false);
+assertEq(Infinity is Infinity, true);
+assertEq(Infinity is -Infinity, false);
+assertEq(0 is 0, true);
+assertEq(0 is -0, false);
+assertEq(-0 is 0, false);
+var obj = {};
+assertEq(obj is obj, true);
+function throws(code) {
+    var error;
+    try {
+        eval(code);
+    } catch (e) {
+        error = e;
+    }
+    assertEq(error.name, 'SyntaxError');
+}
+var is = 0;
+assertEq(is is 0, true);
+assertEq(is isnt 0, false);
+throws('0 \n is 1');
+throws('(0 == 1) \n is 1');
+assertEq((0 ==
+) is true, false);
+var a;
+a = (1 is 1) == true;
+assertEq(a, true);

(-)a/js/src/js.msg (+1 lines)

Line	Link Here

Lines 369-376 MSG_DEF(JSMSG_DEBUG_BAD_OFFSET, 28	Link Here

369

MSG_DEF(JSMSG_DEBUG_BAD_LINE,         283, 0, JSEXN_TYPEERR, "invalid line number")

369

MSG_DEF(JSMSG_DEBUG_BAD_LINE,         283, 0, JSEXN_TYPEERR, "invalid line number")

370

MSG_DEF(JSMSG_DEBUG_NOT_DEBUGGING,    284, 0, JSEXN_ERR, "can't set breakpoint: script global is not a debuggee")

370

MSG_DEF(JSMSG_DEBUG_NOT_DEBUGGING,    284, 0, JSEXN_ERR, "can't set breakpoint: script global is not a debuggee")

371

MSG_DEF(JSMSG_DEBUG_COMPARTMENT_MISMATCH, 285, 2, JSEXN_TYPEERR, "{0}: descriptor .{1} property is an object in a different compartment than the target object")

371

MSG_DEF(JSMSG_DEBUG_COMPARTMENT_MISMATCH, 285, 2, JSEXN_TYPEERR, "{0}: descriptor .{1} property is an object in a different compartment than the target object")

372

MSG_DEF(JSMSG_DEBUG_NOT_SCRIPT_FRAME, 286, 0, JSEXN_ERR, "stack frame is not running JavaScript code")

372

MSG_DEF(JSMSG_DEBUG_NOT_SCRIPT_FRAME, 286, 0, JSEXN_ERR, "stack frame is not running JavaScript code")

373

MSG_DEF(JSMSG_CANT_WATCH_PROP,        287, 0, JSEXN_TYPEERR, "properties whose names are objects can't be watched")

373

MSG_DEF(JSMSG_CANT_WATCH_PROP,        287, 0, JSEXN_TYPEERR, "properties whose names are objects can't be watched")

374

MSG_DEF(JSMSG_CSP_BLOCKED_EVAL,       288, 0, JSEXN_ERR, "call to eval() blocked by CSP")

374

MSG_DEF(JSMSG_CSP_BLOCKED_EVAL,       288, 0, JSEXN_ERR, "call to eval() blocked by CSP")

375

MSG_DEF(JSMSG_DEBUG_NO_SCOPE_OBJECT,  289, 0, JSEXN_TYPEERR, "declarative Environments don't have binding objects")

375

MSG_DEF(JSMSG_DEBUG_NO_SCOPE_OBJECT,  289, 0, JSEXN_TYPEERR, "declarative Environments don't have binding objects")

376

MSG_DEF(JSMSG_EMPTY_CONSEQUENT,       290, 0, JSEXN_SYNTAXERR, "mistyped ; after conditional?")

376

MSG_DEF(JSMSG_EMPTY_CONSEQUENT,       290, 0, JSEXN_SYNTAXERR, "mistyped ; after conditional?")

377

MSG_DEF(JSMSG_NEW_LINE_BEFORE_IS,     291, 0, JSEXN_SYNTAXERR, "new line before 'is' or 'isnt'")





    "keys",                     /* keysAtom                     */
    "iterate",                  /* iterateAtom                  */

    "WeakMap",                  /* WeakMapAtom                  */

    "byteLength",               /* byteLengthAtom               */

    "return",                   /* returnAtom                   */
    "throw",                    /* throwAtom                    */

    "is",                       /* isAtom                       */
    "isnt"                      /* isntAtom                     */
};

void
JSAtomState::checkStaticInvariants()
{
    /*
     * Start and limit offsets for atom pointers in JSAtomState must be aligned
     * on the word boundary.






    js::PropertyName    *WeakMapAtom;

    js::PropertyName    *byteLengthAtom;

    js::PropertyName    *returnAtom;
    js::PropertyName    *throwAtom;

    js::PropertyName    *isAtom;
    js::PropertyName    *isntAtom;

    /* Less frequently used atoms, pinned lazily by JS_ResolveStandardClass. */
    struct {
        js::PropertyName *XMLListAtom;
        js::PropertyName *decodeURIAtom;
        js::PropertyName *decodeURIComponentAtom;
        js::PropertyName *defineGetterAtom;
        js::PropertyName *defineSetterAtom;
        js::PropertyName *encodeURIAtom;





BEGIN_CASE(JSOP_EQ)
    EQUALITY_OP(==);
END_CASE(JSOP_EQ)

BEGIN_CASE(JSOP_NE)
    EQUALITY_OP(!=);
END_CASE(JSOP_NE)



#undef EQUALITY_OP

#define STRICT_EQUALITY_OP(OP, COND)                                          \
    JS_BEGIN_MACRO                                                            \
        const Value &rref = regs.sp[-1];                                      \
        const Value &lref = regs.sp[-2];                                      \
        JSBool equal;                                                         \
        if (!StrictlyEqual(cx, lref, rref, &equal))                           \

BEGIN_CASE(JSOP_STRICTNE)
{
    bool cond;
    STRICT_EQUALITY_OP(!=, cond);
    regs.sp[-1].setBoolean(cond);
}
END_CASE(JSOP_STRICTNE)

#define SAME_VALUE_OP(OP, COND)                                               \
    JS_BEGIN_MACRO                                                            \
        const Value &rref = regs.sp[-1];                                      \
        const Value &lref = regs.sp[-2];                                      \
        JSBool equal;                                                         \
        if (!SameValue(cx, lref, rref, &equal))                               \
            goto error;                                                       \
        COND = equal OP JS_TRUE;                                              \
        regs.sp--;                                                            \
    JS_END_MACRO

BEGIN_CASE(JSOP_IS)
{
    bool cond;
    SAME_VALUE_OP(==, cond);
    regs.sp[-1].setBoolean(cond);
}
END_CASE(JSOP_IS)

BEGIN_CASE(JSOP_ISNT)
{
    bool cond;
    SAME_VALUE_OP(!=, cond);
    regs.sp[-1].setBoolean(cond);
}
END_CASE(JSOP_ISNT)

BEGIN_CASE(JSOP_CASE)
{
    bool cond;
    STRICT_EQUALITY_OP(==, cond);
    if (cond) {
        regs.sp--;
        len = GET_JUMP_OFFSET(regs.pc);
        BRANCH(len);

(-)a/js/src/jsopcode.tbl (+3 lines)

Line	Link Here

Lines 565-572 OPDEF(JSOP_LAMBDA_FC, 221,"lambda_fc	Link Here

565

*/

565

*/

566

OPDEF(JSOP_SETMETHOD,     222,"setmethod",     NULL,  3,  2,  1,  3,  JOF_ATOM|JOF_PROP|JOF_SET|JOF_DETECTING)

566

OPDEF(JSOP_SETMETHOD,     222,"setmethod",     NULL,  3,  2,  1,  3,  JOF_ATOM|JOF_PROP|JOF_SET|JOF_DETECTING)

567

OPDEF(JSOP_INITMETHOD,    223,"initmethod",    NULL,  3,  2,  1,  3,  JOF_ATOM|JOF_PROP|JOF_SET|JOF_DETECTING)

567

OPDEF(JSOP_INITMETHOD,    223,"initmethod",    NULL,  3,  2,  1,  3,  JOF_ATOM|JOF_PROP|JOF_SET|JOF_DETECTING)

568

569

OPDEF(JSOP_SHARPINIT,     224,"sharpinit",     NULL,  3,  0,  0,  0,  JOF_UINT16|JOF_SHARPSLOT)

569

OPDEF(JSOP_SHARPINIT,     224,"sharpinit",     NULL,  3,  0,  0,  0,  JOF_UINT16|JOF_SHARPSLOT)

570

571

/* Pop the stack, convert to a jsid (int or string), and push back. */

571

/* Pop the stack, convert to a jsid (int or string), and push back. */

572

OPDEF(JSOP_TOID,          225, "toid",         NULL,  1,  1,  1,  0,  JOF_BYTE)

572

OPDEF(JSOP_TOID,          225, "toid",         NULL,  1,  1,  1,  0,  JOF_BYTE)

573

574

OPDEF(JSOP_IS,            226, "is",           "is",  1,  2,  1,  10,  JOF_BYTE|JOF_LEFTASSOC|JOF_ARITH|JOF_DETECTING)

575

OPDEF(JSOP_ISNT,          227, "isnt",        "isnt", 1,  2,  1,  10,  JOF_BYTE|JOF_LEFTASSOC|JOF_ARITH|JOF_DETECTING)





    "&="    /* AOP_BITAND */
};

char const *binopNames[] = {
    "==",         /* BINOP_EQ */
    "!=",         /* BINOP_NE */
    "===",        /* BINOP_STRICTEQ */
    "!==",        /* BINOP_STRICTNE */
    "is",         /* BINOP_IS */  
    "isnt",       /* BINOP_ISNT */  
    "<",          /* BINOP_LT */
    "<=",         /* BINOP_LE */
    ">",          /* BINOP_GT */
    ">=",         /* BINOP_GE */
    "<<",         /* BINOP_LSH */
    ">>",         /* BINOP_RSH */
    ">>>",        /* BINOP_URSH */
    "+",          /* BINOP_PLUS */

      case PNK_GT:
        return BINOP_GT;
      case PNK_GE:
        return BINOP_GE;
      case PNK_EQ:
        return BINOP_EQ;
      case PNK_NE:
        return BINOP_NE;
      case PNK_IS:
        return BINOP_IS;
      case PNK_ISNT:
        return BINOP_ISNT;
      case PNK_STRICTEQ:
        return BINOP_STRICTEQ;
      case PNK_STRICTNE:
        return BINOP_STRICTNE;
      case PNK_ADD:
        return BINOP_ADD;
      case PNK_SUB:
        return BINOP_SUB;

      }

      case PNK_ADD:
      case PNK_SUB:
      case PNK_STRICTEQ:
      case PNK_EQ:
      case PNK_STRICTNE:
      case PNK_NE:
      case PNK_IS:
      case PNK_ISNT:
      case PNK_LT:
      case PNK_LE:
      case PNK_GT:
      case PNK_GE:
      case PNK_LSH:
      case PNK_RSH:
      case PNK_URSH:
      case PNK_STAR:





    AOP_LIMIT
};

enum BinaryOperator {
    BINOP_ERR = -1,

    /* eq */
    BINOP_EQ = 0, BINOP_NE, BINOP_STRICTEQ, BINOP_STRICTNE,
    /* harmony eq */
    BINOP_IS, BINOP_ISNT,
    /* rel */
    BINOP_LT, BINOP_LE, BINOP_GT, BINOP_GE,
    /* shift */
    BINOP_LSH, BINOP_RSH, BINOP_URSH,
    /* arithmetic */
    BINOP_ADD, BINOP_SUB, BINOP_STAR, BINOP_DIV, BINOP_MOD,
    /* binary */
    BINOP_BITOR, BINOP_BITXOR, BINOP_BITAND,

Return to bug 715359