diff options
Diffstat (limited to 'src/civetweb/src/third_party/duktape-1.5.2/src-separate/duk_lexer.c')
| -rw-r--r-- | src/civetweb/src/third_party/duktape-1.5.2/src-separate/duk_lexer.c | 2067 |
1 files changed, 2067 insertions, 0 deletions
diff --git a/src/civetweb/src/third_party/duktape-1.5.2/src-separate/duk_lexer.c b/src/civetweb/src/third_party/duktape-1.5.2/src-separate/duk_lexer.c new file mode 100644 index 000000000..2a02829d9 --- /dev/null +++ b/src/civetweb/src/third_party/duktape-1.5.2/src-separate/duk_lexer.c @@ -0,0 +1,2067 @@ +/* + * Lexer for source files, ToNumber() string conversions, RegExp expressions, + * and JSON. + * + * Provides a stream of Ecmascript tokens from an UTF-8/CESU-8 buffer. The + * caller can also rewind the token stream into a certain position which is + * needed by the compiler part for multi-pass scanning. Tokens are + * represented as duk_token structures, and contain line number information. + * Token types are identified with DUK_TOK_* defines. + * + * Characters are decoded into a fixed size lookup window consisting of + * decoded Unicode code points, with window positions past the end of the + * input filled with an invalid codepoint (-1). The tokenizer can thus + * perform multiple character lookups efficiently and with few sanity + * checks (such as access outside the end of the input), which keeps the + * tokenization code small at the cost of performance. + * + * Character data in tokens, such as identifier names and string literals, + * is encoded into CESU-8 format on-the-fly while parsing the token in + * question. The string data is made reachable to garbage collection by + * placing the token-related values in value stack entries allocated for + * this purpose by the caller. The characters exist in Unicode code point + * form only in the fixed size lookup window, which keeps character data + * expansion (of especially ASCII data) low. + * + * Token parsing supports the full range of Unicode characters as described + * in the E5 specification. Parsing has been optimized for ASCII characters + * because ordinary Ecmascript code consists almost entirely of ASCII + * characters. Matching of complex Unicode codepoint sets (such as in the + * IdentifierStart and IdentifierPart productions) is optimized for size, + * and is done using a linear scan of a bit-packed list of ranges. This is + * very slow, but should never be entered unless the source code actually + * contains Unicode characters. + * + * Ecmascript tokenization is partially context sensitive. First, + * additional future reserved words are recognized in strict mode (see E5 + * Section 7.6.1.2). Second, a forward slash character ('/') can be + * recognized either as starting a RegExp literal or as a division operator, + * depending on context. The caller must provide necessary context flags + * when requesting a new token. + * + * Future work: + * + * * Make line number tracking optional, as it consumes space. + * + * * Add a feature flag for disabling UTF-8 decoding of input, as most + * source code is ASCII. Because of Unicode escapes written in ASCII, + * this does not allow Unicode support to be removed from e.g. + * duk_unicode_is_identifier_start() nor does it allow removal of CESU-8 + * encoding of e.g. string literals. + * + * * Add a feature flag for disabling Unicode compliance of e.g. identifier + * names. This allows for a build more than a kilobyte smaller, because + * Unicode ranges needed by duk_unicode_is_identifier_start() and + * duk_unicode_is_identifier_part() can be dropped. String literals + * should still be allowed to contain escaped Unicode, so this still does + * not allow removal of CESU-8 encoding of e.g. string literals. + * + * * Character lookup tables for codepoints above BMP could be stripped. + * + * * Strictly speaking, E5 specification requires that source code consists + * of 16-bit code units, and if not, must be conceptually converted to + * that format first. The current lexer processes Unicode code points + * and allows characters outside the BMP. These should be converted to + * surrogate pairs while reading the source characters into the window, + * not after tokens have been formed (as is done now). However, the fix + * is not trivial because two characters are decoded from one codepoint. + * + * * Optimize for speed as well as size. Large if-else ladders are (at + * least potentially) slow. + */ + +#include "duk_internal.h" + +/* + * Various defines and file specific helper macros + */ + +#define DUK__MAX_RE_DECESC_DIGITS 9 +#define DUK__MAX_RE_QUANT_DIGITS 9 /* Does not allow e.g. 2**31-1, but one more would allow overflows of u32. */ + +/* whether to use macros or helper function depends on call count */ +#define DUK__ISDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_9) +#define DUK__ISHEXDIGIT(x) duk__is_hex_digit((x)) +#define DUK__ISOCTDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_7) +#define DUK__ISDIGIT03(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_3) +#define DUK__ISDIGIT47(x) ((x) >= DUK_ASC_4 && (x) <= DUK_ASC_7) + +/* lexer character window helpers */ +#define DUK__LOOKUP(lex_ctx,index) ((lex_ctx)->window[(index)].codepoint) +#define DUK__ADVANCECHARS(lex_ctx,count) duk__advance_bytes((lex_ctx), (count) * sizeof(duk_lexer_codepoint)) +#define DUK__ADVANCEBYTES(lex_ctx,count) duk__advance_bytes((lex_ctx), (count)) +#define DUK__INITBUFFER(lex_ctx) duk__initbuffer((lex_ctx)) +#define DUK__APPENDBUFFER(lex_ctx,x) duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x)) + +/* lookup shorthands (note: assume context variable is named 'lex_ctx') */ +#define DUK__L0() DUK__LOOKUP(lex_ctx, 0) +#define DUK__L1() DUK__LOOKUP(lex_ctx, 1) +#define DUK__L2() DUK__LOOKUP(lex_ctx, 2) +#define DUK__L3() DUK__LOOKUP(lex_ctx, 3) +#define DUK__L4() DUK__LOOKUP(lex_ctx, 4) +#define DUK__L5() DUK__LOOKUP(lex_ctx, 5) + +/* packed advance/token number macro used by multiple functions */ +#define DUK__ADVTOK(advbytes,tok) ((((advbytes) * sizeof(duk_lexer_codepoint)) << 8) + (tok)) + +/* + * Advance lookup window by N characters, filling in new characters as + * necessary. After returning caller is guaranteed a character window of + * at least DUK_LEXER_WINDOW_SIZE characters. + * + * The main function duk__advance_bytes() is called at least once per every + * token so it has a major lexer/compiler performance impact. There are two + * variants for the main duk__advance_bytes() algorithm: a sliding window + * approach which is slightly faster at the cost of larger code footprint, + * and a simple copying one. + * + * Decoding directly from the source string would be another lexing option. + * But the lookup window based approach has the advantage of hiding the + * source string and its encoding effectively which gives more flexibility + * going forward to e.g. support chunked streaming of source from flash. + * + * Decodes UTF-8/CESU-8 leniently with support for code points from U+0000 to + * U+10FFFF, causing an error if the input is unparseable. Leniency means: + * + * * Unicode code point validation is intentionally not performed, + * except to check that the codepoint does not exceed 0x10ffff. + * + * * In particular, surrogate pairs are allowed and not combined, which + * allows source files to represent all SourceCharacters with CESU-8. + * Broken surrogate pairs are allowed, as Ecmascript does not mandate + * their validation. + * + * * Allow non-shortest UTF-8 encodings. + * + * Leniency here causes few security concerns because all character data is + * decoded into Unicode codepoints before lexer processing, and is then + * re-encoded into CESU-8. The source can be parsed as strict UTF-8 with + * a compiler option. However, Ecmascript source characters include -all- + * 16-bit unsigned integer codepoints, so leniency seems to be appropriate. + * + * Note that codepoints above the BMP are not strictly SourceCharacters, + * but the lexer still accepts them as such. Before ending up in a string + * or an identifier name, codepoints above BMP are converted into surrogate + * pairs and then CESU-8 encoded, resulting in 16-bit Unicode data as + * expected by Ecmascript. + * + * An alternative approach to dealing with invalid or partial sequences + * would be to skip them and replace them with e.g. the Unicode replacement + * character U+FFFD. This has limited utility because a replacement character + * will most likely cause a parse error, unless it occurs inside a string. + * Further, Ecmascript source is typically pure ASCII. + * + * See: + * + * http://en.wikipedia.org/wiki/UTF-8 + * http://en.wikipedia.org/wiki/CESU-8 + * http://tools.ietf.org/html/rfc3629 + * http://en.wikipedia.org/wiki/UTF-8#Invalid_byte_sequences + * + * Future work: + * + * * Reject other invalid Unicode sequences (see Wikipedia entry for examples) + * in strict UTF-8 mode. + * + * * Size optimize. An attempt to use a 16-byte lookup table for the first + * byte resulted in a code increase though. + * + * * Is checking against maximum 0x10ffff really useful? 4-byte encoding + * imposes a certain limit anyway. + * + * * Support chunked streaming of source code. Can be implemented either + * by streaming chunks of bytes or chunks of codepoints. + */ + +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) +DUK_LOCAL void duk__fill_lexer_buffer(duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes) { + duk_lexer_codepoint *cp, *cp_end; + duk_ucodepoint_t x; + duk_small_uint_t contlen; + const duk_uint8_t *p, *p_end; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + duk_ucodepoint_t mincp; +#endif + duk_int_t input_line; + + /* Use temporaries and update lex_ctx only when finished. */ + input_line = lex_ctx->input_line; + p = lex_ctx->input + lex_ctx->input_offset; + p_end = lex_ctx->input + lex_ctx->input_length; + + cp = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->buffer + start_offset_bytes); + cp_end = lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE; + + for (; cp != cp_end; cp++) { + cp->offset = (duk_size_t) (p - lex_ctx->input); + cp->line = input_line; + + /* XXX: potential issue with signed pointers, p_end < p. */ + if (DUK_UNLIKELY(p >= p_end)) { + /* If input_offset were assigned a negative value, it would + * result in a large positive value. Most likely it would be + * larger than input_length and be caught here. In any case + * no memory unsafe behavior would happen. + */ + cp->codepoint = -1; + continue; + } + + x = (duk_ucodepoint_t) (*p++); + + /* Fast path. */ + + if (DUK_LIKELY(x < 0x80UL)) { + DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */ + if (DUK_UNLIKELY(x <= 0x000dUL)) { + if ((x == 0x000aUL) || + ((x == 0x000dUL) && (p >= p_end || *p != 0x000aUL))) { + /* lookup for 0x000a above assumes shortest encoding now */ + + /* E5 Section 7.3, treat the following as newlines: + * LF + * CR [not followed by LF] + * LS + * PS + * + * For CR LF, CR is ignored if it is followed by LF, and the LF will bump + * the line number. + */ + input_line++; + } + } + + cp->codepoint = (duk_codepoint_t) x; + continue; + } + + /* Slow path. */ + + if (x < 0xc0UL) { + /* 10xx xxxx -> invalid */ + goto error_encoding; + } else if (x < 0xe0UL) { + /* 110x xxxx 10xx xxxx */ + contlen = 1; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + mincp = 0x80UL; +#endif + x = x & 0x1fUL; + } else if (x < 0xf0UL) { + /* 1110 xxxx 10xx xxxx 10xx xxxx */ + contlen = 2; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + mincp = 0x800UL; +#endif + x = x & 0x0fUL; + } else if (x < 0xf8UL) { + /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */ + contlen = 3; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + mincp = 0x10000UL; +#endif + x = x & 0x07UL; + } else { + /* no point in supporting encodings of 5 or more bytes */ + goto error_encoding; + } + + DUK_ASSERT(p_end >= p); + if ((duk_size_t) contlen > (duk_size_t) (p_end - p)) { + goto error_clipped; + } + + while (contlen > 0) { + duk_small_uint_t y; + y = *p++; + if ((y & 0xc0U) != 0x80U) { + /* check that byte has the form 10xx xxxx */ + goto error_encoding; + } + x = x << 6; + x += y & 0x3fUL; + contlen--; + } + + /* check final character validity */ + + if (x > 0x10ffffUL) { + goto error_encoding; + } +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) { + goto error_encoding; + } +#endif + + DUK_ASSERT(x != 0x000aUL && x != 0x000dUL); + if ((x == 0x2028UL) || (x == 0x2029UL)) { + input_line++; + } + + cp->codepoint = (duk_codepoint_t) x; + } + + lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input); + lex_ctx->input_line = input_line; + return; + + error_clipped: /* clipped codepoint */ + error_encoding: /* invalid codepoint encoding or codepoint */ + lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input); + lex_ctx->input_line = input_line; + + DUK_ERROR_SYNTAX(lex_ctx->thr, "utf-8 decode failed"); +} + +DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) { + duk_small_uint_t used_bytes, avail_bytes; + + DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */ + DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))); + DUK_ASSERT(lex_ctx->window >= lex_ctx->buffer); + DUK_ASSERT(lex_ctx->window < lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE); + DUK_ASSERT((duk_uint8_t *) lex_ctx->window + count_bytes <= (duk_uint8_t *) lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint)); + + /* Zero 'count' is also allowed to make call sites easier. + * Arithmetic in bytes generates better code in GCC. + */ + + lex_ctx->window = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->window + count_bytes); /* avoid multiply */ + used_bytes = (duk_small_uint_t) ((duk_uint8_t *) lex_ctx->window - (duk_uint8_t *) lex_ctx->buffer); + avail_bytes = DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint) - used_bytes; + if (avail_bytes < (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))) { + /* Not enough data to provide a full window, so "scroll" window to + * start of buffer and fill up the rest. + */ + DUK_MEMMOVE((void *) lex_ctx->buffer, + (const void *) lex_ctx->window, + (size_t) avail_bytes); + lex_ctx->window = lex_ctx->buffer; + duk__fill_lexer_buffer(lex_ctx, avail_bytes); + } +} + +DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx) { + lex_ctx->window = lex_ctx->buffer; + duk__fill_lexer_buffer(lex_ctx, 0); +} +#else /* DUK_USE_LEXER_SLIDING_WINDOW */ +DUK_LOCAL duk_codepoint_t duk__read_char(duk_lexer_ctx *lex_ctx) { + duk_ucodepoint_t x; + duk_small_uint_t len; + duk_small_uint_t i; + const duk_uint8_t *p; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + duk_ucodepoint_t mincp; +#endif + duk_size_t input_offset; + + input_offset = lex_ctx->input_offset; + if (DUK_UNLIKELY(input_offset >= lex_ctx->input_length)) { + /* If input_offset were assigned a negative value, it would + * result in a large positive value. Most likely it would be + * larger than input_length and be caught here. In any case + * no memory unsafe behavior would happen. + */ + return -1; + } + + p = lex_ctx->input + input_offset; + x = (duk_ucodepoint_t) (*p); + + if (DUK_LIKELY(x < 0x80UL)) { + /* 0xxx xxxx -> fast path */ + + /* input offset tracking */ + lex_ctx->input_offset++; + + DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */ + if (DUK_UNLIKELY(x <= 0x000dUL)) { + if ((x == 0x000aUL) || + ((x == 0x000dUL) && (lex_ctx->input_offset >= lex_ctx->input_length || + lex_ctx->input[lex_ctx->input_offset] != 0x000aUL))) { + /* lookup for 0x000a above assumes shortest encoding now */ + + /* E5 Section 7.3, treat the following as newlines: + * LF + * CR [not followed by LF] + * LS + * PS + * + * For CR LF, CR is ignored if it is followed by LF, and the LF will bump + * the line number. + */ + lex_ctx->input_line++; + } + } + + return (duk_codepoint_t) x; + } + + /* Slow path. */ + + if (x < 0xc0UL) { + /* 10xx xxxx -> invalid */ + goto error_encoding; + } else if (x < 0xe0UL) { + /* 110x xxxx 10xx xxxx */ + len = 2; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + mincp = 0x80UL; +#endif + x = x & 0x1fUL; + } else if (x < 0xf0UL) { + /* 1110 xxxx 10xx xxxx 10xx xxxx */ + len = 3; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + mincp = 0x800UL; +#endif + x = x & 0x0fUL; + } else if (x < 0xf8UL) { + /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */ + len = 4; +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + mincp = 0x10000UL; +#endif + x = x & 0x07UL; + } else { + /* no point in supporting encodings of 5 or more bytes */ + goto error_encoding; + } + + DUK_ASSERT(lex_ctx->input_length >= lex_ctx->input_offset); + if ((duk_size_t) len > (duk_size_t) (lex_ctx->input_length - lex_ctx->input_offset)) { + goto error_clipped; + } + + p++; + for (i = 1; i < len; i++) { + duk_small_uint_t y; + y = *p++; + if ((y & 0xc0U) != 0x80U) { + /* check that byte has the form 10xx xxxx */ + goto error_encoding; + } + x = x << 6; + x += y & 0x3fUL; + } + + /* check final character validity */ + + if (x > 0x10ffffUL) { + goto error_encoding; + } +#if defined(DUK_USE_STRICT_UTF8_SOURCE) + if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) { + goto error_encoding; + } +#endif + + /* input offset tracking */ + lex_ctx->input_offset += len; + + /* line tracking */ + DUK_ASSERT(x != 0x000aUL && x != 0x000dUL); + if ((x == 0x2028UL) || (x == 0x2029UL)) { + lex_ctx->input_line++; + } + + return (duk_codepoint_t) x; + + error_clipped: /* clipped codepoint */ + error_encoding: /* invalid codepoint encoding or codepoint */ + DUK_ERROR_SYNTAX(lex_ctx->thr, "utf-8 decode failed"); + return 0; +} + +DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) { + duk_small_uint_t keep_bytes; + duk_lexer_codepoint *cp, *cp_end; + + DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */ + DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))); + + /* Zero 'count' is also allowed to make call sites easier. */ + + keep_bytes = DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint) - count_bytes; + DUK_MEMMOVE((void *) lex_ctx->window, + (const void *) ((duk_uint8_t *) lex_ctx->window + count_bytes), + (size_t) keep_bytes); + + cp = (duk_lexer_codepoint *) ((duk_uint8_t *) lex_ctx->window + keep_bytes); + cp_end = lex_ctx->window + DUK_LEXER_WINDOW_SIZE; + for (; cp != cp_end; cp++) { + cp->offset = lex_ctx->input_offset; + cp->line = lex_ctx->input_line; + cp->codepoint = duk__read_char(lex_ctx); + } +} + +DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx) { + /* Call with count == DUK_LEXER_WINDOW_SIZE to fill buffer initially. */ + duk__advance_bytes(lex_ctx, DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint)); /* fill window */ +} +#endif /* DUK_USE_LEXER_SLIDING_WINDOW */ + +/* + * (Re)initialize the temporary byte buffer. May be called extra times + * with little impact. + */ + +DUK_LOCAL void duk__initbuffer(duk_lexer_ctx *lex_ctx) { + /* Reuse buffer as is unless buffer has grown large. */ + if (DUK_HBUFFER_DYNAMIC_GET_SIZE(lex_ctx->buf) < DUK_LEXER_TEMP_BUF_LIMIT) { + /* Keep current size */ + } else { + duk_hbuffer_resize(lex_ctx->thr, lex_ctx->buf, DUK_LEXER_TEMP_BUF_LIMIT); + } + + DUK_BW_INIT_WITHBUF(lex_ctx->thr, &lex_ctx->bw, lex_ctx->buf); +} + +/* + * Append a Unicode codepoint to the temporary byte buffer. Performs + * CESU-8 surrogate pair encoding for codepoints above the BMP. + * Existing surrogate pairs are allowed and also encoded into CESU-8. + */ + +DUK_LOCAL void duk__appendbuffer(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) { + /* + * Since character data is only generated by decoding the source or by + * the compiler itself, we rely on the input codepoints being correct + * and avoid a check here. + * + * Character data can also come here through decoding of Unicode + * escapes ("\udead\ubeef") so all 16-but unsigned values can be + * present, even when the source file itself is strict UTF-8. + */ + + DUK_ASSERT(x >= 0 && x <= 0x10ffff); + + DUK_BW_WRITE_ENSURE_CESU8(lex_ctx->thr, &lex_ctx->bw, (duk_ucodepoint_t) x); +} + +/* + * Intern the temporary byte buffer into a valstack slot + * (in practice, slot1 or slot2). + */ + +DUK_LOCAL void duk__internbuffer(duk_lexer_ctx *lex_ctx, duk_idx_t valstack_idx) { + duk_context *ctx = (duk_context *) lex_ctx->thr; + + DUK_ASSERT(valstack_idx == lex_ctx->slot1_idx || valstack_idx == lex_ctx->slot2_idx); + + DUK_BW_PUSH_AS_STRING(lex_ctx->thr, &lex_ctx->bw); + duk_replace(ctx, valstack_idx); +} + +/* + * Init lexer context + */ + +DUK_INTERNAL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx) { + DUK_ASSERT(lex_ctx != NULL); + + DUK_MEMZERO(lex_ctx, sizeof(*lex_ctx)); +#if defined(DUK_USE_EXPLICIT_NULL_INIT) +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) + lex_ctx->window = NULL; +#endif + lex_ctx->thr = NULL; + lex_ctx->input = NULL; + lex_ctx->buf = NULL; +#endif +} + +/* + * Set lexer input position and reinitialize lookup window. + */ + +/* NB: duk_lexer_getpoint() is a macro only */ + +DUK_INTERNAL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt) { + DUK_ASSERT_DISABLE(pt->offset >= 0); /* unsigned */ + DUK_ASSERT(pt->line >= 1); + lex_ctx->input_offset = pt->offset; + lex_ctx->input_line = pt->line; + duk__init_lexer_window(lex_ctx); +} + +/* + * Lexing helpers + */ + +/* numeric value of a hex digit (also covers octal and decimal digits) */ +DUK_LOCAL duk_codepoint_t duk__hexval(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) { + duk_small_int_t t; + + /* Here 'x' is a Unicode codepoint */ + if (DUK_LIKELY(x >= 0 && x <= 0xff)) { + t = duk_hex_dectab[x]; + if (DUK_LIKELY(t >= 0)) { + return t; + } + } + + /* Throwing an error this deep makes the error rather vague, but + * saves hundreds of bytes of code. + */ + DUK_ERROR_SYNTAX(lex_ctx->thr, "decode error"); + return 0; +} + +/* having this as a separate function provided a size benefit */ +DUK_LOCAL duk_bool_t duk__is_hex_digit(duk_codepoint_t x) { + if (DUK_LIKELY(x >= 0 && x <= 0xff)) { + return (duk_hex_dectab[x] >= 0); + } + return 0; +} + +DUK_LOCAL duk_codepoint_t duk__decode_hexesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) { + /* validation performed by duk__hexval */ + return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset].codepoint) << 4) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1].codepoint)); +} + +DUK_LOCAL duk_codepoint_t duk__decode_uniesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) { + /* validation performed by duk__hexval */ + return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset].codepoint) << 12) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1].codepoint) << 8) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 2].codepoint) << 4) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 3].codepoint)); +} + +/* + * Parse Ecmascript source InputElementDiv or InputElementRegExp + * (E5 Section 7), skipping whitespace, comments, and line terminators. + * + * Possible results are: + * (1) a token + * (2) a line terminator (skipped) + * (3) a comment (skipped) + * (4) EOF + * + * White space is automatically skipped from the current position (but + * not after the input element). If input has already ended, returns + * DUK_TOK_EOF indefinitely. If a parse error occurs, uses an DUK_ERROR() + * macro call (and hence a longjmp through current heap longjmp context). + * Comments and line terminator tokens are automatically skipped. + * + * The input element being matched is determined by regexp_mode; if set, + * parses a InputElementRegExp, otherwise a InputElementDiv. The + * difference between these are handling of productions starting with a + * forward slash. + * + * If strict_mode is set, recognizes additional future reserved words + * specific to strict mode, and refuses to parse octal literals. + * + * The matching strategy below is to (currently) use a six character + * lookup window to quickly determine which production is the -longest- + * matching one, and then parse that. The top-level if-else clauses + * match the first character, and the code blocks for each clause + * handle -all- alternatives for that first character. Ecmascript + * specification uses the "longest match wins" semantics, so the order + * of the if-clauses matters. + * + * Misc notes: + * + * * Ecmascript numeric literals do not accept a sign character. + * Consequently e.g. "-1.0" is parsed as two tokens: a negative + * sign and a positive numeric literal. The compiler performs + * the negation during compilation, so this has no adverse impact. + * + * * There is no token for "undefined": it is just a value available + * from the global object (or simply established by doing a reference + * to an undefined value). + * + * * Some contexts want Identifier tokens, which are IdentifierNames + * excluding reserved words, while some contexts want IdentifierNames + * directly. In the latter case e.g. "while" is interpreted as an + * identifier name, not a DUK_TOK_WHILE token. The solution here is + * to provide both token types: DUK_TOK_WHILE goes to 't' while + * DUK_TOK_IDENTIFIER goes to 't_nores', and 'slot1' always contains + * the identifier / keyword name. + * + * * Directive prologue needs to identify string literals such as + * "use strict" and 'use strict', which are sensitive to line + * continuations and escape sequences. For instance, "use\u0020strict" + * is a valid directive but is distinct from "use strict". The solution + * here is to decode escapes while tokenizing, but to keep track of the + * number of escapes. Directive detection can then check that the + * number of escapes is zero. + * + * * Multi-line comments with one or more internal LineTerminator are + * treated like a line terminator to comply with automatic semicolon + * insertion. + */ + +DUK_INTERNAL +void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx, + duk_token *out_token, + duk_bool_t strict_mode, + duk_bool_t regexp_mode) { + duk_codepoint_t x; /* temporary, must be signed and 32-bit to hold Unicode code points */ + duk_small_uint_t advtok = 0; /* (advance << 8) + token_type, updated at function end, + * init is unnecessary but suppresses "may be used uninitialized" warnings. + */ + duk_bool_t got_lineterm = 0; /* got lineterm preceding non-whitespace, non-lineterm token */ + + if (++lex_ctx->token_count >= lex_ctx->token_limit) { + DUK_ERROR_RANGE(lex_ctx->thr, "token limit"); + return; /* unreachable */ + } + + out_token->t = DUK_TOK_EOF; + out_token->t_nores = -1; /* marker: copy t if not changed */ +#if 0 /* not necessary to init, disabled for faster parsing */ + out_token->num = DUK_DOUBLE_NAN; + out_token->str1 = NULL; + out_token->str2 = NULL; +#endif + out_token->num_escapes = 0; + /* out_token->lineterm set by caller */ + + /* This would be nice, but parsing is faster without resetting the + * value slots. The only side effect is that references to temporary + * string values may linger until lexing is finished; they're then + * freed normally. + */ +#if 0 + duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx); +#endif + + /* 'advtok' indicates how much to advance and which token id to assign + * at the end. This shared functionality minimizes code size. All + * code paths are required to set 'advtok' to some value, so no default + * init value is used. Code paths calling DUK_ERROR() never return so + * they don't need to set advtok. + */ + + /* + * Matching order: + * + * Punctuator first chars, also covers comments, regexps + * LineTerminator + * Identifier or reserved word, also covers null/true/false literals + * NumericLiteral + * StringLiteral + * EOF + * + * The order does not matter as long as the longest match is + * always correctly identified. There are order dependencies + * in the clauses, so it's not trivial to convert to a switch. + */ + + restart_lineupdate: + out_token->start_line = lex_ctx->window[0].line; + + restart: + out_token->start_offset = lex_ctx->window[0].offset; + + x = DUK__L0(); + + switch (x) { + case DUK_ASC_SPACE: + case DUK_ASC_HT: /* fast paths for space and tab */ + DUK__ADVANCECHARS(lex_ctx, 1); + goto restart; + case DUK_ASC_LF: /* LF line terminator; CR LF and Unicode lineterms are handled in slow path */ + DUK__ADVANCECHARS(lex_ctx, 1); + got_lineterm = 1; + goto restart_lineupdate; + case DUK_ASC_SLASH: /* '/' */ + if (DUK__L1() == '/') { + /* + * E5 Section 7.4, allow SourceCharacter (which is any 16-bit + * code point). + */ + + /* DUK__ADVANCECHARS(lex_ctx, 2) would be correct here, but it unnecessary */ + for (;;) { + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + break; + } + DUK__ADVANCECHARS(lex_ctx, 1); + } + goto restart; /* line terminator will be handled on next round */ + } else if (DUK__L1() == '*') { + /* + * E5 Section 7.4. If the multi-line comment contains a newline, + * it is treated like a single line terminator for automatic + * semicolon insertion. + */ + + duk_bool_t last_asterisk = 0; + DUK__ADVANCECHARS(lex_ctx, 2); + for (;;) { + x = DUK__L0(); + if (x < 0) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "eof in multiline comment"); + } + DUK__ADVANCECHARS(lex_ctx, 1); + if (last_asterisk && x == '/') { + break; + } + if (duk_unicode_is_line_terminator(x)) { + got_lineterm = 1; + } + last_asterisk = (x == '*'); + } + goto restart_lineupdate; + } else if (regexp_mode) { +#if defined(DUK_USE_REGEXP_SUPPORT) + /* + * "/" followed by something in regexp mode. See E5 Section 7.8.5. + * + * RegExp parsing is a bit complex. First, the regexp body is delimited + * by forward slashes, but the body may also contain forward slashes as + * part of an escape sequence or inside a character class (delimited by + * square brackets). A mini state machine is used to implement these. + * + * Further, an early (parse time) error must be thrown if the regexp + * would cause a run-time error when used in the expression new RegExp(...). + * Parsing here simply extracts the (candidate) regexp, and also accepts + * invalid regular expressions (which are delimited properly). The caller + * (compiler) must perform final validation and regexp compilation. + * + * RegExp first char may not be '/' (single line comment) or '*' (multi- + * line comment). These have already been checked above, so there is no + * need below for special handling of the first regexp character as in + * the E5 productions. + * + * About unicode escapes within regexp literals: + * + * E5 Section 7.8.5 grammar does NOT accept \uHHHH escapes. + * However, Section 6 states that regexps accept the escapes, + * see paragraph starting with "In string literals...". + * The regexp grammar, which sees the decoded regexp literal + * (after lexical parsing) DOES have a \uHHHH unicode escape. + * So, for instance: + * + * /\u1234/ + * + * should first be parsed by the lexical grammar as: + * + * '\' 'u' RegularExpressionBackslashSequence + * '1' RegularExpressionNonTerminator + * '2' RegularExpressionNonTerminator + * '3' RegularExpressionNonTerminator + * '4' RegularExpressionNonTerminator + * + * and the escape itself is then parsed by the regexp engine. + * This is the current implementation. + * + * Minor spec inconsistency: + * + * E5 Section 7.8.5 RegularExpressionBackslashSequence is: + * + * \ RegularExpressionNonTerminator + * + * while Section A.1 RegularExpressionBackslashSequence is: + * + * \ NonTerminator + * + * The latter is not normative and a typo. + * + */ + + /* first, parse regexp body roughly */ + + duk_small_int_t state = 0; /* 0=base, 1=esc, 2=class, 3=class+esc */ + + DUK__INITBUFFER(lex_ctx); + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* skip opening slash on first loop */ + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in regexp"); + } + x = DUK__L0(); /* re-read to avoid spill / fetch */ + if (state == 0) { + if (x == '/') { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing slash */ + break; + } else if (x == '\\') { + state = 1; + } else if (x == '[') { + state = 2; + } + } else if (state == 1) { + state = 0; + } else if (state == 2) { + if (x == ']') { + state = 0; + } else if (x == '\\') { + state = 3; + } + } else { /* state == 3 */ + state = 2; + } + DUK__APPENDBUFFER(lex_ctx, x); + } + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + + /* second, parse flags */ + + DUK__INITBUFFER(lex_ctx); + for (;;) { + x = DUK__L0(); + if (!duk_unicode_is_identifier_part(x)) { + break; + } + x = DUK__L0(); /* re-read to avoid spill / fetch */ + DUK__APPENDBUFFER(lex_ctx, x); + DUK__ADVANCECHARS(lex_ctx, 1); + } + duk__internbuffer(lex_ctx, lex_ctx->slot2_idx); + out_token->str2 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx); + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + /* validation of the regexp is caller's responsibility */ + + advtok = DUK__ADVTOK(0, DUK_TOK_REGEXP); +#else + DUK_ERROR_SYNTAX(lex_ctx->thr, "regexp support disabled"); +#endif + } else if (DUK__L1() == '=') { + /* "/=" and not in regexp mode */ + advtok = DUK__ADVTOK(2, DUK_TOK_DIV_EQ); + } else { + /* "/" and not in regexp mode */ + advtok = DUK__ADVTOK(1, DUK_TOK_DIV); + } + break; + case DUK_ASC_LCURLY: /* '{' */ + advtok = DUK__ADVTOK(1, DUK_TOK_LCURLY); + break; + case DUK_ASC_RCURLY: /* '}' */ + advtok = DUK__ADVTOK(1, DUK_TOK_RCURLY); + break; + case DUK_ASC_LPAREN: /* '(' */ + advtok = DUK__ADVTOK(1, DUK_TOK_LPAREN); + break; + case DUK_ASC_RPAREN: /* ')' */ + advtok = DUK__ADVTOK(1, DUK_TOK_RPAREN); + break; + case DUK_ASC_LBRACKET: /* '[' */ + advtok = DUK__ADVTOK(1, DUK_TOK_LBRACKET); + break; + case DUK_ASC_RBRACKET: /* ']' */ + advtok = DUK__ADVTOK(1, DUK_TOK_RBRACKET); + break; + case DUK_ASC_PERIOD: /* '.' */ + if (DUK__ISDIGIT(DUK__L1())) { + /* Period followed by a digit can only start DecimalLiteral + * (handled in slow path). We could jump straight into the + * DecimalLiteral handling but should avoid goto to inside + * a block. + */ + goto slow_path; + } + advtok = DUK__ADVTOK(1, DUK_TOK_PERIOD); + break; + case DUK_ASC_SEMICOLON: /* ';' */ + advtok = DUK__ADVTOK(1, DUK_TOK_SEMICOLON); + break; + case DUK_ASC_COMMA: /* ',' */ + advtok = DUK__ADVTOK(1, DUK_TOK_COMMA); + break; + case DUK_ASC_LANGLE: /* '<' */ + if (DUK__L1() == '<' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_ALSHIFT_EQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_LE); + } else if (DUK__L1() == '<') { + advtok = DUK__ADVTOK(2, DUK_TOK_ALSHIFT); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_LT); + } + break; + case DUK_ASC_RANGLE: /* '>' */ + if (DUK__L1() == '>' && DUK__L2() == '>' && DUK__L3() == '=') { + advtok = DUK__ADVTOK(4, DUK_TOK_RSHIFT_EQ); + } else if (DUK__L1() == '>' && DUK__L2() == '>') { + advtok = DUK__ADVTOK(3, DUK_TOK_RSHIFT); + } else if (DUK__L1() == '>' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_ARSHIFT_EQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_GE); + } else if (DUK__L1() == '>') { + advtok = DUK__ADVTOK(2, DUK_TOK_ARSHIFT); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_GT); + } + break; + case DUK_ASC_EQUALS: /* '=' */ + if (DUK__L1() == '=' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_SEQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_EQUALSIGN); + } + break; + case DUK_ASC_EXCLAMATION: /* '!' */ + if (DUK__L1() == '=' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_SNEQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_NEQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_LNOT); + } + break; + case DUK_ASC_PLUS: /* '+' */ + if (DUK__L1() == '+') { + advtok = DUK__ADVTOK(2, DUK_TOK_INCREMENT); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_ADD_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_ADD); + } + break; + case DUK_ASC_MINUS: /* '-' */ + if (DUK__L1() == '-') { + advtok = DUK__ADVTOK(2, DUK_TOK_DECREMENT); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_SUB_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_SUB); + } + break; + case DUK_ASC_STAR: /* '*' */ + if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_MUL_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_MUL); + } + break; + case DUK_ASC_PERCENT: /* '%' */ + if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_MOD_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_MOD); + } + break; + case DUK_ASC_AMP: /* '&' */ + if (DUK__L1() == '&') { + advtok = DUK__ADVTOK(2, DUK_TOK_LAND); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_BAND_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_BAND); + } + break; + case DUK_ASC_PIPE: /* '|' */ + if (DUK__L1() == '|') { + advtok = DUK__ADVTOK(2, DUK_TOK_LOR); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_BOR_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_BOR); + } + break; + case DUK_ASC_CARET: /* '^' */ + if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_BXOR_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_BXOR); + } + break; + case DUK_ASC_TILDE: /* '~' */ + advtok = DUK__ADVTOK(1, DUK_TOK_BNOT); + break; + case DUK_ASC_QUESTION: /* '?' */ + advtok = DUK__ADVTOK(1, DUK_TOK_QUESTION); + break; + case DUK_ASC_COLON: /* ':' */ + advtok = DUK__ADVTOK(1, DUK_TOK_COLON); + break; + case DUK_ASC_DOUBLEQUOTE: /* '"' */ + case DUK_ASC_SINGLEQUOTE: { /* '\'' */ + duk_small_int_t quote = x; /* Note: duk_uint8_t type yields larger code */ + duk_small_int_t adv; + + DUK__INITBUFFER(lex_ctx); + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat opening quote on first loop */ + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in string literal"); + } + if (x == quote) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing quote */ + break; + } + if (x == '\\') { + /* DUK__L0 -> '\' char + * DUK__L1 ... DUK__L5 -> more lookup + */ + + x = DUK__L1(); + + /* How much to advance before next loop; note that next loop + * will advance by 1 anyway, so -1 from the total escape + * length (e.g. len('\uXXXX') - 1 = 6 - 1). As a default, + * 1 is good. + */ + adv = 2 - 1; /* note: long live range */ + + if (x < 0) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "eof or line terminator in string literal"); + } + if (duk_unicode_is_line_terminator(x)) { + /* line continuation */ + if (x == 0x000d && DUK__L2() == 0x000a) { + /* CR LF again a special case */ + adv = 3 - 1; + } + } else if (x == '\'') { + DUK__APPENDBUFFER(lex_ctx, 0x0027); + } else if (x == '"') { + DUK__APPENDBUFFER(lex_ctx, 0x0022); + } else if (x == '\\') { + DUK__APPENDBUFFER(lex_ctx, 0x005c); + } else if (x == 'b') { + DUK__APPENDBUFFER(lex_ctx, 0x0008); + } else if (x == 'f') { + DUK__APPENDBUFFER(lex_ctx, 0x000c); + } else if (x == 'n') { + DUK__APPENDBUFFER(lex_ctx, 0x000a); + } else if (x == 'r') { + DUK__APPENDBUFFER(lex_ctx, 0x000d); + } else if (x == 't') { + DUK__APPENDBUFFER(lex_ctx, 0x0009); + } else if (x == 'v') { + DUK__APPENDBUFFER(lex_ctx, 0x000b); + } else if (x == 'x') { + adv = 4 - 1; + DUK__APPENDBUFFER(lex_ctx, duk__decode_hexesc_from_window(lex_ctx, 2)); + } else if (x == 'u') { + adv = 6 - 1; + DUK__APPENDBUFFER(lex_ctx, duk__decode_uniesc_from_window(lex_ctx, 2)); + } else if (DUK__ISDIGIT(x)) { + duk_codepoint_t ch = 0; /* initialized to avoid warnings of unused var */ + + /* + * Octal escape or zero escape: + * \0 (lookahead not DecimalDigit) + * \1 ... \7 (lookahead not DecimalDigit) + * \ZeroToThree OctalDigit (lookahead not DecimalDigit) + * \FourToSeven OctalDigit (no lookahead restrictions) + * \ZeroToThree OctalDigit OctalDigit (no lookahead restrictions) + * + * Zero escape is part of the standard syntax. Octal escapes are + * defined in E5 Section B.1.2, and are only allowed in non-strict mode. + * Any other productions starting with a decimal digit are invalid. + */ + + if (x == '0' && !DUK__ISDIGIT(DUK__L2())) { + /* Zero escape (also allowed in non-strict mode) */ + ch = 0; + /* adv = 2 - 1 default OK */ +#if defined(DUK_USE_OCTAL_SUPPORT) + } else if (strict_mode) { + /* No other escape beginning with a digit in strict mode */ + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid escape in string literal"); + } else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(DUK__L2()) && DUK__ISOCTDIGIT(DUK__L3())) { + /* Three digit octal escape, digits validated. */ + adv = 4 - 1; + ch = (duk__hexval(lex_ctx, x) << 6) + + (duk__hexval(lex_ctx, DUK__L2()) << 3) + + duk__hexval(lex_ctx, DUK__L3()); + } else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) && + DUK__ISOCTDIGIT(DUK__L2())) { + /* Two digit octal escape, digits validated. + * + * The if-condition is a bit tricky. We could catch e.g. + * '\039' in the three-digit escape and fail it there (by + * validating the digits), but we want to avoid extra + * additional validation code. + */ + adv = 3 - 1; + ch = (duk__hexval(lex_ctx, x) << 3) + + duk__hexval(lex_ctx, DUK__L2()); + } else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(DUK__L2())) { + /* One digit octal escape, digit validated. */ + /* adv = 2 default OK */ + ch = duk__hexval(lex_ctx, x); +#else + /* fall through to error */ +#endif + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid escape in string literal"); + } + + DUK__APPENDBUFFER(lex_ctx, ch); + } else { + /* escaped NonEscapeCharacter */ + DUK__APPENDBUFFER(lex_ctx, x); + } + DUK__ADVANCECHARS(lex_ctx, adv); + + /* Track number of escapes; count not really needed but directive + * prologues need to detect whether there were any escapes or line + * continuations or not. + */ + out_token->num_escapes++; + } else { + /* part of string */ + DUK__APPENDBUFFER(lex_ctx, x); + } + } + + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + advtok = DUK__ADVTOK(0, DUK_TOK_STRING); + break; + } + default: + goto slow_path; + } /* switch */ + + goto skip_slow_path; + + slow_path: + if (duk_unicode_is_line_terminator(x)) { + if (x == 0x000d && DUK__L1() == 0x000a) { + /* + * E5 Section 7.3: CR LF is detected as a single line terminator for + * line numbers. Here we also detect it as a single line terminator + * token. + */ + DUK__ADVANCECHARS(lex_ctx, 2); + } else { + DUK__ADVANCECHARS(lex_ctx, 1); + } + got_lineterm = 1; + goto restart_lineupdate; + } else if (duk_unicode_is_identifier_start(x) || x == '\\') { + /* + * Parse an identifier and then check whether it is: + * - reserved word (keyword or other reserved word) + * - "null" (NullLiteral) + * - "true" (BooleanLiteral) + * - "false" (BooleanLiteral) + * - anything else => identifier + * + * This does not follow the E5 productions cleanly, but is + * useful and compact. + * + * Note that identifiers may contain Unicode escapes, + * see E5 Sections 6 and 7.6. They must be decoded first, + * and the result checked against allowed characters. + * The above if-clause accepts an identifier start and an + * '\' character -- no other token can begin with a '\'. + * + * Note that "get" and "set" are not reserved words in E5 + * specification so they are recognized as plain identifiers + * (the tokens DUK_TOK_GET and DUK_TOK_SET are actually not + * used now). The compiler needs to work around this. + * + * Strictly speaking, following Ecmascript longest match + * specification, an invalid escape for the first character + * should cause a syntax error. However, an invalid escape + * for IdentifierParts should just terminate the identifier + * early (longest match), and let the next tokenization + * fail. For instance Rhino croaks with 'foo\z' when + * parsing the identifier. This has little practical impact. + */ + + duk_small_int_t i, i_end; + duk_bool_t first = 1; + duk_hstring *str; + + DUK__INITBUFFER(lex_ctx); + for (;;) { + /* re-lookup first char on first loop */ + if (DUK__L0() == '\\') { + duk_codepoint_t ch; + if (DUK__L1() != 'u') { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid unicode escape in identifier"); + } + + ch = duk__decode_uniesc_from_window(lex_ctx, 2); + + /* IdentifierStart is stricter than IdentifierPart, so if the first + * character is escaped, must have a stricter check here. + */ + if (!(first ? duk_unicode_is_identifier_start(ch) : duk_unicode_is_identifier_part(ch))) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid unicode escape in identifier"); + } + DUK__APPENDBUFFER(lex_ctx, ch); + DUK__ADVANCECHARS(lex_ctx, 6); + + /* Track number of escapes: necessary for proper keyword + * detection. + */ + out_token->num_escapes++; + } else { + /* Note: first character is checked against this. But because + * IdentifierPart includes all IdentifierStart characters, and + * the first character (if unescaped) has already been checked + * in the if condition, this is OK. + */ + if (!duk_unicode_is_identifier_part(DUK__L0())) { + break; + } + DUK__APPENDBUFFER(lex_ctx, DUK__L0()); + DUK__ADVANCECHARS(lex_ctx, 1); + } + first = 0; + } + + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + str = out_token->str1; + DUK_ASSERT(str != NULL); + out_token->t_nores = DUK_TOK_IDENTIFIER; + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + /* + * Interned identifier is compared against reserved words, which are + * currently interned into the heap context. See genbuiltins.py. + * + * Note that an escape in the identifier disables recognition of + * keywords; e.g. "\u0069f = 1;" is a valid statement (assigns to + * identifier named "if"). This is not necessarily compliant, + * see test-dec-escaped-char-in-keyword.js. + * + * Note: "get" and "set" are awkward. They are not officially + * ReservedWords (and indeed e.g. "var set = 1;" is valid), and + * must come out as DUK_TOK_IDENTIFIER. The compiler needs to + * work around this a bit. + */ + + /* XXX: optimize by adding the token numbers directly into the + * always interned duk_hstring objects (there should be enough + * flag bits free for that)? + */ + + i_end = (strict_mode ? DUK_STRIDX_END_RESERVED : DUK_STRIDX_START_STRICT_RESERVED); + + advtok = DUK__ADVTOK(0, DUK_TOK_IDENTIFIER); + if (out_token->num_escapes == 0) { + for (i = DUK_STRIDX_START_RESERVED; i < i_end; i++) { + DUK_ASSERT(i >= 0 && i < DUK_HEAP_NUM_STRINGS); + if (DUK_HTHREAD_GET_STRING(lex_ctx->thr, i) == str) { + advtok = DUK__ADVTOK(0, DUK_STRIDX_TO_TOK(i)); + break; + } + } + } + } else if (DUK__ISDIGIT(x) || (x == '.')) { + /* Note: decimal number may start with a period, but must be followed by a digit */ + + /* + * DecimalLiteral, HexIntegerLiteral, OctalIntegerLiteral + * "pre-parsing", followed by an actual, accurate parser step. + * + * Note: the leading sign character ('+' or '-') is -not- part of + * the production in E5 grammar, and that the a DecimalLiteral + * starting with a '0' must be followed by a non-digit. Leading + * zeroes are syntax errors and must be checked for. + * + * XXX: the two step parsing process is quite awkward, it would + * be more straightforward to allow numconv to parse the longest + * valid prefix (it already does that, it only needs to indicate + * where the input ended). However, the lexer decodes characters + * using a lookup window, so this is not a trivial change. + */ + + /* XXX: because of the final check below (that the literal is not + * followed by a digit), this could maybe be simplified, if we bail + * out early from a leading zero (and if there are no periods etc). + * Maybe too complex. + */ + + duk_double_t val; + duk_bool_t int_only = 0; + duk_bool_t allow_hex = 0; + duk_small_int_t state; /* 0=before period/exp, + * 1=after period, before exp + * 2=after exp, allow '+' or '-' + * 3=after exp and exp sign + */ + duk_small_uint_t s2n_flags; + duk_codepoint_t y; + + DUK__INITBUFFER(lex_ctx); + y = DUK__L1(); + if (x == '0' && (y == 'x' || y == 'X')) { + DUK__APPENDBUFFER(lex_ctx, x); + DUK__APPENDBUFFER(lex_ctx, y); + DUK__ADVANCECHARS(lex_ctx, 2); + int_only = 1; + allow_hex = 1; +#if defined(DUK_USE_OCTAL_SUPPORT) + } else if (!strict_mode && x == '0' && DUK__ISDIGIT(y)) { + /* Note: if DecimalLiteral starts with a '0', it can only be + * followed by a period or an exponent indicator which starts + * with 'e' or 'E'. Hence the if-check above ensures that + * OctalIntegerLiteral is the only valid NumericLiteral + * alternative at this point (even if y is, say, '9'). + */ + + DUK__APPENDBUFFER(lex_ctx, x); + DUK__ADVANCECHARS(lex_ctx, 1); + int_only = 1; +#endif + } + + state = 0; + for (;;) { + x = DUK__L0(); /* re-lookup curr char on first round */ + if (DUK__ISDIGIT(x)) { + /* Note: intentionally allow leading zeroes here, as the + * actual parser will check for them. + */ + if (state == 2) { + state = 3; + } + } else if (allow_hex && DUK__ISHEXDIGIT(x)) { + /* Note: 'e' and 'E' are also accepted here. */ + ; + } else if (x == '.') { + if (state >= 1 || int_only) { + break; + } else { + state = 1; + } + } else if (x == 'e' || x == 'E') { + if (state >= 2 || int_only) { + break; + } else { + state = 2; + } + } else if (x == '-' || x == '+') { + if (state != 2) { + break; + } else { + state = 3; + } + } else { + break; + } + DUK__APPENDBUFFER(lex_ctx, x); + DUK__ADVANCECHARS(lex_ctx, 1); + } + + /* XXX: better coercion */ + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + + s2n_flags = DUK_S2N_FLAG_ALLOW_EXP | + DUK_S2N_FLAG_ALLOW_FRAC | + DUK_S2N_FLAG_ALLOW_NAKED_FRAC | + DUK_S2N_FLAG_ALLOW_EMPTY_FRAC | +#if defined(DUK_USE_OCTAL_SUPPORT) + (strict_mode ? 0 : DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) | +#endif + DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT; + + duk_dup((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + duk_numconv_parse((duk_context *) lex_ctx->thr, 10 /*radix*/, s2n_flags); + val = duk_to_number((duk_context *) lex_ctx->thr, -1); + if (DUK_ISNAN(val)) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid numeric literal"); + } + duk_replace((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); /* could also just pop? */ + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + /* Section 7.8.3 (note): NumericLiteral must be followed by something other than + * IdentifierStart or DecimalDigit. + */ + + if (DUK__ISDIGIT(DUK__L0()) || duk_unicode_is_identifier_start(DUK__L0())) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid numeric literal"); + } + + out_token->num = val; + advtok = DUK__ADVTOK(0, DUK_TOK_NUMBER); + } else if (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) { + DUK__ADVANCECHARS(lex_ctx, 1); + goto restart; + } else if (x < 0) { + advtok = DUK__ADVTOK(0, DUK_TOK_EOF); + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid token"); + } + skip_slow_path: + + /* + * Shared exit path + */ + + DUK__ADVANCEBYTES(lex_ctx, advtok >> 8); + out_token->t = advtok & 0xff; + if (out_token->t_nores < 0) { + out_token->t_nores = out_token->t; + } + out_token->lineterm = got_lineterm; + + /* Automatic semicolon insertion is allowed if a token is preceded + * by line terminator(s), or terminates a statement list (right curly + * or EOF). + */ + if (got_lineterm || out_token->t == DUK_TOK_RCURLY || out_token->t == DUK_TOK_EOF) { + out_token->allow_auto_semi = 1; + } else { + out_token->allow_auto_semi = 0; + } +} + +#if defined(DUK_USE_REGEXP_SUPPORT) + +/* + * Parse a RegExp token. The grammar is described in E5 Section 15.10. + * Terminal constructions (such as quantifiers) are parsed directly here. + * + * 0xffffffffU is used as a marker for "infinity" in quantifiers. Further, + * DUK__MAX_RE_QUANT_DIGITS limits the maximum number of digits that + * will be accepted for a quantifier. + */ + +DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token) { + duk_small_int_t advtok = 0; /* init is unnecessary but suppresses "may be used uninitialized" warnings */ + duk_codepoint_t x, y; + + if (++lex_ctx->token_count >= lex_ctx->token_limit) { + DUK_ERROR_RANGE(lex_ctx->thr, "token limit"); + return; /* unreachable */ + } + + DUK_MEMZERO(out_token, sizeof(*out_token)); + + x = DUK__L0(); + y = DUK__L1(); + + DUK_DDD(DUK_DDDPRINT("parsing regexp token, L0=%ld, L1=%ld", (long) x, (long) y)); + + switch (x) { + case '|': { + advtok = DUK__ADVTOK(1, DUK_RETOK_DISJUNCTION); + break; + } + case '^': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_START); + break; + } + case '$': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_END); + break; + } + case '?': { + out_token->qmin = 0; + out_token->qmax = 1; + if (y == '?') { + advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER); + out_token->greedy = 0; + } else { + advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER); + out_token->greedy = 1; + } + break; + } + case '*': { + out_token->qmin = 0; + out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; + if (y == '?') { + advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER); + out_token->greedy = 0; + } else { + advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER); + out_token->greedy = 1; + } + break; + } + case '+': { + out_token->qmin = 1; + out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; + if (y == '?') { + advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER); + out_token->greedy = 0; + } else { + advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER); + out_token->greedy = 1; + } + break; + } + case '{': { + /* Production allows 'DecimalDigits', including leading zeroes */ + duk_uint_fast32_t val1 = 0; + duk_uint_fast32_t val2 = DUK_RE_QUANTIFIER_INFINITE; + duk_small_int_t digits = 0; +#if defined(DUK_USE_ES6_REGEXP_BRACES) + duk_lexer_point lex_pt; +#endif + +#if defined(DUK_USE_ES6_REGEXP_BRACES) + /* Store lexer position, restoring if quantifier is invalid. */ + DUK_LEXER_GETPOINT(lex_ctx, &lex_pt); +#endif + + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat '{' on entry */ + x = DUK__L0(); + if (DUK__ISDIGIT(x)) { + digits++; + val1 = val1 * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x); + } else if (x == ',') { + if (digits > DUK__MAX_RE_QUANT_DIGITS) { + goto invalid_quantifier; + } + if (val2 != DUK_RE_QUANTIFIER_INFINITE) { + goto invalid_quantifier; + } + if (DUK__L1() == '}') { + /* form: { DecimalDigits , }, val1 = min count */ + if (digits == 0) { + goto invalid_quantifier; + } + out_token->qmin = val1; + out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; + DUK__ADVANCECHARS(lex_ctx, 2); + break; + } + val2 = val1; + val1 = 0; + digits = 0; /* not strictly necessary because of lookahead '}' above */ + } else if (x == '}') { + if (digits > DUK__MAX_RE_QUANT_DIGITS) { + goto invalid_quantifier; + } + if (digits == 0) { + goto invalid_quantifier; + } + if (val2 != DUK_RE_QUANTIFIER_INFINITE) { + /* val2 = min count, val1 = max count */ + out_token->qmin = val2; + out_token->qmax = val1; + } else { + /* val1 = count */ + out_token->qmin = val1; + out_token->qmax = val1; + } + DUK__ADVANCECHARS(lex_ctx, 1); + break; + } else { + goto invalid_quantifier; + } + } + if (DUK__L0() == '?') { + out_token->greedy = 0; + DUK__ADVANCECHARS(lex_ctx, 1); + } else { + out_token->greedy = 1; + } + advtok = DUK__ADVTOK(0, DUK_RETOK_QUANTIFIER); + break; + invalid_quantifier: +#if defined(DUK_USE_ES6_REGEXP_BRACES) + /* Failed to match the quantifier, restore lexer and parse + * opening brace as a literal. + */ + DUK_LEXER_SETPOINT(lex_ctx, &lex_pt); + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_CHAR); + out_token->num = '{'; +#else + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp quantifier"); +#endif + break; + } + case '.': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_PERIOD); + break; + } + case '\\': { + /* The E5.1 specification does not seem to allow IdentifierPart characters + * to be used as identity escapes. Unfortunately this includes '$', which + * cannot be escaped as '\$'; it needs to be escaped e.g. as '\u0024'. + * Many other implementations (including V8 and Rhino, for instance) do + * accept '\$' as a valid identity escape, which is quite pragmatic. + * See: test-regexp-identity-escape-dollar.js. + */ + + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR); /* default: char escape (two chars) */ + if (y == 'b') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_WORD_BOUNDARY); + } else if (y == 'B') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY); + } else if (y == 'f') { + out_token->num = 0x000c; + } else if (y == 'n') { + out_token->num = 0x000a; + } else if (y == 't') { + out_token->num = 0x0009; + } else if (y == 'r') { + out_token->num = 0x000d; + } else if (y == 'v') { + out_token->num = 0x000b; + } else if (y == 'c') { + x = DUK__L2(); + if ((x >= 'a' && x <= 'z') || + (x >= 'A' && x <= 'Z')) { + out_token->num = (x % 32); + advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_CHAR); + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + } + } else if (y == 'x') { + out_token->num = duk__decode_hexesc_from_window(lex_ctx, 2); + advtok = DUK__ADVTOK(4, DUK_RETOK_ATOM_CHAR); + } else if (y == 'u') { + out_token->num = duk__decode_uniesc_from_window(lex_ctx, 2); + advtok = DUK__ADVTOK(6, DUK_RETOK_ATOM_CHAR); + } else if (y == 'd') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_DIGIT); + } else if (y == 'D') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_DIGIT); + } else if (y == 's') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WHITE); + } else if (y == 'S') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WHITE); + } else if (y == 'w') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WORD_CHAR); + } else if (y == 'W') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WORD_CHAR); + } else if (DUK__ISDIGIT(y)) { + /* E5 Section 15.10.2.11 */ + if (y == '0') { + if (DUK__ISDIGIT(DUK__L2())) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + } + out_token->num = 0x0000; + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR); + } else { + /* XXX: shared parsing? */ + duk_uint_fast32_t val = 0; + duk_small_int_t i; + for (i = 0; ; i++) { + if (i >= DUK__MAX_RE_DECESC_DIGITS) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + } + DUK__ADVANCECHARS(lex_ctx, 1); /* eat backslash on entry */ + x = DUK__L0(); + if (!DUK__ISDIGIT(x)) { + break; + } + val = val * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x); + } + /* DUK__L0() cannot be a digit, because the loop doesn't terminate if it is */ + advtok = DUK__ADVTOK(0, DUK_RETOK_ATOM_BACKREFERENCE); + out_token->num = val; + } + } else if ((y >= 0 && !duk_unicode_is_identifier_part(y)) || +#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE) + y == '$' || +#endif + y == DUK_UNICODE_CP_ZWNJ || + y == DUK_UNICODE_CP_ZWJ) { + /* IdentityEscape, with dollar added as a valid additional + * non-standard escape (see test-regexp-identity-escape-dollar.js). + * Careful not to match end-of-buffer (<0) here. + */ + out_token->num = y; + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + } + break; + } + case '(': { + /* XXX: naming is inconsistent: ATOM_END_GROUP ends an ASSERT_START_LOOKAHEAD */ + + if (y == '?') { + if (DUK__L2() == '=') { + /* (?= */ + advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_POS_LOOKAHEAD); + } else if (DUK__L2() == '!') { + /* (?! */ + advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD); + } else if (DUK__L2() == ':') { + /* (?: */ + advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_START_NONCAPTURE_GROUP); + } + } else { + /* ( */ + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CAPTURE_GROUP); + } + break; + } + case ')': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_END_GROUP); + break; + } + case '[': { + /* + * To avoid creating a heavy intermediate value for the list of ranges, + * only the start token ('[' or '[^') is parsed here. The regexp + * compiler parses the ranges itself. + */ + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CHARCLASS); + if (y == '^') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_START_CHARCLASS_INVERTED); + } + break; + } +#if !defined(DUK_USE_ES6_REGEXP_BRACES) + case '}': +#endif + case ']': { + /* Although these could be parsed as PatternCharacters unambiguously (here), + * E5 Section 15.10.1 grammar explicitly forbids these as PatternCharacters. + */ + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp character"); + break; + } + case -1: { + /* EOF */ + advtok = DUK__ADVTOK(0, DUK_TOK_EOF); + break; + } + default: { + /* PatternCharacter, all excluded characters are matched by cases above */ + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_CHAR); + out_token->num = x; + break; + } + } + + /* + * Shared exit path + */ + + DUK__ADVANCEBYTES(lex_ctx, advtok >> 8); + out_token->t = advtok & 0xff; +} + +/* + * Special parser for character classes; calls callback for every + * range parsed and returns the number of ranges present. + */ + +/* XXX: this duplicates functionality in duk_regexp.c where a similar loop is + * required anyway. We could use that BUT we need to update the regexp compiler + * 'nranges' too. Work this out a bit more cleanly to save space. + */ + +/* XXX: the handling of character range detection is a bit convoluted. + * Try to simplify and make smaller. + */ + +/* XXX: logic for handling character ranges is now incorrect, it will accept + * e.g. [\d-z] whereas it should croak from it? SMJS accepts this too, though. + * + * Needs a read through and a lot of additional tests. + */ + +DUK_LOCAL +void duk__emit_u16_direct_ranges(duk_lexer_ctx *lex_ctx, + duk_re_range_callback gen_range, + void *userdata, + const duk_uint16_t *ranges, + duk_small_int_t num) { + const duk_uint16_t *ranges_end; + + DUK_UNREF(lex_ctx); + + ranges_end = ranges + num; + while (ranges < ranges_end) { + /* mark range 'direct', bypass canonicalization (see Wiki) */ + gen_range(userdata, (duk_codepoint_t) ranges[0], (duk_codepoint_t) ranges[1], 1); + ranges += 2; + } +} + +DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata) { + duk_codepoint_t start = -1; + duk_codepoint_t ch; + duk_codepoint_t x; + duk_bool_t dash = 0; + + DUK_DD(DUK_DDPRINT("parsing regexp ranges")); + + for (;;) { + x = DUK__L0(); + DUK__ADVANCECHARS(lex_ctx, 1); + + ch = -1; /* not strictly necessary, but avoids "uninitialized variable" warnings */ + DUK_UNREF(ch); + + if (x < 0) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "eof in character class"); + } else if (x == ']') { + DUK_ASSERT(!dash); /* lookup should prevent this */ + if (start >= 0) { + gen_range(userdata, start, start, 0); + } + break; + } else if (x == '-') { + if (start >= 0 && !dash && DUK__L0() != ']') { + /* '-' as a range indicator */ + dash = 1; + continue; + } else { + /* '-' verbatim */ + ch = x; + } + } else if (x == '\\') { + /* + * The escapes are same as outside a character class, except that \b has a + * different meaning, and \B and backreferences are prohibited (see E5 + * Section 15.10.2.19). However, it's difficult to share code because we + * handle e.g. "\n" very differently: here we generate a single character + * range for it. + */ + + x = DUK__L0(); + DUK__ADVANCECHARS(lex_ctx, 1); + + if (x == 'b') { + /* Note: '\b' in char class is different than outside (assertion), + * '\B' is not allowed and is caught by the duk_unicode_is_identifier_part() + * check below. + */ + ch = 0x0008; + } else if (x == 'f') { + ch = 0x000c; + } else if (x == 'n') { + ch = 0x000a; + } else if (x == 't') { + ch = 0x0009; + } else if (x == 'r') { + ch = 0x000d; + } else if (x == 'v') { + ch = 0x000b; + } else if (x == 'c') { + x = DUK__L0(); + DUK__ADVANCECHARS(lex_ctx, 1); + if ((x >= 'a' && x <= 'z') || + (x >= 'A' && x <= 'Z')) { + ch = (x % 32); + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + return; /* never reached, but avoids warnings of + * potentially unused variables. + */ + } + } else if (x == 'x') { + ch = duk__decode_hexesc_from_window(lex_ctx, 0); + DUK__ADVANCECHARS(lex_ctx, 2); + } else if (x == 'u') { + ch = duk__decode_uniesc_from_window(lex_ctx, 0); + DUK__ADVANCECHARS(lex_ctx, 4); + } else if (x == 'd') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_digit, + sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'D') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_not_digit, + sizeof(duk_unicode_re_ranges_not_digit) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 's') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_white, + sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'S') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_not_white, + sizeof(duk_unicode_re_ranges_not_white) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'w') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_wordchar, + sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'W') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_not_wordchar, + sizeof(duk_unicode_re_ranges_not_wordchar) / sizeof(duk_uint16_t)); + ch = -1; + } else if (DUK__ISDIGIT(x)) { + /* DecimalEscape, only \0 is allowed, no leading zeroes are allowed */ + if (x == '0' && !DUK__ISDIGIT(DUK__L0())) { + ch = 0x0000; + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + } + } else if (!duk_unicode_is_identifier_part(x) +#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE) + || x == '$' +#endif + ) { + /* IdentityEscape */ + ch = x; + } else { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid regexp escape"); + } + } else { + /* character represents itself */ + ch = x; + } + + /* ch is a literal character here or -1 if parsed entity was + * an escape such as "\s". + */ + + if (ch < 0) { + /* multi-character sets not allowed as part of ranges, see + * E5 Section 15.10.2.15, abstract operation CharacterRange. + */ + if (start >= 0) { + if (dash) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid range"); + } else { + gen_range(userdata, start, start, 0); + start = -1; + /* dash is already 0 */ + } + } + } else { + if (start >= 0) { + if (dash) { + if (start > ch) { + DUK_ERROR_SYNTAX(lex_ctx->thr, "invalid range"); + } + gen_range(userdata, start, ch, 0); + start = -1; + dash = 0; + } else { + gen_range(userdata, start, start, 0); + start = ch; + /* dash is already 0 */ + } + } else { + start = ch; + } + } + } + + return; +} + +#endif /* DUK_USE_REGEXP_SUPPORT */ |