* Finish an AST node, adding `type` and `end` properties. * * @param {!node_t} node * @param {string} type * @returns {!node_t}

* This function is used to raise exceptions on parse errors. It * takes an offset integer (into the current `input`) to indicate * the location

* Continue to the next token.

* Predicate that tests whether the next token is of the given * type, and if yes, consumes it as a side effect. * @param {!Object} type * @re

* Expect a token of a given type. If found, consume it, otherwise, * raise an unexpected token error. * * @param {!Object} type

* @param {!Object} type * @param {number} size

* Called at the end of every token. Sets `tokEnd`, `tokVal`, and * `tokRegexpAllowed`, and skips the space after the token, so that * the next o

* @returns {!node_t}

* Parse a full expression. The arguments are used to forbid comma * sequences (in argument lists, array literals, or object literals) * or the `

* Raise an unexpected token error. * @throws {SyntaxError}

* Parse the next token as an identifier. If `liberal` is true (used * when parsing properties), it will also convert keywords into * identifiers

* Start a node whose start offset information should be based on * the start of another node. For example, a binary operator node is * only star

* Consume a semicolon, or, failing that, see if we are allowed to * pretend that there is a semicolon at this position.

* @param {boolean=} forceRegexp

* Parse a semicolon-enclosed block of statements, handling `"use * strict"` declarations when `allowStrict` is true (used for * function bodies)

* Used for constructs like `switch` and `if` that insist on * parentheses around their expression. * * @returns {!node_t}

* Read an integer in the given radix. Return null if zero digits * were read, the integer value otherwise. When `len` is given, this * will retu

* Test whether a semicolon can be inserted at the current position. * * @returns {boolean}

* Verify that a node is an lval — something that can be assigned to. * * @param {!node_t} expr

* @param {string} words * @returns {function(*): boolean}

* Parse a single statement. * * If expecting a statement and finding a slash operator, parse a * regular expression literal. This is to handl

* Used to read character escape sequences ('\x', '\u', '\U'). * * @param {number} len * @returns {number}

* Test whether a statement node is the string literal `"use strict"`. * * @param {!node_t} stmt * @returns {boolean}

* Parse an atomic expression — either a single token that is an expression, * an expression started by a keyword like `function` or `new`, * or

* Parses a comma-separated list of expressions, and returns them as * an array. `close` is the token type that ends the list, and * `allowEmpty`

* Parse a regular `for` loop. The disambiguation code in `parseStatement` * will already have parsed the init statement or expression. * * @p

* Parse a function declaration or literal (depending on the * `isStatement` parameter). * * @param {!node_t} node * @param {boolean} isSta

* Enter strict mode. Re-reads the next token to please pedantic * tests ("use strict"; 010; -- should fail). * * @param {boolean} strct