END_CASE(JSOP_GROUP)  BEGIN_CASE(JSOP_PUSH)
break;  case JSOP_PUSH:
js_Interpret(JSContext *cx, jsbytecode *pc, jsval *result){    JSRuntime *rt;    JSStackFrame *fp;    JSScript *script;    uintN inlineCallCount;    JSObject *obj, *obj2, *proto, *parent;    JSVersion currentVersion, originalVersion;    JSBranchCallback onbranch;    JSBool ok, cond;    JSTrapHandler interruptHandler;    jsint depth, len;    jsval *sp, *newsp;    void *mark;    jsbytecode *endpc, *pc2;    JSOp op, op2;    jsatomid atomIndex;    JSAtom *atom;    uintN argc, slot, attrs;    jsval *vp, lval, rval, ltmp, rtmp;    jsid id;    JSObject *withobj, *origobj, *propobj;    jsval iter_state;    JSProperty *prop;    JSScopeProperty *sprop;    JSString *str, *str2;    jsint i, j;    jsdouble d, d2;    JSClass *clasp, *funclasp;    JSFunction *fun;    JSType type;#if !defined JS_THREADED_INTERP && defined DEBUG    FILE *tracefp;#endif#if JS_HAS_EXPORT_IMPORT    JSIdArray *ida;#endif#if JS_HAS_SWITCH_STATEMENT    jsint low, high, off, npairs;    JSBool match;#endif#if JS_HAS_GETTER_SETTER    JSPropertyOp getter, setter;#endif#if JS_HAS_XML_SUPPORT    JSBool foreach = JS_FALSE;#endif    int stackDummy;#ifdef JS_THREADED_INTERP    static void *normalJumpTable[] = {# define OPDEF(op,val,name,token,length,nuses,ndefs,prec,format) \        &&L_##op,# include "jsopcode.tbl"# undef OPDEF    };    static void *interruptJumpTable[] = {# define OPDEF(op,val,name,token,length,nuses,ndefs,prec,format) \        &&interrupt,# include "jsopcode.tbl"# undef OPDEF    };    register void **jumpTable = normalJumpTable;# define DO_OP()            goto *jumpTable[op]# define DO_NEXT_OP(n)      do { op = *(pc += (n)); DO_OP(); } while (0)# define BEGIN_CASE(OP)     case OP: L_##OP:# define END_CASE(OP)       DO_NEXT_OP(OP##_LENGTH);# define END_VARLEN_CASE    DO_NEXT_OP(len);# define EMPTY_CASE(OP)     BEGIN_CASE(OP) op = *++pc; DO_OP();#else# define DO_OP()            goto do_op# define DO_NEXT_OP(n)      goto advance_pc# define BEGIN_CASE(OP)     case OP:# define END_CASE(OP)       break;# define END_VARLEN_CASE    break;# define EMPTY_CASE(OP)     BEGIN_CASE(OP) END_CASE(OP)#endif    *result = JSVAL_VOID;    rt = cx->runtime;    /* Set registerized frame pointer and derived script pointer. */    fp = cx->fp;    script = fp->script;    JS_ASSERT(script->length != 0);    /* Count of JS function calls that nest in this C js_Interpret frame. */    inlineCallCount = 0;    /*     * Optimized Get and SetVersion for proper script language versioning.     *     * If any native method or JSClass/JSObjectOps hook calls js_SetVersion     * and changes cx->version, the effect will "stick" and we will stop     * maintaining currentVersion.  This is relied upon by testsuites, for     * the most part -- web browsers select version before compiling and not     * at run-time.     */    currentVersion = script->version;    originalVersion = cx->version;    if (currentVersion != originalVersion)        js_SetVersion(cx, currentVersion);    /*     * Prepare to call a user-supplied branch handler, and abort the script     * if it returns false.  We reload onbranch after calling out to native     * functions (but not to getters, setters, or other native hooks).     */#define LOAD_BRANCH_CALLBACK(cx)    (onbranch = (cx)->branchCallback)    LOAD_BRANCH_CALLBACK(cx);    ok = JS_TRUE;#define CHECK_BRANCH(len)                                                     \    JS_BEGIN_MACRO                                                            \        if (len <= 0 && onbranch) {                                           \            SAVE_SP_AND_PC(fp);                                               \            if (!(ok = (*onbranch)(cx, script)))                              \                goto out;                                                     \        }                                                                     \    JS_END_MACRO    /*     * Load the debugger's interrupt hook here and after calling out to native     * functions (but not to getters, setters, or other native hooks), so we do     * not have to reload it each time through the interpreter loop -- we hope     * the compiler can keep it in a register when it is non-null.     */#ifdef JS_THREADED_INTERP# define LOAD_JUMP_TABLE()                                                    \    (jumpTable = interruptHandler ? interruptJumpTable : normalJumpTable)#else# define LOAD_JUMP_TABLE()      /* nothing */#endif#define LOAD_INTERRUPT_HANDLER(rt)                                            \    JS_BEGIN_MACRO                                                            \        interruptHandler = (rt)->interruptHandler;                            \        LOAD_JUMP_TABLE();                                                    \    JS_END_MACRO    LOAD_INTERRUPT_HANDLER(rt);    /* Check for too much js_Interpret nesting, or too deep a C stack. */    if (++cx->interpLevel == MAX_INTERP_LEVEL ||        !JS_CHECK_STACK_SIZE(cx, stackDummy)) {        JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_OVER_RECURSED);        ok = JS_FALSE;        goto out2;    }    /*     * Allocate operand and pc stack slots for the script's worst-case depth,     * unless we're called to interpret a part of an already active script, a     * filtering predicate expression for example.     */    depth = (jsint) script->depth;    if (JS_LIKELY(!fp->spbase)) {        newsp = js_AllocRawStack(cx, (uintN)(2 * depth), &mark);        if (!newsp) {            ok = JS_FALSE;            goto out2;        }        sp = newsp + depth;        fp->spbase = sp;        SAVE_SP(fp);    } else {        sp = fp->sp;        JS_ASSERT(JS_UPTRDIFF(sp, fp->spbase) <= depth * sizeof(jsval));        newsp = fp->spbase - depth;        mark = NULL;    }#ifdef JS_THREADED_INTERP    /*     * This is a loop, but it does not look like a loop.  The loop-closing     * jump is distributed throughout interruptJumpTable, and comes back to     * the interrupt label.  The dispatch on op is through normalJumpTable.     * The trick is LOAD_INTERRUPT_HANDLER setting jumpTable appropriately.     */    if (interruptHandler) {interrupt:        SAVE_SP_AND_PC(fp);        switch (interruptHandler(cx, script, pc, &rval,                                 rt->interruptHandlerData)) {          case JSTRAP_ERROR:            ok = JS_FALSE;            goto out;          case JSTRAP_CONTINUE:            break;          case JSTRAP_RETURN:            fp->rval = rval;            goto out;#if JS_HAS_EXCEPTIONS          case JSTRAP_THROW:            cx->throwing = JS_TRUE;            cx->exception = rval;            ok = JS_FALSE;            goto out;#endif /* JS_HAS_EXCEPTIONS */          default:;        }        LOAD_INTERRUPT_HANDLER(rt);    }    op = (JSOp) *pc;    goto *normalJumpTable[op];#else  /* !JS_THREADED_INTERP */    for (;;) {        op = (JSOp) *pc;      do_op:        len = js_CodeSpec[op].length;#ifdef DEBUG        tracefp = (FILE *) cx->tracefp;        if (tracefp) {            intN nuses, n;            fprintf(tracefp, "%4u: ", js_PCToLineNumber(cx, script, pc));            js_Disassemble1(cx, script, pc,                            PTRDIFF(pc, script->code, jsbytecode), JS_FALSE,                            tracefp);            nuses = js_CodeSpec[op].nuses;            if (nuses) {                SAVE_SP_AND_PC(fp);                for (n = -nuses; n < 0; n++) {                    str = js_DecompileValueGenerator(cx, n, sp[n], NULL);                    if (str) {                        fprintf(tracefp, "%s %s",                                (n == -nuses) ? "  inputs:" : ",",                                JS_GetStringBytes(str));                    }                }                fprintf(tracefp, " @ %d\n", sp - fp->spbase);            }        }#endif /* DEBUG */        if (interruptHandler) {            SAVE_SP_AND_PC(fp);            switch (interruptHandler(cx, script, pc, &rval,                                     rt->interruptHandlerData)) {              case JSTRAP_ERROR:                ok = JS_FALSE;                goto out;              case JSTRAP_CONTINUE:                break;              case JSTRAP_RETURN:                fp->rval = rval;                goto out;#if JS_HAS_EXCEPTIONS              case JSTRAP_THROW:                cx->throwing = JS_TRUE;                cx->exception = rval;                ok = JS_FALSE;                goto out;#endif /* JS_HAS_EXCEPTIONS */              default:;            }            LOAD_INTERRUPT_HANDLER(rt);        }#endif /* !JS_THREADED_INTERP */        switch (op) {          BEGIN_CASE(JSOP_STOP)            goto out;          EMPTY_CASE(JSOP_NOP)          BEGIN_CASE(JSOP_GROUP)            obj = NULL;          END_CASE(JSOP_GROUP)          BEGIN_CASE(JSOP_PUSH)            PUSH_OPND(JSVAL_VOID);          END_CASE(JSOP_PUSH)          BEGIN_CASE(JSOP_POP)            sp--;          END_CASE(JSOP_POP)          BEGIN_CASE(JSOP_POP2)            sp -= 2;          END_CASE(JSOP_POP2)          BEGIN_CASE(JSOP_SWAP)            /*             * N.B. JSOP_SWAP doesn't swap the corresponding generating pcs             * for the operands it swaps.             */            ltmp = sp[-1];            sp[-1] = sp[-2];            sp[-2] = ltmp;          END_CASE(JSOP_SWAP)          BEGIN_CASE(JSOP_POPV)            *result = POP_OPND();          END_CASE(JSOP_POPV)          BEGIN_CASE(JSOP_ENTERWITH)            FETCH_OBJECT(cx, -1, rval, obj);            SAVE_SP_AND_PC(fp);            withobj = js_NewObject(cx, &js_WithClass, obj, fp->scopeChain);            if (!withobj)                goto out;            rval = INT_TO_JSVAL(sp - fp->spbase);            OBJ_SET_SLOT(cx, withobj, JSSLOT_PRIVATE, rval);            fp->scopeChain = withobj;            STORE_OPND(-1, OBJECT_TO_JSVAL(withobj));          END_CASE(JSOP_ENTERWITH)          BEGIN_CASE(JSOP_LEAVEWITH)            rval = POP_OPND();            JS_ASSERT(JSVAL_IS_OBJECT(rval));            withobj = JSVAL_TO_OBJECT(rval);            JS_ASSERT(OBJ_GET_CLASS(cx, withobj) == &js_WithClass);            rval = OBJ_GET_SLOT(cx, withobj, JSSLOT_PARENT);            JS_ASSERT(JSVAL_IS_OBJECT(rval));            fp->scopeChain = JSVAL_TO_OBJECT(rval);          END_CASE(JSOP_LEAVEWITH)          BEGIN_CASE(JSOP_SETRVAL)            fp->rval = POP_OPND();          END_CASE(JSOP_SETRVAL)          BEGIN_CASE(JSOP_RETURN)            CHECK_BRANCH(-1);