JSParseNode *pn;
JSParseNode *pn, *pn1, *pn2;
static JSParser Statements;static JSParser Statement;static JSParser Variables;static JSParser Expr;static JSParser AssignExpr;static JSParser CondExpr;static JSParser OrExpr;static JSParser AndExpr;static JSParser BitOrExpr;static JSParser BitXorExpr;static JSParser BitAndExpr;static JSParser EqExpr;static JSParser RelExpr;static JSParser ShiftExpr;static JSParser AddExpr;static JSParser MulExpr;static JSParser UnaryExpr;static JSMemberParser MemberExpr;static JSParser PrimaryExpr;/* * Insist that the next token be of type tt, or report errno and return null. * NB: this macro uses cx and ts from its lexical environment. */#define MUST_MATCH_TOKEN(tt, errno)                                           \    JS_BEGIN_MACRO                                                            \        if (js_GetToken(cx, ts) != tt) {                                      \            js_ReportCompileErrorNumber(cx, ts, NULL, JSREPORT_ERROR, errno); \            return NULL;                                                      \        }                                                                     \    JS_END_MACRO#ifdef METER_PARSENODESstatic uint32 parsenodes = 0;static uint32 maxparsenodes = 0;static uint32 recyclednodes = 0;#endif/* * Allocate a JSParseNode from cx's temporary arena. */static JSParseNode *NewParseNode(JSContext *cx, JSToken *tok, JSParseNodeArity arity,             JSTreeContext *tc){    JSParseNode *pn;    pn = tc->nodeList;    if (pn) {        tc->nodeList = pn->pn_next;    } else {        JS_ARENA_ALLOCATE_TYPE(pn, JSParseNode, &cx->tempPool);        if (!pn) {            JS_ReportOutOfMemory(cx);            return NULL;        }    }    pn->pn_type = tok->type;    pn->pn_pos = tok->pos;    pn->pn_op = JSOP_NOP;    pn->pn_arity = arity;    pn->pn_next = NULL;#ifdef METER_PARSENODES    parsenodes++;    if (parsenodes - recyclednodes > maxparsenodes)        maxparsenodes = parsenodes - recyclednodes;#endif    return pn;}static JSParseNode *NewBinary(JSContext *cx, JSTokenType tt,          JSOp op, JSParseNode *left, JSParseNode *right,          JSTreeContext *tc){    JSParseNode *pn;    if (!left || !right)        return NULL;    pn = tc->nodeList;    if (pn) {        tc->nodeList = pn->pn_next;    } else {        JS_ARENA_ALLOCATE_TYPE(pn, JSParseNode, &cx->tempPool);        if (!pn) {            JS_ReportOutOfMemory(cx);            return NULL;        }    }    pn->pn_type = tt;    pn->pn_pos.begin = left->pn_pos.begin;    pn->pn_pos.end = right->pn_pos.end;    pn->pn_op = op;    pn->pn_arity = PN_BINARY;    pn->pn_left = left;    pn->pn_right = right;    pn->pn_next = NULL;#ifdef METER_PARSENODES    parsenodes++;    if (parsenodes - recyclednodes > maxparsenodes)        maxparsenodes = parsenodes - recyclednodes;#endif    return pn;}static voidRecycleTree(JSParseNode *pn, JSTreeContext *tc){    JSParseNode *pn2;    if (!pn)        return;    JS_ASSERT(pn != tc->nodeList);      /* catch back-to-back dup recycles */    switch (pn->pn_arity) {      case PN_FUNC:        RecycleTree(pn->pn_body, tc);        break;      case PN_LIST:        while ((pn2 = pn->pn_head) != NULL) {            pn->pn_head = pn2->pn_next;            RecycleTree(pn2, tc);        }        break;      case PN_TERNARY:        RecycleTree(pn->pn_kid1, tc);        RecycleTree(pn->pn_kid2, tc);        RecycleTree(pn->pn_kid3, tc);        break;      case PN_BINARY:        RecycleTree(pn->pn_left, tc);        RecycleTree(pn->pn_right, tc);        break;      case PN_UNARY:        RecycleTree(pn->pn_kid, tc);        break;      case PN_NAME:        RecycleTree(pn->pn_expr, tc);        break;      case PN_NULLARY:        break;    }    pn->pn_next = tc->nodeList;    tc->nodeList = pn;#ifdef METER_PARSENODES    recyclednodes++;#endif}static JSBoolWellTerminated(JSContext *cx, JSTokenStream *ts, JSTokenType lastExprType){    JSTokenType tt;    tt = js_PeekTokenSameLine(cx, ts);    if (tt == TOK_ERROR)        return JS_FALSE;    if (tt != TOK_EOF && tt != TOK_EOL && tt != TOK_SEMI && tt != TOK_RC) {#if JS_HAS_LEXICAL_CLOSURE        if ((tt == TOK_FUNCTION || lastExprType == TOK_FUNCTION) &&            cx->version < JSVERSION_1_2) {            /*             * Checking against version < 1.2 and version >= 1.0             * in the above line breaks old javascript, so we keep it             * this way for now... XXX warning needed?             */            return JS_TRUE;        }#endif        js_ReportCompileErrorNumber(cx, ts, NULL, JSREPORT_ERROR,                                    JSMSG_SEMI_BEFORE_STMNT);        return JS_FALSE;    }    return JS_TRUE;}#if JS_HAS_GETTER_SETTERstatic JSTokenTypeCheckGetterOrSetter(JSContext *cx, JSTokenStream *ts, JSTokenType tt){    JSAtom *atom;    JSRuntime *rt;    JSOp op;    JS_ASSERT(CURRENT_TOKEN(ts).type == TOK_NAME);    atom = CURRENT_TOKEN(ts).t_atom;    rt = cx->runtime;    if (atom == rt->atomState.getterAtom)        op = JSOP_GETTER;    else if (atom == rt->atomState.setterAtom)        op = JSOP_SETTER;    else        return TOK_NAME;    if (js_PeekTokenSameLine(cx, ts) != tt)        return TOK_NAME;    (void) js_GetToken(cx, ts);    if (CURRENT_TOKEN(ts).t_op != JSOP_NOP) {        js_ReportCompileErrorNumber(cx, ts, NULL, JSREPORT_ERROR,                                    JSMSG_BAD_GETTER_OR_SETTER,                                    (op == JSOP_GETTER)                                    ? js_getter_str                                    : js_setter_str);        return TOK_ERROR;    }    CURRENT_TOKEN(ts).t_op = op;    if (!js_ReportCompileErrorNumber(cx, ts, NULL,                                     JSREPORT_WARNING |                                     JSREPORT_STRICT,                                     JSMSG_DEPRECATED_USAGE,                                     ATOM_BYTES(atom))) {        return TOK_ERROR;    }    return tt;}#endif/* * Parse a top-level JS script. */JS_FRIEND_API(JSParseNode *)js_ParseTokenStream(JSContext *cx, JSObject *chain, JSTokenStream *ts){    JSStackFrame *fp, frame;    JSTreeContext tc;    JSParseNode *pn;    /*     * Push a compiler frame if we have no frames, or if the top frame is a     * lightweight function activation, or if its scope chain doesn't match     * the one passed to us.     */    fp = cx->fp;    if (!fp || !fp->varobj || fp->scopeChain != chain) {        memset(&frame, 0, sizeof frame);        frame.varobj = frame.scopeChain = chain;        if (cx->options & JSOPTION_VAROBJFIX) {            while ((chain = JS_GetParent(cx, chain)) != NULL)                frame.varobj = chain;        }        frame.down = fp;        cx->fp = &frame;    }    /*     * Prevent GC activation (possible if out of memory when atomizing,     * or from pre-ECMAv2 switch case expr eval in the unlikely case of a     * branch-callback -- unlikely because it means the switch case must     * have called a function).     */    JS_DISABLE_GC(cx->runtime);    TREE_CONTEXT_INIT(&tc);    pn = Statements(cx, ts, &tc);    if (pn) {        if (!js_MatchToken(cx, ts, TOK_EOF)) {            js_ReportCompileErrorNumber(cx, ts, NULL, JSREPORT_ERROR,                                        JSMSG_SYNTAX_ERROR);            pn = NULL;        } else {            pn->pn_type = TOK_LC;            if (!js_FoldConstants(cx, pn, &tc))                pn = NULL;        }    }    TREE_CONTEXT_FINISH(&tc);    JS_ENABLE_GC(cx->runtime);    cx->fp = fp;    return pn;}/* * Compile a top-level script. */JS_FRIEND_API(JSBool)js_CompileTokenStream(JSContext *cx, JSObject *chain, JSTokenStream *ts,                      JSCodeGenerator *cg){    JSStackFrame *fp, frame;    JSParseNode *pn;    JSBool ok;#ifdef METER_PARSENODES    void *sbrk(ptrdiff_t), *before = sbrk(0);#endif    /*     * Push a compiler frame if we have no frames, or if the top frame is a     * lightweight function activation, or if its scope chain doesn't match     * the one passed to us.     */    fp = cx->fp;    if (!fp || !fp->varobj || fp->scopeChain != chain) {        memset(&frame, 0, sizeof frame);        frame.varobj = frame.scopeChain = chain;        if (cx->options & JSOPTION_VAROBJFIX) {            while ((chain = JS_GetParent(cx, chain)) != NULL)                frame.varobj = chain;        }        frame.down = fp;        cx->fp = &frame;    }    /* Prevent GC activation while compiling. */    JS_DISABLE_GC(cx->runtime);    pn = Statements(cx, ts, &cg->treeContext);    if (!pn) {        ok = JS_FALSE;    } else if (!js_MatchToken(cx, ts, TOK_EOF)) {        js_ReportCompileErrorNumber(cx, ts, NULL, JSREPORT_ERROR,                                    JSMSG_SYNTAX_ERROR);        ok = JS_FALSE;    } else {#ifdef METER_PARSENODES        printf("Parser growth: %d (%u nodes, %u max, %u unrecycled)\n",               (char *)sbrk(0) - (char *)before,               parsenodes,               maxparsenodes,               parsenodes - recyclednodes);        before = sbrk(0);#endif        /*         * No need to emit code here -- Statements already has, for each         * statement in turn.  Search for TCF_COMPILING in Statements, below.         * That flag is set for every tc == &cg->treeContext, and it implies         * that the tc can be downcast to a cg and used to emit code during         * parsing, rather than at the end of the parse phase.         */        ok = JS_TRUE;    }#ifdef METER_PARSENODES    printf("Code-gen growth: %d (%u bytecodes, %u srcnotes)\n",           (char *)sbrk(0) - (char *)before, CG_OFFSET(cg), cg->noteCount);#endif#ifdef JS_ARENAMETER    JS_DumpArenaStats(stdout);#endif    JS_ENABLE_GC(cx->runtime);    cx->fp = fp;    return ok;}/* * Insist on a final return before control flows out of pn, but don't be too * smart about loops (do {...; return e2;} while(0) at the end of a function * that contains an early return e1 will get a strict-option-only warning). */static JSBoolHasFinalReturn(JSParseNode *pn){    JSBool ok, hasDefault;    JSParseNode *pn2, *pn3;    switch (pn->pn_type) {      case TOK_LC:        if (!pn->pn_head)            return JS_FALSE;        return HasFinalReturn(PN_LAST(pn));      case TOK_IF:        ok = HasFinalReturn(pn->pn_kid2);        ok &= pn->pn_kid3 && HasFinalReturn(pn->pn_kid3);        return ok;#if JS_HAS_SWITCH_STATEMENT      case TOK_SWITCH:        ok = JS_TRUE;        hasDefault = JS_FALSE;        for (pn2 = pn->pn_kid2->pn_head; ok && pn2; pn2 = pn2->pn_next) {            if (pn2->pn_type == TOK_DEFAULT)                hasDefault = JS_TRUE;            pn3 = pn2->pn_right;            JS_ASSERT(pn3->pn_type == TOK_LC);            if (pn3->pn_head)                ok &= HasFinalReturn(PN_LAST(pn3));        }        /* If a final switch has no default case, we judge it harshly. */        ok &= hasDefault;        return ok;#endif /* JS_HAS_SWITCH_STATEMENT */      case TOK_WITH:        return HasFinalReturn(pn->pn_right);      case TOK_RETURN:        return JS_TRUE;#if JS_HAS_EXCEPTIONS      case TOK_THROW:        return JS_TRUE;      case TOK_TRY:        /* If we have a finally block that returns, we are done. */        if (pn->pn_kid3 && HasFinalReturn(pn->pn_kid3))            return JS_TRUE;        /* Else check the try block and any and all catch statements. */        ok = HasFinalReturn(pn->pn_kid1);        if (pn->pn_kid2)            ok &= HasFinalReturn(pn->pn_kid2);        return ok;      case TOK_CATCH:        /* Check this block's code and iterate over further catch blocks. */        ok = HasFinalReturn(pn->pn_kid3);        for (pn2 = pn->pn_kid2; pn2; pn2 = pn2->pn_kid2)            ok &= HasFinalReturn(pn2->pn_kid3);        return ok;#endif      default:        return JS_FALSE;    }}static JSBoolReportNoReturnValue(JSContext *cx, JSTokenStream *ts){    JSFunction *fun;    JSBool ok;    fun = cx->fp->fun;    if (fun->atom) {        char *name = js_GetStringBytes(ATOM_TO_STRING(fun->atom));        ok = js_ReportCompileErrorNumber(cx, ts, NULL,                                         JSREPORT_WARNING |                                         JSREPORT_STRICT,                                         JSMSG_NO_RETURN_VALUE, name);    } else {        ok = js_ReportCompileErrorNumber(cx, ts, NULL,                                         JSREPORT_WARNING |                                         JSREPORT_STRICT,                                         JSMSG_ANON_NO_RETURN_VALUE);    }    return ok;}static JSBoolCheckFinalReturn(JSContext *cx, JSTokenStream *ts, JSParseNode *pn){    return HasFinalReturn(pn) || ReportNoReturnValue(cx, ts);}static JSParseNode *FunctionBody(JSContext *cx, JSTokenStream *ts, JSFunction *fun,             JSTreeContext *tc){    JSStackFrame *fp, frame;    JSObject *funobj;    uintN oldflags;    JSParseNode *pn;    fp = cx->fp;    funobj = fun->object;    if (!fp || fp->fun != fun || fp->varobj != funobj ||        fp->scopeChain != funobj) {        memset(&frame, 0, sizeof frame);        frame.fun = fun;        frame.varobj = frame.scopeChain = funobj;        frame.down = fp;        cx->fp = &frame;    }    oldflags = tc->flags;    tc->flags &= ~(TCF_RETURN_EXPR | TCF_RETURN_VOID);    tc->flags |= TCF_IN_FUNCTION;    pn = Statements(cx, ts, tc);    /* Check for falling off the end of a function that returns a value. */    if (pn && JS_HAS_STRICT_OPTION(cx) && (tc->flags & TCF_RETURN_EXPR)) {        if (!CheckFinalReturn(cx, ts, pn))            pn = NULL;    }    cx->fp = fp;    tc->flags = oldflags | (tc->flags & TCF_FUN_FLAGS);    return pn;}/* * Compile a JS function body, which might appear as the value of an event * handler attribute in an HTML <INPUT> tag. */JSBooljs_CompileFunctionBody(JSContext *cx, JSTokenStream *ts, JSFunction *fun){    JSCodeGenerator funcg;    JSStackFrame *fp, frame;    JSObject *funobj;    JSParseNode *pn;    JSBool ok;    if (!js_InitCodeGenerator(cx, &funcg, ts->filename, ts->lineno,                              ts->principals)) {        return JS_FALSE;    }    /* Prevent GC activation while compiling. */    JS_DISABLE_GC(cx->runtime);    /* Push a JSStackFrame for use by FunctionBody and js_EmitFunctionBody. */    fp = cx->fp;    funobj = fun->object;    JS_ASSERT(!fp || fp->fun != fun || fp->varobj != funobj ||              fp->scopeChain != funobj);    memset(&frame, 0, sizeof frame);    frame.fun = fun;    frame.varobj = frame.scopeChain = funobj;    frame.down = fp;    cx->fp = &frame;    /* Ensure that the body looks like a block statement to js_EmitTree. */    CURRENT_TOKEN(ts).type = TOK_LC;    pn = FunctionBody(cx, ts, fun, &funcg.treeContext);    if (!pn) {        ok = JS_FALSE;    } else {        /*         * No need to emit code here -- Statements (via FunctionBody) already         * has.  See similar comment in js_CompileTokenStream, and bug 108257.         */        fun->script = js_NewScriptFromCG(cx, &funcg, fun);        if (!fun->script) {            ok = JS_FALSE;        } else {            if (funcg.treeContext.flags & TCF_FUN_HEAVYWEIGHT)                fun->flags |= JSFUN_HEAVYWEIGHT;            ok = JS_TRUE;        }    }    /* Restore saved state and release code generation arenas. */    cx->fp = fp;    JS_ENABLE_GC(cx->runtime);    js_FinishCodeGenerator(cx, &funcg);    return ok;}static JSParseNode *FunctionDef(JSContext *cx, JSTokenStream *ts, JSTreeContext *tc,            JSBool lambda){    JSParseNode *pn, *body;    JSOp op, prevop;    JSAtom *funAtom, *argAtom;    JSFunction *fun;    JSObject *parent;    JSObject *pobj;    JSScopeProperty *sprop;    uintN dupflag;    JSBool ok;    JSTreeContext funtc;    JSAtomListElement *ale;    /* Make a TOK_FUNCTION node. */    pn = NewParseNode(cx, &CURRENT_TOKEN(ts), PN_FUNC, tc);    if (!pn)        return NULL;    op = CURRENT_TOKEN(ts).t_op;    /* Scan the optional function name into funAtom. */    if (js_MatchToken(cx, ts, TOK_NAME))        funAtom = CURRENT_TOKEN(ts).t_atom;    else        funAtom = NULL;    /* Find the nearest variable-declaring scope and use it as our parent. */    parent = cx->fp->varobj;    fun = js_NewFunction(cx, NULL, NULL, 0, lambda ? JSFUN_LAMBDA : 0, parent,                         funAtom);    if (!fun)        return NULL;#if JS_HAS_GETTER_SETTER    if (op != JSOP_NOP)        fun->flags |= (op == JSOP_GETTER) ? JSPROP_GETTER : JSPROP_SETTER;#endif    /* Now parse formal argument list and compute fun->nargs. */    MUST_MATCH_TOKEN(TOK_LP, JSMSG_PAREN_BEFORE_FORMAL);    if (!js_MatchToken(cx, ts, TOK_RP)) {        do {            MUST_MATCH_TOKEN(TOK_NAME, JSMSG_MISSING_FORMAL);            argAtom = CURRENT_TOKEN(ts).t_atom;            pobj = NULL;            if (!js_LookupProperty(cx, fun->object, (jsid)argAtom, &pobj,                                   (JSProperty **)&sprop)) {                return NULL;            }            dupflag = 0;            if (sprop) {                ok = JS_TRUE;                if (pobj == fun->object &&                    sprop->getter == js_GetArgument) {                    /*                     * A duplicate parameter name. We force a duplicate node                     * on the SCOPE_LAST_PROP(scope) list with the same id,                     * distinguished by the SPROP_IS_DUPLICATE flag, and not                     * mapped by an entry in scope.                     */                    ok = js_ReportCompileErrorNumber(cx, ts, NULL,                                                     JSREPORT_WARNING |                                                     JSREPORT_STRICT,                                                     JSMSG_DUPLICATE_FORMAL,                                                     ATOM_BYTES(argAtom));                    dupflag = SPROP_IS_DUPLICATE;                }                OBJ_DROP_PROPERTY(cx, pobj, (JSProperty *)sprop);                if (!ok)                    return NULL;                sprop = NULL;            }            if (!js_AddNativeProperty(cx, fun->object, (jsid)argAtom,                                      js_GetArgument, js_SetArgument,                                      SPROP_INVALID_SLOT,                                      JSPROP_ENUMERATE | JSPROP_PERMANENT |                                      JSPROP_SHARED,                                      SPROP_HAS_SHORTID | dupflag,                                      fun->nargs)) {                return NULL;            }            fun->nargs++;        } while (js_MatchToken(cx, ts, TOK_COMMA));        MUST_MATCH_TOKEN(TOK_RP, JSMSG_PAREN_AFTER_FORMAL);    }    MUST_MATCH_TOKEN(TOK_LC, JSMSG_CURLY_BEFORE_BODY);    pn->pn_pos.begin = CURRENT_TOKEN(ts).pos.begin;    TREE_CONTEXT_INIT(&funtc);    body = FunctionBody(cx, ts, fun, &funtc);    if (!body)        return NULL;    MUST_MATCH_TOKEN(TOK_RC, JSMSG_CURLY_AFTER_BODY);    pn->pn_pos.end = CURRENT_TOKEN(ts).pos.end;#if JS_HAS_LEXICAL_CLOSURE    /*     * If we collected flags that indicate nested heavyweight functions, or     * this function contains heavyweight-making statements (references to     * __parent__ or __proto__; use of with, eval, import, or export; and     * assignment to arguments), flag the function as heavyweight (requiring     * a call object per invocation).     */    if (funtc.flags & TCF_FUN_HEAVYWEIGHT) {        fun->flags |= JSFUN_HEAVYWEIGHT;        tc->flags |= TCF_FUN_HEAVYWEIGHT;    } else {        /*         * If this function is a named statement function not at top-level         * (i.e. a JSOP_CLOSURE), or if it refers to unqualified names that         * are not local args or vars (TCF_FUN_USES_NONLOCALS), then our         * enclosing function, if any, must be heavyweight.         */        if ((!lambda && funAtom && tc->topStmt) ||            (funtc.flags & TCF_FUN_USES_NONLOCALS)) {            tc->flags |= TCF_FUN_HEAVYWEIGHT;        }    }#endif    /*     * Record names for function statements in tc->decls so we know when to     * avoid optimizing variable references that might name a function.     */    if (!lambda && funAtom) {        ATOM_LIST_SEARCH(ale, &tc->decls, funAtom);        if (ale) {            prevop = ALE_JSOP(ale);            if ((JS_HAS_STRICT_OPTION(cx) || prevop == JSOP_DEFCONST) &&                !js_ReportCompileErrorNumber(cx, ts, NULL,                                             (prevop != JSOP_DEFCONST)                                             ? JSREPORT_WARNING|JSREPORT_STRICT                                             : JSREPORT_ERROR,                                             JSMSG_REDECLARED_VAR,                                             (prevop == JSOP_DEFFUN ||                                              prevop == JSOP_CLOSURE)                                             ? js_function_str                                             : (prevop == JSOP_DEFCONST)                                             ? js_const_str                                             : js_var_str,                                             ATOM_BYTES(funAtom))) {                return NULL;            }            if (tc->topStmt && prevop == JSOP_DEFVAR)                tc->flags |= TCF_FUN_CLOSURE_VS_VAR;        } else {            ale = js_IndexAtom(cx, funAtom, &tc->decls);            if (!ale)                return NULL;        }        ALE_SET_JSOP(ale, tc->topStmt ? JSOP_CLOSURE : JSOP_DEFFUN);#if JS_HAS_LEXICAL_CLOSURE        /*         * A function nested at top level inside another's body needs only a         * local variable to bind its name to its value, and not an activation         * object property (it might also need the activation property, if the         * outer function contains with statements, e.g., but the stack slot         * wins when jsemit.c's LookupArgOrVar can optimize a JSOP_NAME into a         * JSOP_GETVAR bytecode).         */        if (!tc->topStmt && (tc->flags & TCF_IN_FUNCTION)) {            JSStackFrame *fp;            JSObject *varobj;            /*             * Define a property on the outer function so that LookupArgOrVar             * can properly optimize accesses.             *             * XXX Here and in Variables, we use the function object's scope,             * XXX arguably polluting it, when we could use a compiler-private             * XXX scope structure.  Tradition!             */            fp = cx->fp;            varobj = fp->varobj;            JS_ASSERT(OBJ_GET_CLASS(cx, varobj) == &js_FunctionClass);            JS_ASSERT(fp->fun == (JSFunction *) JS_GetPrivate(cx, varobj));            if (!js_DefineNativeProperty(cx, varobj, (jsid)funAtom,                                         OBJECT_TO_JSVAL(fun->object),                                         js_GetLocalVariable,                                         js_SetLocalVariable,                                         JSPROP_ENUMERATE,                                         SPROP_HAS_SHORTID, fp->fun->nvars,                                         NULL)) {                return NULL;            }            fp->fun->nvars++;        }#endif    }#if JS_HAS_LEXICAL_CLOSURE    if (lambda || !funAtom) {        /*         * ECMA ed. 3 standard: function expression, possibly anonymous (even         * if at top-level, an unnamed function is an expression statement, not         * a function declaration).         */        op = fun->atom ? JSOP_NAMEDFUNOBJ : JSOP_ANONFUNOBJ;    } else if (tc->topStmt) {        /*         * ECMA ed. 3 extension: a function expression statement not at the         * top level, e.g., in a compound statement such as the "then" part         * of an "if" statement, binds a closure only if control reaches that         * sub-statement.         */        op = JSOP_CLOSURE;    } else#endif        op = JSOP_NOP;    pn->pn_op = op;    pn->pn_fun = fun;    pn->pn_body = body;    pn->pn_flags = funtc.flags & TCF_FUN_FLAGS;    pn->pn_tryCount = funtc.tryCount;    TREE_CONTEXT_FINISH(&funtc);    return pn;}static JSParseNode *FunctionStmt(JSContext *cx, JSTokenStream *ts, JSTreeContext *tc){    return FunctionDef(cx, ts, tc, JS_FALSE);}#if JS_HAS_LEXICAL_CLOSUREstatic JSParseNode *FunctionExpr(JSContext *cx, JSTokenStream *ts, JSTreeContext *tc){    return FunctionDef(cx, ts, tc, JS_TRUE);}#endif/* * Parse the statements in a block, creating a TOK_LC node that lists the * statements' trees.  If called from block-parsing code, the caller must * match { before and } after. */static JSParseNode *Statements(JSContext *cx, JSTokenStream *ts, JSTreeContext *tc){    JSParseNode *pn, *pn2;    JSTokenType tt;    pn = NewParseNode(cx, &CURRENT_TOKEN(ts), PN_LIST, tc);    if (!pn)        return NULL;    PN_INIT_LIST(pn);    ts->flags |= TSF_REGEXP;    while ((tt = js_PeekToken(cx, ts)) > TOK_EOF && tt != TOK_RC) {        ts->flags &= ~TSF_REGEXP;        pn2 = Statement(cx, ts, tc);        if (!pn2)            return NULL;        ts->flags |= TSF_REGEXP;        /* If compiling top-level statements, emit as we go to save space. */        if (!tc->topStmt && (tc->flags & TCF_COMPILING)) {            if (cx->fp->fun &&                JS_HAS_STRICT_OPTION(cx) &&                (tc->flags & TCF_RETURN_EXPR)) {                /*                 * Check pn2 for lack of a final return statement if it is the                 * last statement in the block.                 */                tt = js_PeekToken(cx, ts);                if ((tt == TOK_EOF || tt == TOK_RC) &&                    !CheckFinalReturn(cx, ts, pn2)) {                    tt = TOK_ERROR;                    break;                }                /*                 * Clear TCF_RETURN_EXPR so FunctionBody doesn't try to                 * CheckFinalReturn again.                 */                tc->flags &= ~TCF_RETURN_EXPR;            }            if (!js_FoldConstants(cx, pn2, tc) ||                !js_AllocTryNotes(cx, (JSCodeGenerator *)tc) ||                !js_EmitTree(cx, (JSCodeGenerator *)tc, pn2)) {                tt = TOK_ERROR;                break;            }            RecycleTree(pn2, tc);        } else {            PN_APPEND(pn, pn2);        }    }    ts->flags &= ~TSF_REGEXP;    if (tt == TOK_ERROR)        return NULL;    pn->pn_pos.end = CURRENT_TOKEN(ts).pos.end;    return pn;}