Attachment #702262 for bug #568953

Attachment #702262: Parser support for bug #568953

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





}

/* XXX too many "... statement" L10N gaffes below -- fix via js.msg! */
const char js_with_statement_str[] = "with statement";
const char js_finally_block_str[]  = "finally block";
const char js_script_str[]         = "script";

static const char *statementName[] = {
    "export statement",      /* EXPORT */
    "label statement",       /* LABEL */
    "if statement",          /* IF */
    "else statement",        /* ELSE */
    "destructuring body",    /* BODY */
    "switch statement",      /* SWITCH */
    "block",                 /* BLOCK */
    js_with_statement_str,   /* WITH */
    "catch block",           /* CATCH */





 * vim: set ts=8 sw=4 et tw=99:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef ParseNode_inl_h__
#define ParseNode_inl_h__

#include "builtin/Module.h"
#include "frontend/ParseNode.h"

namespace js {
namespace frontend {

inline bool
UpvarCookie::set(JSContext *cx, unsigned newLevel, uint16_t newSlot)
{

    level_ = newLevel;
    slot_ = newSlot;
    return true;
}

inline PropertyName *
ParseNode::name() const
{
    JS_ASSERT(isKind(PNK_MODULE) || isKind(PNK_FUNCTION) || isKind(PNK_NAME));
    JSAtom *atom = isKind(PNK_MODULE) ? pn_modulebox->module()->atom() 
                                      : isKind(PNK_FUNCTION) ? pn_funbox->function()->atom()
                                                             : pn_atom;
    return atom->asPropertyName();
}

inline bool
ParseNode::isConstant()
{
    switch (pn_type) {
      case PNK_NUMBER:





    F(FILTER) \
    F(XMLELEM) \
    F(XMLLIST) \
    F(YIELD) \
    F(ARRAYCOMP) \
    F(ARRAYPUSH) \
    F(LEXICALSCOPE) \
    F(LET) \
    F(EXPORT) \
    F(SEQ) \
    F(FORIN) \
    F(FORHEAD) \
    F(ARGSBODY) \
    F(SPREAD) \
    F(MODULE) \
    \
    /* Equality operators. */ \
    F(STRICTEQ) \
    F(EQ) \
    F(STRICTNE) \
    F(NE) \
    \
    /* Unary operators. */ \

struct Definition;

class LoopControlStatement;
class BreakStatement;
class ContinueStatement;
class XMLProcessingInstruction;
class ConditionalExpression;
class PropertyAccess;
class ModuleBox;

struct ParseNode {
  private:
    uint32_t            pn_type   : 16, /* PNK_* type */
                        pn_op     : 8,  /* see JSOp enum and jsopcode.tbl */
                        pn_arity  : 5,  /* see ParseNodeArity enum */
                        pn_parens : 1,  /* this expr was enclosed in parens */
                        pn_used   : 1,  /* name node is on a use-chain */

        struct {                        /* one kid if unary */
            ParseNode   *kid;
            bool        hidden;         /* hidden genexp-induced JSOP_YIELD
                                           or directive prologue member (as
                                           pn_prologue) */
        } unary;
        struct {                        /* name, labeled statement, etc. */
            union {
                JSAtom      *atom;      /* lexical name or label atom */
                ObjectBox   *objbox;    /* block or regexp object */
                ModuleBox   *modulebox; /* modulebox */
                FunctionBox *funbox;    /* functionbox */
            };
            union {
                ParseNode  *expr;       /* function body, var initializer, argument default,
                                           or base object of PNK_DOT */
                Definition *lexdef;     /* lexical definition for this use */
            };
            UpvarCookie cookie;         /* upvar cookie with absolute frame
                                           level (not relative skip), possibly
                                           in current frame */
            uint32_t    dflags:12,      /* definition/use flags, see below */
                        blockid:20;     /* block number, for subset dominance
                                           computation */
        } name;

        } loopControl;
        class {                         /* E4X <?target data?> XML PI */
            friend class XMLProcessingInstruction;
            PropertyName     *target;   /* non-empty */
            JSAtom           *data;     /* may be empty, never null */
        } xmlpi;
    } pn_u;

#define pn_modulebox    pn_u.name.modulebox
#define pn_funbox       pn_u.name.funbox
#define pn_body         pn_u.name.expr
#define pn_cookie       pn_u.name.cookie
#define pn_dflags       pn_u.name.dflags
#define pn_blockid      pn_u.name.blockid
#define pn_index        pn_u.name.blockid /* reuse as object table index */
#define pn_head         pn_u.list.head
#define pn_tail         pn_u.list.tail

                                           'arguments' that has been converted
                                           into a definition after the function
                                           body has been parsed. */

/* Flags to propagate from uses to definition. */
#define PND_USE2DEF_FLAGS (PND_ASSIGNED | PND_CLOSED)

/* PN_LIST pn_xflags bits. */
#define PNX_STRCAT       0x01           /* PNK_ADD list has string term */
#define PNX_CANTFOLD     0x02           /* PNK_ADD list has unfoldable term */
#define PNX_POPVAR       0x04           /* PNK_VAR or PNK_CONST last result
                                           needs popping */
#define PNX_FORINVAR     0x08           /* PNK_VAR is left kid of PNK_FORIN node
                                           which is left kid of PNK_FOR */
#define PNX_ENDCOMMA     0x10           /* array literal has comma at end */
#define PNX_XMLROOT      0x20           /* top-most node in XML literal tree */
#define PNX_GROUPINIT    0x40           /* var [a, b] = [c, d]; unit list */
#define PNX_NEEDBRACES   0x80           /* braces necessary due to closure */
#define PNX_FUNCDEFS    0x100           /* contains top-level function statements */
#define PNX_MODULEDEFS  0x100           /* contains module statements */
#define PNX_SETCALL     0x100           /* call expression in lvalue context */
#define PNX_DESTRUCT    0x200           /* destructuring special cases:
                                           1. shorthand syntax used, at present
                                              object destructuring ({x,y}) only;
                                           2. code evaluating destructuring
                                              arguments occurs before function
                                              body */
#define PNX_HOLEY       0x400           /* array initialiser has holes */
#define PNX_NONCONST    0x800           /* initialiser has non-constants */

    unsigned frameLevel() const {
        JS_ASSERT(pn_arity == PN_FUNC || pn_arity == PN_NAME);
        return pn_cookie.level();
    }

    unsigned frameSlot() const {
        JS_ASSERT(pn_arity == PN_FUNC || pn_arity == PN_NAME);


    enum Kind { VAR, CONST, LET, ARG, NAMED_LAMBDA, PLACEHOLDER };

    bool canHaveInitializer() { return int(kind()) <= int(ARG); }

    static const char *kindString(Kind kind);

    Kind kind() {
        if (getKind() == PNK_MODULE) {
            return VAR;
        } else if (getKind() == PNK_FUNCTION) {
            if (isOp(JSOP_GETARG))
                return ARG;
            return VAR;
        }
        JS_ASSERT(getKind() == PNK_NAME);
        if (isOp(JSOP_CALLEE))
            return NAMED_LAMBDA;
        if (isPlaceholder())

    JS_ASSERT(pn != dn->dn_uses);
    pn->pn_link = dn->dn_uses;
    dn->dn_uses = pn;
    dn->pn_dflags |= pn->pn_dflags & PND_USE2DEF_FLAGS;
    pn->setUsed(true);
    pn->pn_lexdef = dn;
}

class ModuleBox;

class ObjectBox {
  public:
    JSObject *object;

    ObjectBox(JSObject *object, ObjectBox *traceLink);
    bool isModuleBox() { return object->isModule(); }
    bool isFunctionBox() { return object->isFunction(); }
    ModuleBox *asModuleBox();





#include "jslock.h"
#include "jsnum.h"
#include "jsobj.h"
#include "jsopcode.h"
#include "jsscope.h"
#include "jsscript.h"
#include "jsstr.h"

#include "builtin/Module.h"
#include "frontend/FoldConstants.h"
#include "frontend/ParseMaps.h"
#include "frontend/Parser.h"
#include "frontend/TokenStream.h"
#include "gc/Marking.h"

#if JS_HAS_XML_SUPPORT
#include "jsxml.h"

        if (name == cx->names().empty)
            break;
        if (!decls_.addUnique(name, dn))
            return false;
        break;

      case Definition::CONST:
      case Definition::VAR:
        if (sc->isModuleBox() || sc->isFunctionBox()) {
            dn->setOp(JSOP_GETLOCAL);
            /* Modules don't have local variables */
            if (sc->isModuleBox())
                dn->pn_dflags |= PND_CLOSED;
            dn->pn_dflags |= PND_BOUND;
            if (!dn->pn_cookie.set(cx, staticLevel, vars_.length()))
                return false;
            if (!vars_.append(dn))
                return false;
        }
        if (!decls_.addUnique(name, dn))
            return false;

                       (pc->sc->bindingsAccessedDynamically() &&
                        pc->decls().lookupFirst(name) == dn);

        *dst = Binding(name, kind, aliased);
    }
}

bool
ParseContext::generateBindings(JSContext *cx, InternalHandle<Bindings*> bindings) const
{
    JS_ASSERT(sc->isModuleBox() || sc->isFunctionBox());
    JS_ASSERT_IF(sc->isModuleBox(), args_.length() == 0);

    unsigned count = args_.length() + vars_.length();
    Binding *packedBindings = cx->tempLifoAlloc().newArrayUninitialized<Binding>(count);
    if (!packedBindings) {
        js_ReportOutOfMemory(cx);
        return false;
    }


    AppendPackedBindings(this, vars_, packedBindings + args_.length());

    if (!Bindings::initWithTemporaryStorage(cx, bindings, args_.length(), vars_.length(),
                                            packedBindings))
    {
        return false;
    }

    if (sc->isFunctionBox()) {
        FunctionBox *funbox = sc->asFunctionBox();
        if (bindings->hasAnyAliasedBindings() || funbox->hasExtensibleScope())
            funbox->function()->setIsHeavyweight();
    }

    return true;
}

Parser::Parser(JSContext *cx, const CompileOptions &options,
               StableCharPtr chars, size_t length, bool foldConstants)
  : AutoGCRooter(cx, PARSER),
    context(cx),

        reportError(NULL, JSMSG_SYNTAX_ERROR);
        return NULL;
    }

    if (!FoldConstants(context, pn, this))
        return NULL;

    InternalHandle<Bindings*> bindings(script, &script->bindings);
    if (!funpc.generateBindings(context, bindings))
        return NULL;

    return pn;
}

ParseNode *
Parser::functionBody(FunctionBodyType type)
{


/*
 * Beware: this function is called for functions nested in other functions or
 * global scripts but not for functions compiled through the Function
 * constructor or JSAPI. To always execute code when a function has finished
 * parsing, use Parser::functionBody.
 */
static bool
LeaveContext(ParseNode *pn, Parser *parser, PropertyName *funName = NULL,
             FunctionSyntaxKind kind = Expression)
{
    JSContext *cx = parser->context;
    ParseContext *pc = parser->pc;
    ParseContext *outerpc = pc->parent;
    outerpc->blockidGen = pc->blockidGen;

    if (!outerpc->topStmt || outerpc->topStmt->type == STMT_BLOCK)
        pn->pn_dflags |= PND_BLOCKCHILD;

    if (!pc->topStmt || pc->topStmt->type == STMT_BLOCK)
        fn->pn_dflags |= PND_BLOCKCHILD;

    /* Propagate unresolved lexical names up to pc->lexdeps. */
    if (pc->lexdeps->count()) {
        for (AtomDefnRange r = pc->lexdeps->all(); !r.empty(); r.popFront()) {
            JSAtom *atom = r.front().key();
            Definition *dn = r.front().value();
            JS_ASSERT(dn->isPlaceholder());

            if (pc->sc->isFunctionBox()) {
                if (atom == funName && kind == Expression) {
                    dn->setOp(JSOP_CALLEE);
                    if (!dn->pn_cookie.set(cx, pc->staticLevel,
                                           UpvarCookie::CALLEE_SLOT))
                        return false;
                    dn->pn_dflags |= PND_BOUND;
                    JS_ASSERT(dn->kind() == Definition::NAMED_LAMBDA);

                    /*
                     * Since 'dn' is a placeholder, it has not been defined in the
                     * ParseContext and hence we must manually flag a closed-over
                     * callee name as needing a dynamic scope (this is done for all
                     * definitions in the ParseContext by generateBindings).
                     *
                     * If 'dn' has been assigned to, then we also flag the function
                     * scope has needing a dynamic scope so that dynamic scope
                     * setter can either ignore the set (in non-strict mode) or
                     * produce an error (in strict mode).
                     */
                    if (dn->isClosed() || dn->isAssigned())
                        pc->sc->asFunctionBox()->function()->setIsHeavyweight();
                    continue;
                }
            }

            Definition *outerdn = outerpc->decls().lookupFirst(atom);

            /*
             * Make sure to deoptimize lexical dependencies that are polluted
             * by eval and function statements (which both flag the function as
             * having an extensible scope) or any enclosing 'with'.
             */
            if ((pc->sc->isFunctionBox() && pc->sc->asFunctionBox()->hasExtensibleScope()) ||
                outerpc->parsingWith)
                DeoptimizeUsesWithin(dn, pn->pn_pos);

            if (!outerdn) {
                AtomDefnAddPtr p = outerpc->lexdeps->lookupForAdd(atom);
                if (p) {
                    outerdn = p.value();
                } else {
                    /*
                     * Create a new placeholder for our outer lexdep. We could
                     * simply re-use the inner placeholder, but that introduces
                     * subtleties in the case where we find a later definition
                     * that captures an existing lexdep. For example:
                     *
                     *   function f() { function g() { x; } let x; }

                     *   function f() { x; { function g() { x; } let x; } }
                     *
                     * Here, the 'let' must not capture all the uses of f's
                     * lexdep entry for x, but it must capture the x node
                     * referred to from g's TOK_UPVARS node.  Always turning
                     * inherited lexdeps into uses of a new outer definition
                     * allows us to handle both these cases in a natural way.
                     */
                    outerdn = MakePlaceholder(dn, parser, outerpc);
                    if (!outerdn || !outerpc->lexdeps->add(p, atom, outerdn))
                        return false;
                }
            }

            /*
             * Insert dn's uses list at the front of outerdn's list.
             *
             * Without loss of generality or correctness, we allow a dn to
             * be in inner and outer lexdeps, since the purpose of lexdeps
             * is one-pass coordination of name use and definition across
             * functions, and if different dn's are used we'll merge lists
             * when leaving the inner function.
             *
             * The dn == outerdn case arises with generator expressions
             * (see CompExprTransplanter::transplant, the PN_FUNC/PN_NAME
             * case), and nowhere else, currently.
             */
            if (dn != outerdn) {
                if (ParseNode *pnu = dn->dn_uses) {
                    while (true) {
                        pnu->pn_lexdef = outerdn;
                        if (!pnu->pn_link)
                            break;
                        pnu = pnu->pn_link;
                    }
                    pnu->pn_link = outerdn->dn_uses;
                    outerdn->dn_uses = dn->dn_uses;
                    dn->dn_uses = NULL;
                }

                outerdn->pn_dflags |= dn->pn_dflags & ~PND_PLACEHOLDER;
            }

            /* Mark the outer dn as escaping. */
            outerdn->pn_dflags |= PND_CLOSED;
        }
    }

    InternalHandle<Bindings*> bindings = pc->sc->isModuleBox()
        ? InternalHandle<Bindings*>::fromMarkedLocation(&pc->sc->asModuleBox()->bindings)
        : InternalHandle<Bindings*>::fromMarkedLocation(&pc->sc->asFunctionBox()->bindings);
    if (!pc->generateBindings(cx, bindings))
        return false;

    pc->lexdeps.releaseMap(cx);
    return true;
}

/*
 * DefineArg is called for both the arguments of a regular function definition
 * and the arguments specified by the Function constructor.
 *
 * The 'disallowDuplicateArgs' bool indicates whether the use of another

         * As a SpiderMonkey-specific extension, non-body-level function
         * statements (e.g., functions in an "if" or "while" block) are
         * dynamically bound when control flow reaches the statement. The
         * emitter normally emits functions in two passes (see PNK_ARGSBODY).
         * To distinguish
         */
        if (bodyLevel) {
            JS_ASSERT(pn->functionIsHoisted());
            JS_ASSERT_IF(pc->sc->isGlobalSharedContext(), pn->pn_cookie.isFree());
            JS_ASSERT_IF(pc->sc->isModuleBox() || pc->sc->isFunctionBox(), !pn->pn_cookie.isFree());
        } else {
            JS_ASSERT(!pc->sc->strict);
            JS_ASSERT(pn->pn_cookie.isFree());
            if (pc->sc->isFunctionBox()) {
                FunctionBox *funbox = pc->sc->asFunctionBox();
                funbox->setMightAliasLocals();
                funbox->setHasExtensibleScope();
            }

        outerpc->sc->setBindingsAccessedDynamically();


    pn->pn_funbox = funbox;
    pn->pn_body->append(body);
    pn->pn_body->pn_pos = body->pn_pos;
    pn->pn_blockid = outerpc->blockid();

    if (!LeaveContext(pn, this, funName, kind))
        return false;

    return true;
}

ParseNode *
Parser::moduleStmt()
{
    JS_ASSERT(versionNumber() == JSVERSION_ECMA_5);
    JS_ASSERT(tokenStream.currentToken().name() == context->names().module);
    JS_ALWAYS_TRUE(tokenStream.matchToken(TOK_NAME));

    if (pc->sc->isFunctionBox() || !pc->atBodyLevel()) {
        reportError(NULL, JSMSG_MODULE_STATEMENT);
        return NULL;
    }
    RootedPropertyName name(context, tokenStream.currentToken().name());
    ParseNode *pn = NameNode::create(PNK_MODULE, name, this, pc);
    if (!pn)
        return NULL;
    if (Definition *dn = pc->lexdeps.lookupDefn(name)) {
        JS_ASSERT(dn->isDefn());
        dn->setKind(PNK_MODULE);
        dn->setArity(PN_NAME);
        dn->pn_pos.begin = pn->pn_pos.begin;
        dn->pn_pos.end = pn->pn_pos.end;

        dn->pn_body = NULL;
        dn->pn_cookie.makeFree();

        pc->lexdeps->remove(name);
        freeTree(pn);
        pn = dn;
    }
    if (!pc->define(context, name, pn, Definition::VAR))
        return NULL;

    Module *module = js_NewModule(context, name);
    if (!module)
        return NULL;
    ModuleBox *modulebox = context->tempLifoAlloc().new_<ModuleBox>(context, pc, module, traceListHead);
    if (!modulebox) {
        js_ReportOutOfMemory(context);
        return NULL;
    }
    pn->pn_modulebox = modulebox;

    ParseContext modulepc(this, modulebox, pc->staticLevel + 1, pc->blockidGen);
    if (!modulepc.init())
        return NULL;

    MUST_MATCH_TOKEN(TOK_LC, JSMSG_CURLY_BEFORE_MODULE);
    modulebox->bufStart = tokenStream.offsetOfToken(tokenStream.currentToken());
    pn->pn_body = statements();
    MUST_MATCH_TOKEN(TOK_RC, JSMSG_CURLY_AFTER_MODULE);
    pn->pn_modulebox->bufEnd = tokenStream.offsetOfToken(tokenStream.currentToken()) + 1;

    if (!LeaveContext(pn, this))
        return NULL;
    return pn;
}

ParseNode *
Parser::functionStmt()
{
    JS_ASSERT(tokenStream.currentToken().type == TOK_FUNCTION);
    RootedPropertyName name(context);
    if (tokenStream.getToken(TSF_KEYWORD_IS_NAME) == TOK_NAME) {
        name = tokenStream.currentToken().name();
    } else {
        /* Unnamed function expressions are forbidden in statement context. */

            return NULL;
        }

        if (canHaveDirectives) {
            if (!maybeParseDirective(next, &canHaveDirectives))
                return NULL;
        }

        if (next->isKind(PNK_MODULE)) {
            JS_ASSERT(pc->atBodyLevel());
            pn->pn_xflags |= PNX_MODULEDEFS;
        } else if (next->isKind(PNK_FUNCTION)) {
            /*
             * PNX_FUNCDEFS notifies the emitter that the block contains body-
             * level function definitions that should be processed before the
             * rest of nodes.
             *
             * |hasFunctionStmt| is for the TOK_LC case in Statement. It
             * is relevant only for function definitions not at body-level,
             * which we call function statements.

    } while (0);

    /* Check termination of this primitive statement. */
    return MatchOrInsertSemicolon(context, &tokenStream) ? pn : NULL;
}
#endif

ParseNode *
Parser::exportStatement()
{
    if (!pc->sc->isModuleBox()) {
        reportError(NULL, JSMSG_EXPORT_STATEMENT);
        return NULL;
    }
    ParseNode *pn = UnaryNode::create(PNK_EXPORT, this);
    if (!pn)
        return NULL;
    StmtInfoPC stmtInfo(context);
    PushStatementPC(pc, &stmtInfo, STMT_EXPORT);
    pn->pn_kid = statement();
    PopStatementPC(context, pc);
    if (!pn->pn_kid)
        return NULL;
    return pn;
}

ParseNode *
Parser::expressionStatement()
{
    tokenStream.ungetToken();
    ParseNode *pn2 = expr();
    if (!pn2)
        return NULL;

    if (tokenStream.peekToken() == TOK_COLON) {

        pn->pn_xflags |= PNX_POPVAR;
        break;

#if JS_HAS_BLOCK_SCOPE
      case TOK_LET:
        return letStatement();
#endif /* JS_HAS_BLOCK_SCOPE */

      case TOK_EXPORT:
        return exportStatement();

      case TOK_RETURN:
        pn = returnOrYield(false);
        if (!pn)
            return NULL;
        break;

      case TOK_LC:
      {

        pn->pn_kid = pn2;
        break;
      }
#endif

      case TOK_ERROR:
        return NULL;

      case TOK_NAME:
        if (versionNumber() == JSVERSION_ECMA_5 &&
            tokenStream.currentToken().name() == context->names().module &&
            tokenStream.peekTokenSameLine(TSF_OPERAND) == TOK_NAME)
        {
            return moduleStmt();
        }

      default:
        return expressionStatement();
    }

    /* Check termination of this primitive statement. */
    return MatchOrInsertSemicolon(context, &tokenStream) ? pn : NULL;
}



        if (AtomDefnPtr p = genpc.lexdeps->lookup(context->names().arguments)) {
            Definition *dn = p.value();
            ParseNode *errorNode = dn->dn_uses ? dn->dn_uses : body;
            reportError(errorNode, JSMSG_BAD_GENEXP_BODY, js_arguments_str);
            return NULL;
        }

        if (!LeaveContext(genfn, this))
            return NULL;
    }

    /*
     * Our result is a call expression that invokes the anonymous generator
     * function object.
     */
    ParseNode *result = ListNode::create(PNK_CALL, this);






    /* See the sad story in DefineArg. */
    void prepareToAddDuplicateArg(Definition *prevDecl);

    /* See the sad story in MakeDefIntoUse. */
    void updateDecl(JSAtom *atom, ParseNode *newDecl);

    /*
     * After a module or function body has been parsed, the parser generates
     * its "bindings". Bindings are a data-structure, ultimately stored in the
     * compiled JSScript, that serve three purposes:
     *  - After parsing, the ParseContext is destroyed and 'decls' along with
     *    it. Mostly, the emitter just uses the binding information stored in
     *    the use/def nodes, but the emitter occasionally needs 'bindings' for
     *    various scope-related queries.
     *  - Bindings provide the initial js::Shape to use when creating a dynamic
     *    scope object (js::CallObject) for the function. This shape is used
     *    during dynamic name lookup.
     *  - Sometimes a script's bindings are accessed at runtime to retrieve the
     *    contents of the lexical scope (e.g., from the debugger).
     */
    bool generateBindings(JSContext *cx, InternalHandle<Bindings*> bindings) const;

  public:
    ParseNode       *yieldNode;     /* parse node for a yield expression that might
                                       be an error if we turn out to be inside a
                                       generator expression */

  private:
    ParseContext    **parserPC;     /* this points to the Parser's active pc

     * Parsers whose name has a '1' suffix leave the TokenStream state
     * pointing to the token one past the end of the parsed fragment.  For a
     * number of the parsers this is convenient and avoids a lot of
     * unnecessary ungetting and regetting of tokens.
     *
     * Some parsers have two versions:  an always-inlined version (with an 'i'
     * suffix) and a never-inlined version (with an 'n' suffix).
     */
    ParseNode *moduleStmt();
    ParseNode *functionStmt();
    ParseNode *functionExpr();
    ParseNode *statements(bool *hasFunctionStmt = NULL);

    ParseNode *switchStatement();
    ParseNode *forStatement();
    ParseNode *tryStatement();
    ParseNode *withStatement();


    ParseNode *condition();
    ParseNode *comprehensionTail(ParseNode *kid, unsigned blockid, bool isGenexp,
                                 ParseNodeKind kind = PNK_SEMI, JSOp op = JSOP_NOP);
    ParseNode *generatorExpr(ParseNode *kid);
    bool argumentList(ParseNode *listNode);
    ParseNode *bracketedExpr();
    ParseNode *letBlock(LetContext letContext);
    ParseNode *exportStatement();
    ParseNode *returnOrYield(bool useAssignExpr);
    ParseNode *destructuringExpr(BindData *data, TokenKind tt);

    bool checkForFunctionNode(PropertyName *name, ParseNode *node);

    ParseNode *identifierName(bool afterDoubleDot);

#if JS_HAS_XML_SUPPORT





 * STMT_WITH and STMT_CATCH, or you will break StmtInfoBase::linksScope. If you
 * add a non-looping statement type, add it before STMT_DO_LOOP or you will
 * break StmtInfoBase::isLoop().
 *
 * Also remember to keep the statementName array in BytecodeEmitter.cpp in
 * sync.
 */
enum StmtType {
    STMT_EXPORT,                /* export statement */
    STMT_LABEL,                 /* labeled statement:  L: s */
    STMT_IF,                    /* if (then) statement */
    STMT_ELSE,                  /* else clause of if statement */
    STMT_SEQ,                   /* synthetic sequence of statements */
    STMT_BLOCK,                 /* compound statement: { s1[;... sN] } */
    STMT_SWITCH,                /* switch statement */
    STMT_WITH,                  /* with statement */
    STMT_CATCH,                 /* catch block */

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

Line	Link Here

Lines 383-390 MSG_DEF(JSMSG_INVALID_LANGUAGE_TAG, 32	Link Here

383

MSG_DEF(JSMSG_INVALID_LOCALE_MATCHER, 330, 1, JSEXN_RANGEERR, "invalid locale matcher in supportedLocalesOf(): {0}")

383

MSG_DEF(JSMSG_INVALID_LOCALE_MATCHER, 330, 1, JSEXN_RANGEERR, "invalid locale matcher in supportedLocalesOf(): {0}")

384

MSG_DEF(JSMSG_INVALID_OPTION_VALUE,   331, 2, JSEXN_RANGEERR, "invalid value {1} for option {0}")

384

MSG_DEF(JSMSG_INVALID_OPTION_VALUE,   331, 2, JSEXN_RANGEERR, "invalid value {1} for option {0}")

385

MSG_DEF(JSMSG_INVALID_DIGITS_VALUE,   332, 1, JSEXN_RANGEERR, "invalid digits value: {0}")

385

MSG_DEF(JSMSG_INVALID_DIGITS_VALUE,   332, 1, JSEXN_RANGEERR, "invalid digits value: {0}")

386

MSG_DEF(JSMSG_INTL_OBJECT_REINITED,   333, 0, JSEXN_TYPEERR, "can't initialize object twice as an object of an Intl constructor")

386

MSG_DEF(JSMSG_INTL_OBJECT_REINITED,   333, 0, JSEXN_TYPEERR, "can't initialize object twice as an object of an Intl constructor")

387

MSG_DEF(JSMSG_INVALID_CURRENCY_CODE,  334, 1, JSEXN_RANGEERR, "invalid currency code in NumberFormat(): {0}")

387

MSG_DEF(JSMSG_INVALID_CURRENCY_CODE,  334, 1, JSEXN_RANGEERR, "invalid currency code in NumberFormat(): {0}")

388

MSG_DEF(JSMSG_UNDEFINED_CURRENCY,     335, 0, JSEXN_TYPEERR, "undefined currency in NumberFormat() with currency style")

388

MSG_DEF(JSMSG_UNDEFINED_CURRENCY,     335, 0, JSEXN_TYPEERR, "undefined currency in NumberFormat() with currency style")

389

MSG_DEF(JSMSG_INVALID_TIME_ZONE,      336, 1, JSEXN_RANGEERR, "invalid time zone in DateTimeFormat(): {0}")

389

MSG_DEF(JSMSG_INVALID_TIME_ZONE,      336, 1, JSEXN_RANGEERR, "invalid time zone in DateTimeFormat(): {0}")

390

MSG_DEF(JSMSG_DATE_NOT_FINITE,        337, 0, JSEXN_RANGEERR, "date value is not finite in DateTimeFormat.format()")

390

MSG_DEF(JSMSG_DATE_NOT_FINITE,        337, 0, JSEXN_RANGEERR, "date value is not finite in DateTimeFormat.format()")

391

MSG_DEF(JSMSG_MODULE_STATEMENT,       338, 0, JSEXN_SYNTAXERR, "modules may be declared only at top level or immediately within another module")

392

MSG_DEF(JSMSG_CURLY_BEFORE_MODULE,    339, 0, JSEXN_SYNTAXERR, "missing { before module body")

393

MSG_DEF(JSMSG_CURLY_AFTER_MODULE,     340, 0, JSEXN_SYNTAXERR, "missing } after module body")

394

MSG_DEF(JSMSG_EXPORT_STATEMENT,       341, 0, JSEXN_SYNTAXERR, "export statements may occur only within a module")





js_AtomToPrintableString(JSContext *cx, JSAtom *atom, JSAutoByteString *bytes)
{
    return js_ValueToPrintable(cx, StringValue(atom), bytes);
}

const char * js::TypeStrings[] = {
    js_undefined_str,
    js_object_str,
    js_module_str,
    js_function_str,
    js_string_str,
    js_number_str,
    js_boolean_str,
    js_null_str,
    js_xml_str,
};






    JSVERSION_UNKNOWN = -1,
    JSVERSION_LATEST  = JSVERSION_ECMA_5
} JSVersion;

/* Result of typeof operator enumeration. */
typedef enum JSType {
    JSTYPE_VOID,                /* undefined */
    JSTYPE_OBJECT,              /* object */
    JSTYPE_MODULE,              /* module */
    JSTYPE_FUNCTION,            /* function */
    JSTYPE_STRING,              /* string */
    JSTYPE_NUMBER,              /* number */
    JSTYPE_BOOLEAN,             /* boolean */
    JSTYPE_NULL,                /* null */
    JSTYPE_XML,                 /* xml object */
    JSTYPE_LIMIT
} JSType;





    macro(valueOf, valueOf, "valueOf") \
    macro(var, var, "var") \
    macro(void0, void0, "(void 0)") \
    macro(watch, watch, "watch") \
    macro(writable, writable, "writable") \
    /* Type names must be contiguous and ordered; see js::TypeName. */ \
    macro(undefined, undefined, "undefined") \
    macro(object, object, "object") \
    macro(module, module, "module") \
    macro(function, function, "function") \
    macro(string, string, "string") \
    macro(number, number, "number") \
    macro(boolean, boolean, "boolean") \
    macro(null, null, "null") \
    macro(xml, xml, "xml") \
    FOR_EACH_XML_ONLY_NAME(macro)






    macro(typeof, typeof, TOK_TYPEOF, JSOP_TYPEOF, JSVERSION_DEFAULT) \
    macro(var, var, TOK_VAR, JSOP_DEFVAR, JSVERSION_DEFAULT) \
    macro(void, void_, TOK_VOID, JSOP_VOID, JSVERSION_DEFAULT) \
    macro(while, while_, TOK_WHILE, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(with, with, TOK_WITH, JSOP_NOP, JSVERSION_DEFAULT) \
    /* ES5 reserved keywords reserved in all code. */ \
    macro(class, class_, TOK_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(enum, enum_, TOK_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(export, export, TOK_EXPORT, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(extends, extends, TOK_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(import, import, TOK_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(super, super, TOK_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    /* ES5 future reserved keywords in strict mode. */ \
    macro(implements, implements, TOK_STRICT_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(interface, interface, TOK_STRICT_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(package, package, TOK_STRICT_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \
    macro(private, private_, TOK_STRICT_RESERVED, JSOP_NOP, JSVERSION_DEFAULT) \

Return to bug 568953