nifi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ald...@apache.org
Subject [09/51] [abbrv] [partial] nifi-minifi-cpp git commit: MINIFI-293 Remove thirdparty dependencies no longer utilized inclusive of libxml2 and all of civetweb thirdparty
Date Thu, 04 May 2017 19:10:17 GMT
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_js_compiler.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_js_compiler.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_js_compiler.c
deleted file mode 100644
index 3983c7c..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_js_compiler.c
+++ /dev/null
@@ -1,7865 +0,0 @@
-/*
- *  Ecmascript compiler.
- *
- *  Parses an input string and generates a function template result.
- *  Compilation may happen in multiple contexts (global code, eval
- *  code, function code).
- *
- *  The parser uses a traditional top-down recursive parsing for the
- *  statement level, and an operator precedence based top-down approach
- *  for the expression level.  The attempt is to minimize the C stack
- *  depth.  Bytecode is generated directly without an intermediate
- *  representation (tree), at the cost of needing two passes over each
- *  function.
- *
- *  The top-down recursive parser functions are named "duk__parse_XXX".
- *
- *  Recursion limits are in key functions to prevent arbitrary C recursion:
- *  function body parsing, statement parsing, and expression parsing.
- *
- *  See doc/compiler.rst for discussion on the design.
- *
- *  A few typing notes:
- *
- *    - duk_regconst_t: unsigned, no marker value for "none"
- *    - duk_reg_t: signed, < 0 = none
- *    - PC values: duk_int_t, negative values used as markers
- */
-
-#include "duk_internal.h"
-
-/* if highest bit of a register number is set, it refers to a constant instead */
-#define DUK__CONST_MARKER                 DUK_JS_CONST_MARKER
-
-/* for array and object literals */
-#define DUK__MAX_ARRAY_INIT_VALUES        20
-#define DUK__MAX_OBJECT_INIT_PAIRS        10
-
-/* XXX: hack, remove when const lookup is not O(n) */
-#define DUK__GETCONST_MAX_CONSTS_CHECK    256
-
-/* These limits are based on bytecode limits.  Max temps is limited
- * by duk_hcompiledfunction nargs/nregs fields being 16 bits.
- */
-#define DUK__MAX_CONSTS                   DUK_BC_BC_MAX
-#define DUK__MAX_FUNCS                    DUK_BC_BC_MAX
-#define DUK__MAX_TEMPS                    0xffffL
-
-/* Initial bytecode size allocation. */
-#define DUK__BC_INITIAL_INSTS 256
-
-#define DUK__RECURSION_INCREASE(comp_ctx,thr)  do { \
-		DUK_DDD(DUK_DDDPRINT("RECURSION INCREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \
-		duk__recursion_increase((comp_ctx)); \
-	} while (0)
-
-#define DUK__RECURSION_DECREASE(comp_ctx,thr)  do { \
-		DUK_DDD(DUK_DDDPRINT("RECURSION DECREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \
-		duk__recursion_decrease((comp_ctx)); \
-	} while (0)
-
-/* Value stack slot limits: these are quite approximate right now, and
- * because they overlap in control flow, some could be eliminated.
- */
-#define DUK__COMPILE_ENTRY_SLOTS          8
-#define DUK__FUNCTION_INIT_REQUIRE_SLOTS  16
-#define DUK__FUNCTION_BODY_REQUIRE_SLOTS  16
-#define DUK__PARSE_STATEMENTS_SLOTS       16
-#define DUK__PARSE_EXPR_SLOTS             16
-
-/* Temporary structure used to pass a stack allocated region through
- * duk_safe_call().
- */
-typedef struct {
-	duk_small_uint_t flags;
-	duk_compiler_ctx comp_ctx_alloc;
-	duk_lexer_point lex_pt_alloc;
-} duk__compiler_stkstate;
-
-/*
- *  Prototypes
- */
-
-/* lexing */
-DUK_LOCAL_DECL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect);
-DUK_LOCAL_DECL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect);
-DUK_LOCAL_DECL void duk__advance(duk_compiler_ctx *ctx);
-
-/* function helpers */
-DUK_LOCAL_DECL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg);
-DUK_LOCAL_DECL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind);
-DUK_LOCAL_DECL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx);
-
-/* code emission */
-DUK_LOCAL_DECL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc);
-DUK_LOCAL_DECL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins);
-#if 0  /* unused */
-DUK_LOCAL_DECL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op);
-#endif
-DUK_LOCAL_DECL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c);
-DUK_LOCAL_DECL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b);
-#if 0  /* unused */
-DUK_LOCAL_DECL void duk__emit_a(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a);
-#endif
-DUK_LOCAL_DECL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc);
-DUK_LOCAL_DECL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc);
-DUK_LOCAL_DECL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c);
-DUK_LOCAL_DECL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b);
-DUK_LOCAL_DECL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc);
-DUK_LOCAL_DECL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags);
-DUK_LOCAL_DECL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val);
-DUK_LOCAL_DECL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val);
-DUK_LOCAL_DECL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc);
-DUK_LOCAL_DECL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc);
-DUK_LOCAL_DECL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc);
-DUK_LOCAL_DECL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc);
-DUK_LOCAL_DECL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags);
-DUK_LOCAL_DECL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst);
-DUK_LOCAL_DECL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst);
-DUK_LOCAL_DECL void duk__emit_invalid(duk_compiler_ctx *comp_ctx);
-
-/* ivalue/ispec helpers */
-DUK_LOCAL_DECL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst);
-DUK_LOCAL_DECL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst);
-DUK_LOCAL_DECL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival);
-DUK_LOCAL_DECL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num);
-DUK_LOCAL_DECL duk_reg_t duk__alloctemp(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next);
-DUK_LOCAL_DECL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL
-duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx,
-                                         duk_ispec *x,
-                                         duk_reg_t forced_reg,
-                                         duk_small_uint_t flags);
-DUK_LOCAL_DECL void duk__ispec_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ispec *x, duk_reg_t forced_reg);
-DUK_LOCAL_DECL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg);
-DUK_LOCAL_DECL void duk__ivalue_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-DUK_LOCAL_DECL void duk__ivalue_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-DUK_LOCAL_DECL
-duk_regconst_t duk__ivalue_toregconst_raw(duk_compiler_ctx *comp_ctx,
-                                          duk_ivalue *x,
-                                          duk_reg_t forced_reg,
-                                          duk_small_uint_t flags);
-DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-#if 0  /* unused */
-DUK_LOCAL_DECL duk_reg_t duk__ivalue_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-#endif
-DUK_LOCAL_DECL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg);
-DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-DUK_LOCAL_DECL duk_regconst_t duk__ivalue_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-
-/* identifier handling */
-DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname);
-
-/* label handling */
-DUK_LOCAL_DECL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id);
-DUK_LOCAL_DECL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags);
-DUK_LOCAL_DECL void duk__lookup_active_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_bool_t is_break, duk_int_t *out_label_id, duk_int_t *out_label_catch_depth, duk_int_t *out_label_pc, duk_bool_t *out_is_closest);
-DUK_LOCAL_DECL void duk__reset_labels_to_length(duk_compiler_ctx *comp_ctx, duk_int_t len);
-
-/* top-down expression parser */
-DUK_LOCAL_DECL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res);
-DUK_LOCAL_DECL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL duk_bool_t duk__expr_is_empty(duk_compiler_ctx *comp_ctx);
-
-/* exprtop is the top level variant which resets nud/led counts */
-DUK_LOCAL_DECL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-DUK_LOCAL_DECL void duk__exprtop(duk_compiler_ctx *ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-
-/* convenience helpers */
-#if 0  /* unused */
-DUK_LOCAL_DECL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#endif
-#if 0  /* unused */
-DUK_LOCAL_DECL duk_reg_t duk__expr_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#endif
-DUK_LOCAL_DECL void duk__expr_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg);
-DUK_LOCAL_DECL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#if 0  /* unused */
-DUK_LOCAL_DECL duk_regconst_t duk__expr_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#endif
-DUK_LOCAL_DECL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-DUK_LOCAL_DECL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-DUK_LOCAL_DECL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#if 0  /* unused */
-DUK_LOCAL_DECL duk_reg_t duk__exprtop_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#endif
-DUK_LOCAL_DECL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg);
-DUK_LOCAL_DECL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#if 0  /* unused */
-DUK_LOCAL_DECL void duk__exprtop_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-#endif
-
-/* expression parsing helpers */
-DUK_LOCAL_DECL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__nud_array_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags);
-
-/* statement parsing */
-DUK_LOCAL_DECL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname);
-DUK_LOCAL_DECL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags);
-DUK_LOCAL_DECL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-DUK_LOCAL_DECL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-DUK_LOCAL_DECL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-DUK_LOCAL_DECL void duk__parse_while_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-DUK_LOCAL_DECL void duk__parse_break_or_continue_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__parse_throw_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-DUK_LOCAL_DECL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem);
-DUK_LOCAL_DECL duk_int_t duk__stmt_label_site(duk_compiler_ctx *comp_ctx, duk_int_t label_id);
-DUK_LOCAL_DECL void duk__parse_stmts(duk_compiler_ctx *comp_ctx, duk_bool_t allow_source_elem, duk_bool_t expect_eof);
-
-DUK_LOCAL_DECL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token);
-DUK_LOCAL_DECL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx);
-DUK_LOCAL_DECL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget);
-DUK_LOCAL_DECL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget);
-
-/*
- *  Parser control values for tokens.  The token table is ordered by the
- *  DUK_TOK_XXX defines.
- *
- *  The binding powers are for lbp() use (i.e. for use in led() context).
- *  Binding powers are positive for typing convenience, and bits at the
- *  top should be reserved for flags.  Binding power step must be higher
- *  than 1 so that binding power "lbp - 1" can be used for right associative
- *  operators.  Currently a step of 2 is used (which frees one more bit for
- *  flags).
- */
-
-/* XXX: actually single step levels would work just fine, clean up */
-
-/* binding power "levels" (see doc/compiler.rst) */
-#define DUK__BP_INVALID                0             /* always terminates led() */
-#define DUK__BP_EOF                    2
-#define DUK__BP_CLOSING                4             /* token closes expression, e.g. ')', ']' */
-#define DUK__BP_FOR_EXPR               DUK__BP_CLOSING    /* bp to use when parsing a top level Expression */
-#define DUK__BP_COMMA                  6
-#define DUK__BP_ASSIGNMENT             8
-#define DUK__BP_CONDITIONAL            10
-#define DUK__BP_LOR                    12
-#define DUK__BP_LAND                   14
-#define DUK__BP_BOR                    16
-#define DUK__BP_BXOR                   18
-#define DUK__BP_BAND                   20
-#define DUK__BP_EQUALITY               22
-#define DUK__BP_RELATIONAL             24
-#define DUK__BP_SHIFT                  26
-#define DUK__BP_ADDITIVE               28
-#define DUK__BP_MULTIPLICATIVE         30
-#define DUK__BP_POSTFIX                32
-#define DUK__BP_CALL                   34
-#define DUK__BP_MEMBER                 36
-
-#define DUK__TOKEN_LBP_BP_MASK         0x1f
-#define DUK__TOKEN_LBP_FLAG_NO_REGEXP  (1 << 5)   /* regexp literal must not follow this token */
-#define DUK__TOKEN_LBP_FLAG_TERMINATES (1 << 6)   /* terminates expression; e.g. post-increment/-decrement */
-#define DUK__TOKEN_LBP_FLAG_UNUSED     (1 << 7)   /* spare */
-
-#define DUK__TOKEN_LBP_GET_BP(x)       ((duk_small_uint_t) (((x) & DUK__TOKEN_LBP_BP_MASK) * 2))
-
-#define DUK__MK_LBP(bp)                ((bp) >> 1)    /* bp is assumed to be even */
-#define DUK__MK_LBP_FLAGS(bp,flags)    (((bp) >> 1) | (flags))
-
-DUK_LOCAL const duk_uint8_t duk__token_lbp[] = {
-	DUK__MK_LBP(DUK__BP_EOF),                                 /* DUK_TOK_EOF */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_IDENTIFIER */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_BREAK */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CASE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CATCH */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CONTINUE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DEBUGGER */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DEFAULT */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DELETE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DO */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_ELSE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FINALLY */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FOR */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FUNCTION */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IF */
-	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_IN */
-	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_INSTANCEOF */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_NEW */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_RETURN */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SWITCH */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_THIS */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_THROW */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_TRY */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_TYPEOF */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_VAR */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CONST */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_VOID */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_WHILE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_WITH */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CLASS */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_ENUM */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_EXPORT */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_EXTENDS */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IMPORT */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SUPER */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_NULL */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_TRUE */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_FALSE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_GET */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SET */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IMPLEMENTS */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_INTERFACE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LET */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PACKAGE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PRIVATE */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PROTECTED */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PUBLIC */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_STATIC */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_YIELD */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LCURLY */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RCURLY */
-	DUK__MK_LBP(DUK__BP_MEMBER),                              /* DUK_TOK_LBRACKET */
-	DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RBRACKET */
-	DUK__MK_LBP(DUK__BP_CALL),                                /* DUK_TOK_LPAREN */
-	DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RPAREN */
-	DUK__MK_LBP(DUK__BP_MEMBER),                              /* DUK_TOK_PERIOD */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SEMICOLON */
-	DUK__MK_LBP(DUK__BP_COMMA),                               /* DUK_TOK_COMMA */
-	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_LT */
-	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_GT */
-	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_LE */
-	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_GE */
-	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_EQ */
-	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_NEQ */
-	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_SEQ */
-	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_SNEQ */
-	DUK__MK_LBP(DUK__BP_ADDITIVE),                            /* DUK_TOK_ADD */
-	DUK__MK_LBP(DUK__BP_ADDITIVE),                            /* DUK_TOK_SUB */
-	DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_MUL */
-	DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_DIV */
-	DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_MOD */
-	DUK__MK_LBP(DUK__BP_POSTFIX),                             /* DUK_TOK_INCREMENT */
-	DUK__MK_LBP(DUK__BP_POSTFIX),                             /* DUK_TOK_DECREMENT */
-	DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_ALSHIFT */
-	DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_ARSHIFT */
-	DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_RSHIFT */
-	DUK__MK_LBP(DUK__BP_BAND),                                /* DUK_TOK_BAND */
-	DUK__MK_LBP(DUK__BP_BOR),                                 /* DUK_TOK_BOR */
-	DUK__MK_LBP(DUK__BP_BXOR),                                /* DUK_TOK_BXOR */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LNOT */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_BNOT */
-	DUK__MK_LBP(DUK__BP_LAND),                                /* DUK_TOK_LAND */
-	DUK__MK_LBP(DUK__BP_LOR),                                 /* DUK_TOK_LOR */
-	DUK__MK_LBP(DUK__BP_CONDITIONAL),                         /* DUK_TOK_QUESTION */
-	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_COLON */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_EQUALSIGN */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_ADD_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_SUB_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_MUL_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_DIV_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_MOD_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_ALSHIFT_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_ARSHIFT_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_RSHIFT_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_BAND_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_BOR_EQ */
-	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_BXOR_EQ */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_NUMBER */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_STRING */
-	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_REGEXP */
-};
-
-/*
- *  Misc helpers
- */
-
-DUK_LOCAL void duk__recursion_increase(duk_compiler_ctx *comp_ctx) {
-	DUK_ASSERT(comp_ctx != NULL);
-	DUK_ASSERT(comp_ctx->recursion_depth >= 0);
-	if (comp_ctx->recursion_depth >= comp_ctx->recursion_limit) {
-		DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_COMPILER_RECURSION_LIMIT);
-	}
-	comp_ctx->recursion_depth++;
-}
-
-DUK_LOCAL void duk__recursion_decrease(duk_compiler_ctx *comp_ctx) {
-	DUK_ASSERT(comp_ctx != NULL);
-	DUK_ASSERT(comp_ctx->recursion_depth > 0);
-	comp_ctx->recursion_depth--;
-}
-
-DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments(duk_compiler_ctx *comp_ctx, duk_hstring *h) {
-	DUK_UNREF(comp_ctx);
-	DUK_ASSERT(h != NULL);
-	return DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h);
-}
-
-DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments_in_strict_mode(duk_compiler_ctx *comp_ctx, duk_hstring *h) {
-	DUK_ASSERT(h != NULL);
-	return (comp_ctx->curr_func.is_strict &&
-	        DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h));
-}
-
-/*
- *  Parser duk__advance() token eating functions
- */
-
-/* XXX: valstack handling is awkward.  Add a valstack helper which
- * avoids dup():ing; valstack_copy(src, dst)?
- */
-
-DUK_LOCAL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) {
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-	duk_bool_t regexp;
-
-	DUK_ASSERT(comp_ctx->curr_token.t >= 0 && comp_ctx->curr_token.t <= DUK_TOK_MAXVAL);  /* MAXVAL is inclusive */
-
-	/*
-	 *  Use current token to decide whether a RegExp can follow.
-	 *
-	 *  We can use either 't' or 't_nores'; the latter would not
-	 *  recognize keywords.  Some keywords can be followed by a
-	 *  RegExp (e.g. "return"), so using 't' is better.  This is
-	 *  not trivial, see doc/compiler.rst.
-	 */
-
-	regexp = 1;
-	if (duk__token_lbp[comp_ctx->curr_token.t] & DUK__TOKEN_LBP_FLAG_NO_REGEXP) {
-		regexp = 0;
-	}
-	if (comp_ctx->curr_func.reject_regexp_in_adv) {
-		comp_ctx->curr_func.reject_regexp_in_adv = 0;
-		regexp = 0;
-	}
-
-	if (expect >= 0 && comp_ctx->curr_token.t != expect) {
-		DUK_D(DUK_DPRINT("parse error: expect=%ld, got=%ld",
-		                 (long) expect, (long) comp_ctx->curr_token.t));
-		DUK_ERROR_SYNTAX(thr, DUK_STR_PARSE_ERROR);
-	}
-
-	/* make current token the previous; need to fiddle with valstack "backing store" */
-	DUK_MEMCPY(&comp_ctx->prev_token, &comp_ctx->curr_token, sizeof(duk_token));
-	duk_copy(ctx, comp_ctx->tok11_idx, comp_ctx->tok21_idx);
-	duk_copy(ctx, comp_ctx->tok12_idx, comp_ctx->tok22_idx);
-
-	/* parse new token */
-	duk_lexer_parse_js_input_element(&comp_ctx->lex,
-	                                 &comp_ctx->curr_token,
-	                                 comp_ctx->curr_func.is_strict,
-	                                 regexp);
-
-	DUK_DDD(DUK_DDDPRINT("advance: curr: tok=%ld/%ld,%ld,term=%ld,%!T,%!T "
-	                     "prev: tok=%ld/%ld,%ld,term=%ld,%!T,%!T",
-	                     (long) comp_ctx->curr_token.t,
-	                     (long) comp_ctx->curr_token.t_nores,
-	                     (long) comp_ctx->curr_token.start_line,
-	                     (long) comp_ctx->curr_token.lineterm,
-	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok11_idx),
-	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok12_idx),
-	                     (long) comp_ctx->prev_token.t,
-	                     (long) comp_ctx->prev_token.t_nores,
-	                     (long) comp_ctx->prev_token.start_line,
-	                     (long) comp_ctx->prev_token.lineterm,
-	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok21_idx),
-	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok22_idx)));
-}
-
-/* advance, expecting current token to be a specific token; parse next token in regexp context */
-DUK_LOCAL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) {
-	duk__advance_helper(comp_ctx, expect);
-}
-
-/* advance, whatever the current token is; parse next token in regexp context */
-DUK_LOCAL void duk__advance(duk_compiler_ctx *comp_ctx) {
-	duk__advance_helper(comp_ctx, -1);
-}
-
-/*
- *  Helpers for duk_compiler_func.
- */
-
-/* init function state: inits valstack allocations */
-DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) {
-	duk_compiler_func *func = &comp_ctx->curr_func;
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-	duk_idx_t entry_top;
-
-	entry_top = duk_get_top(ctx);
-
-	DUK_MEMZERO(func, sizeof(*func));  /* intentional overlap with earlier memzero */
-#ifdef DUK_USE_EXPLICIT_NULL_INIT
-	func->h_name = NULL;
-	func->h_consts = NULL;
-	func->h_funcs = NULL;
-	func->h_decls = NULL;
-	func->h_labelnames = NULL;
-	func->h_labelinfos = NULL;
-	func->h_argnames = NULL;
-	func->h_varmap = NULL;
-#endif
-
-	duk_require_stack(ctx, DUK__FUNCTION_INIT_REQUIRE_SLOTS);
-
-	DUK_BW_INIT_PUSHBUF(thr, &func->bw_code, DUK__BC_INITIAL_INSTS * sizeof(duk_compiler_instr));
-	/* code_idx = entry_top + 0 */
-
-	duk_push_array(ctx);
-	func->consts_idx = entry_top + 1;
-	func->h_consts = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 1);
-	DUK_ASSERT(func->h_consts != NULL);
-
-	duk_push_array(ctx);
-	func->funcs_idx = entry_top + 2;
-	func->h_funcs = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 2);
-	DUK_ASSERT(func->h_funcs != NULL);
-	DUK_ASSERT(func->fnum_next == 0);
-
-	duk_push_array(ctx);
-	func->decls_idx = entry_top + 3;
-	func->h_decls = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 3);
-	DUK_ASSERT(func->h_decls != NULL);
-
-	duk_push_array(ctx);
-	func->labelnames_idx = entry_top + 4;
-	func->h_labelnames = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 4);
-	DUK_ASSERT(func->h_labelnames != NULL);
-
-	duk_push_dynamic_buffer(ctx, 0);
-	func->labelinfos_idx = entry_top + 5;
-	func->h_labelinfos = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 5);
-	DUK_ASSERT(func->h_labelinfos != NULL);
-	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_labelinfos) && !DUK_HBUFFER_HAS_EXTERNAL(func->h_labelinfos));
-
-	duk_push_array(ctx);
-	func->argnames_idx = entry_top + 6;
-	func->h_argnames = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 6);
-	DUK_ASSERT(func->h_argnames != NULL);
-
-	duk_push_object_internal(ctx);
-	func->varmap_idx = entry_top + 7;
-	func->h_varmap = DUK_GET_HOBJECT_POSIDX(ctx, entry_top + 7);
-	DUK_ASSERT(func->h_varmap != NULL);
-}
-
-/* reset function state (prepare for pass 2) */
-DUK_LOCAL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx) {
-	duk_compiler_func *func = &comp_ctx->curr_func;
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-
-	/* reset bytecode buffer but keep current size; pass 2 will
-	 * require same amount or more.
-	 */
-	DUK_BW_RESET_SIZE(thr, &func->bw_code);
-
-	duk_hobject_set_length_zero(thr, func->h_consts);
-	/* keep func->h_funcs; inner functions are not reparsed to avoid O(depth^2) parsing */
-	func->fnum_next = 0;
-	/* duk_hobject_set_length_zero(thr, func->h_funcs); */
-	duk_hobject_set_length_zero(thr, func->h_labelnames);
-	duk_hbuffer_reset(thr, func->h_labelinfos);
-	/* keep func->h_argnames; it is fixed for all passes */
-
-	/* truncated in case pass 3 needed */
-	duk_push_object_internal(ctx);
-	duk_replace(ctx, func->varmap_idx);
-	func->h_varmap = DUK_GET_HOBJECT_POSIDX(ctx, func->varmap_idx);
-	DUK_ASSERT(func->h_varmap != NULL);
-}
-
-/* cleanup varmap from any null entries, compact it, etc; returns number
- * of final entries after cleanup.
- */
-DUK_LOCAL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx) {
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-	duk_hobject *h_varmap;
-	duk_hstring *h_key;
-	duk_tval *tv;
-	duk_uint32_t i, e_next;
-	duk_int_t ret;
-
-	/* [ ... varmap ] */
-
-	h_varmap = DUK_GET_HOBJECT_NEGIDX(ctx, -1);
-	DUK_ASSERT(h_varmap != NULL);
-
-	ret = 0;
-	e_next = DUK_HOBJECT_GET_ENEXT(h_varmap);
-	for (i = 0; i < e_next; i++) {
-		h_key = DUK_HOBJECT_E_GET_KEY(thr->heap, h_varmap, i);
-		if (!h_key) {
-			continue;
-		}
-
-		DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h_varmap, i));
-
-		/* The entries can either be register numbers or 'null' values.
-		 * Thus, no need to DECREF them and get side effects.  DECREF'ing
-		 * the keys (strings) can cause memory to be freed but no side
-		 * effects as strings don't have finalizers.  This is why we can
-		 * rely on the object properties not changing from underneath us.
-		 */
-
-		tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h_varmap, i);
-		if (!DUK_TVAL_IS_NUMBER(tv)) {
-			DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv));
-			DUK_HOBJECT_E_SET_KEY(thr->heap, h_varmap, i, NULL);
-			DUK_HSTRING_DECREF(thr, h_key);
-			/* when key is NULL, value is garbage so no need to set */
-		} else {
-			ret++;
-		}
-	}
-
-	duk_compact(ctx, -1);
-
-	return ret;
-}
-
-/* convert duk_compiler_func into a function template, leaving the result
- * on top of stack.
- */
-/* XXX: awkward and bloated asm -- use faster internal accesses */
-DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind) {
-	duk_compiler_func *func = &comp_ctx->curr_func;
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-	duk_hcompiledfunction *h_res;
-	duk_hbuffer_fixed *h_data;
-	duk_size_t consts_count;
-	duk_size_t funcs_count;
-	duk_size_t code_count;
-	duk_size_t code_size;
-	duk_size_t data_size;
-	duk_size_t i;
-	duk_tval *p_const;
-	duk_hobject **p_func;
-	duk_instr_t *p_instr;
-	duk_compiler_instr *q_instr;
-	duk_tval *tv;
-
-	DUK_DDD(DUK_DDDPRINT("converting duk_compiler_func to function/template"));
-
-	/*
-	 *  Push result object and init its flags
-	 */
-
-	/* Valstack should suffice here, required on function valstack init */
-
-	(void) duk_push_compiledfunction(ctx);
-	h_res = (duk_hcompiledfunction *) DUK_GET_HOBJECT_NEGIDX(ctx, -1);  /* XXX: specific getter */
-	DUK_ASSERT(h_res != NULL);
-
-	if (func->is_function) {
-		DUK_DDD(DUK_DDDPRINT("function -> set NEWENV"));
-		DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res);
-
-		if (!func->is_arguments_shadowed) {
-			/* arguments object would be accessible; note that shadowing
-			 * bindings are arguments or function declarations, neither
-			 * of which are deletable, so this is safe.
-			 */
-
-			if (func->id_access_arguments || func->may_direct_eval) {
-				DUK_DDD(DUK_DDDPRINT("function may access 'arguments' object directly or "
-				                     "indirectly -> set CREATEARGS"));
-				DUK_HOBJECT_SET_CREATEARGS((duk_hobject *) h_res);
-			}
-		}
-	} else if (func->is_eval && func->is_strict) {
-		DUK_DDD(DUK_DDDPRINT("strict eval code -> set NEWENV"));
-		DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res);
-	} else {
-		/* non-strict eval: env is caller's env or global env (direct vs. indirect call)
-		 * global code: env is is global env
-		 */
-		DUK_DDD(DUK_DDDPRINT("non-strict eval code or global code -> no NEWENV"));
-		DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) h_res));
-	}
-
-	if (func->is_function && !func->is_decl && func->h_name != NULL && !force_no_namebind) {
-		/* Object literal set/get functions have a name (property
-		 * name) but must not have a lexical name binding, see
-		 * test-bug-getset-func-name.js.
-		 */
-		DUK_DDD(DUK_DDDPRINT("function expression with a name -> set NAMEBINDING"));
-		DUK_HOBJECT_SET_NAMEBINDING((duk_hobject *) h_res);
-	}
-
-	if (func->is_strict) {
-		DUK_DDD(DUK_DDDPRINT("function is strict -> set STRICT"));
-		DUK_HOBJECT_SET_STRICT((duk_hobject *) h_res);
-	}
-
-	if (func->is_notail) {
-		DUK_DDD(DUK_DDDPRINT("function is notail -> set NOTAIL"));
-		DUK_HOBJECT_SET_NOTAIL((duk_hobject *) h_res);
-	}
-
-	/*
-	 *  Build function fixed size 'data' buffer, which contains bytecode,
-	 *  constants, and inner function references.
-	 *
-	 *  During the building phase 'data' is reachable but incomplete.
-	 *  Only incref's occur during building (no refzero or GC happens),
-	 *  so the building process is atomic.
-	 */
-
-	consts_count = duk_hobject_get_length(thr, func->h_consts);
-	funcs_count = duk_hobject_get_length(thr, func->h_funcs) / 3;
-	code_count = DUK_BW_GET_SIZE(thr, &func->bw_code) / sizeof(duk_compiler_instr);
-	code_size = code_count * sizeof(duk_instr_t);
-
-	data_size = consts_count * sizeof(duk_tval) +
-	            funcs_count * sizeof(duk_hobject *) +
-	            code_size;
-
-	DUK_DDD(DUK_DDDPRINT("consts_count=%ld, funcs_count=%ld, code_size=%ld -> "
-	                     "data_size=%ld*%ld + %ld*%ld + %ld = %ld",
-	                     (long) consts_count, (long) funcs_count, (long) code_size,
-	                     (long) consts_count, (long) sizeof(duk_tval),
-	                     (long) funcs_count, (long) sizeof(duk_hobject *),
-	                     (long) code_size, (long) data_size));
-
-	duk_push_fixed_buffer(ctx, data_size);
-	h_data = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1);
-	DUK_ASSERT(h_data != NULL);
-
-	DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_res, (duk_hbuffer *) h_data);
-	DUK_HEAPHDR_INCREF(thr, h_data);
-
-	p_const = (duk_tval *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data);
-	for (i = 0; i < consts_count; i++) {
-		DUK_ASSERT(i <= DUK_UARRIDX_MAX);  /* const limits */
-		tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_consts, (duk_uarridx_t) i);
-		DUK_ASSERT(tv != NULL);
-		DUK_TVAL_SET_TVAL(p_const, tv);
-		p_const++;
-		DUK_TVAL_INCREF(thr, tv);  /* may be a string constant */
-
-		DUK_DDD(DUK_DDDPRINT("constant: %!T", (duk_tval *) tv));
-	}
-
-	p_func = (duk_hobject **) p_const;
-	DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_res, p_func);
-	for (i = 0; i < funcs_count; i++) {
-		duk_hobject *h;
-		DUK_ASSERT(i * 3 <= DUK_UARRIDX_MAX);  /* func limits */
-		tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_funcs, (duk_uarridx_t) (i * 3));
-		DUK_ASSERT(tv != NULL);
-		DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-		h = DUK_TVAL_GET_OBJECT(tv);
-		DUK_ASSERT(h != NULL);
-		DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(h));
-		*p_func++ = h;
-		DUK_HOBJECT_INCREF(thr, h);
-
-		DUK_DDD(DUK_DDDPRINT("inner function: %p -> %!iO",
-		                     (void *) h, (duk_heaphdr *) h));
-	}
-
-	p_instr = (duk_instr_t *) p_func;
-	DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_res, p_instr);
-
-	/* copy bytecode instructions one at a time */
-	q_instr = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(thr, &func->bw_code);
-	for (i = 0; i < code_count; i++) {
-		p_instr[i] = q_instr[i].ins;
-	}
-	/* Note: 'q_instr' is still used below */
-
-	DUK_ASSERT((duk_uint8_t *) (p_instr + code_count) == DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data) + data_size);
-
-	duk_pop(ctx);  /* 'data' (and everything in it) is reachable through h_res now */
-
-	/*
-	 *  Init object properties
-	 *
-	 *  Properties should be added in decreasing order of access frequency.
-	 *  (Not very critical for function templates.)
-	 */
-
-	DUK_DDD(DUK_DDDPRINT("init function properties"));
-
-	/* [ ... res ] */
-
-	/* _Varmap: omitted if function is guaranteed not to do slow path identifier
-	 * accesses or if it would turn out to be empty of actual register mappings
-	 * after a cleanup.  When debugging is enabled, we always need the varmap to
-	 * be able to lookup variables at any point.
-	 */
-#if defined(DUK_USE_DEBUGGER_SUPPORT)
-	if (1) {
-#else
-	if (func->id_access_slow ||     /* directly uses slow accesses */
-	    func->may_direct_eval ||    /* may indirectly slow access through a direct eval */
-	    funcs_count > 0) {          /* has inner functions which may slow access (XXX: this can be optimized by looking at the inner functions) */
-#endif
-		duk_int_t num_used;
-		duk_dup(ctx, func->varmap_idx);
-		num_used = duk__cleanup_varmap(comp_ctx);
-		DUK_DDD(DUK_DDDPRINT("cleaned up varmap: %!T (num_used=%ld)",
-		                     (duk_tval *) duk_get_tval(ctx, -1), (long) num_used));
-
-		if (num_used > 0) {
-			duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE);
-		} else {
-			DUK_DDD(DUK_DDDPRINT("varmap is empty after cleanup -> no need to add"));
-			duk_pop(ctx);
-		}
-	}
-
-	/* _Formals: omitted if function is guaranteed not to need a (non-strict) arguments object */
-	if (1) {
-		/* XXX: Add a proper condition.  If formals list is omitted, recheck
-		 * handling for 'length' in duk_js_push_closure(); it currently relies
-		 * on _Formals being set.  Removal may need to be conditional to debugging
-		 * being enabled/disabled too.
-		 */
-		duk_dup(ctx, func->argnames_idx);
-		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE);
-	}
-
-	/* name */
-	if (func->h_name) {
-		duk_push_hstring(ctx, func->h_name);
-		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
-	}
-
-	/* _Source */
-#if defined(DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY)
-	if (0) {
-		/* XXX: Currently function source code is not stored, as it is not
-		 * required by the standard.  Source code should not be stored by
-		 * default (user should enable it explicitly), and the source should
-		 * probably be compressed with a trivial text compressor; average
-		 * compression of 20-30% is quite easy to achieve even with a trivial
-		 * compressor (RLE + backwards lookup).
-		 *
-		 * Debugging needs source code to be useful: sometimes input code is
-		 * not found in files as it may be generated and then eval()'d, given
-		 * by dynamic C code, etc.
-		 *
-		 * Other issues:
-		 *
-		 *   - Need tokenizer indices for start and end to substring
-		 *   - Always normalize function declaration part?
-		 *   - If we keep _Formals, only need to store body
-		 */
-
-		/*
-		 *  For global or eval code this is straightforward.  For functions
-		 *  created with the Function constructor we only get the source for
-		 *  the body and must manufacture the "function ..." part.
-		 *
-		 *  For instance, for constructed functions (v8):
-		 *
-		 *    > a = new Function("foo", "bar", "print(foo)");
-		 *    [Function]
-		 *    > a.toString()
-		 *    'function anonymous(foo,bar) {\nprint(foo)\n}'
-		 *
-		 *  Similarly for e.g. getters (v8):
-		 *
-		 *    > x = { get a(foo,bar) { print(foo); } }
-		 *    { a: [Getter] }
-		 *    > Object.getOwnPropertyDescriptor(x, 'a').get.toString()
-		 *    'function a(foo,bar) { print(foo); }'
-		 */
-
-#if 0
-		duk_push_string(ctx, "XXX");
-		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_SOURCE, DUK_PROPDESC_FLAGS_NONE);
-#endif
-	}
-#endif  /* DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY */
-
-	/* _Pc2line */
-#if defined(DUK_USE_PC2LINE)
-	if (1) {
-		/*
-		 *  Size-optimized pc->line mapping.
-		 */
-
-		DUK_ASSERT(code_count <= DUK_COMPILER_MAX_BYTECODE_LENGTH);
-		duk_hobject_pc2line_pack(thr, q_instr, (duk_uint_fast32_t) code_count);  /* -> pushes fixed buffer */
-		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_NONE);
-
-		/* XXX: if assertions enabled, walk through all valid PCs
-		 * and check line mapping.
-		 */
-	}
-#endif  /* DUK_USE_PC2LINE */
-
-	/* fileName */
-	if (comp_ctx->h_filename) {
-		/*
-		 *  Source filename (or equivalent), for identifying thrown errors.
-		 */
-
-		duk_push_hstring(ctx, comp_ctx->h_filename);
-		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_NONE);
-	}
-
-	/*
-	 *  Init remaining result fields
-	 *
-	 *  'nregs' controls how large a register frame is allocated.
-	 *
-	 *  'nargs' controls how many formal arguments are written to registers:
-	 *  r0, ... r(nargs-1).  The remaining registers are initialized to
-	 *  undefined.
-	 */
-
-	DUK_ASSERT(func->temp_max >= 0);
-	h_res->nregs = (duk_uint16_t) func->temp_max;
-	h_res->nargs = (duk_uint16_t) duk_hobject_get_length(thr, func->h_argnames);
-	DUK_ASSERT(h_res->nregs >= h_res->nargs);  /* pass2 allocation handles this */
-#if defined(DUK_USE_DEBUGGER_SUPPORT)
-	h_res->start_line = (duk_uint32_t) func->min_line;
-	h_res->end_line = (duk_uint32_t) func->max_line;
-#endif
-
-	DUK_DD(DUK_DDPRINT("converted function: %!ixT",
-	                   (duk_tval *) duk_get_tval(ctx, -1)));
-
-	/*
-	 *  Compact the function template.
-	 */
-
-	duk_compact(ctx, -1);
-
-	/*
-	 *  Debug dumping
-	 */
-
-#ifdef DUK_USE_DDDPRINT
-	{
-		duk_hcompiledfunction *h;
-		duk_instr_t *p, *p_start, *p_end;
-
-		h = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
-		p_start = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, h);
-		p_end = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, h);
-
-		p = p_start;
-		while (p < p_end) {
-			DUK_DDD(DUK_DDDPRINT("BC %04ld: %!I        ; 0x%08lx op=%ld (%!C) a=%ld b=%ld c=%ld",
-			                     (long) (p - p_start),
-			                     (duk_instr_t) (*p),
-			                     (unsigned long) (*p),
-			                     (long) DUK_DEC_OP(*p),
-			                     (long) DUK_DEC_OP(*p),
-			                     (long) DUK_DEC_A(*p),
-			                     (long) DUK_DEC_B(*p),
-			                     (long) DUK_DEC_C(*p)));
-			p++;
-		}
-	}
-#endif
-}
-
-/*
- *  Code emission helpers
- *
- *  Some emission helpers understand the range of target and source reg/const
- *  values and automatically emit shuffling code if necessary.  This is the
- *  case when the slot in question (A, B, C) is used in the standard way and
- *  for opcodes the emission helpers explicitly understand (like DUK_OP_CALL).
- *
- *  The standard way is that:
- *    - slot A is a target register
- *    - slot B is a source register/constant
- *    - slot C is a source register/constant
- *
- *  If a slot is used in a non-standard way the caller must indicate this
- *  somehow.  If a slot is used as a target instead of a source (or vice
- *  versa), this can be indicated with a flag to trigger proper shuffling
- *  (e.g. DUK__EMIT_FLAG_B_IS_TARGET).  If the value in the slot is not
- *  register/const related at all, the caller must ensure that the raw value
- *  fits into the corresponding slot so as to not trigger shuffling.  The
- *  caller must set a "no shuffle" flag to ensure compilation fails if
- *  shuffling were to be triggered because of an internal error.
- *
- *  For slots B and C the raw slot size is 9 bits but one bit is reserved for
- *  the reg/const indicator.  To use the full 9-bit range for a raw value,
- *  shuffling must be disabled with the DUK__EMIT_FLAG_NO_SHUFFLE_{B,C} flag.
- *  Shuffling is only done for A, B, and C slots, not the larger BC or ABC slots.
- *
- *  There is call handling specific understanding in the A-B-C emitter to
- *  convert call setup and call instructions into indirect ones if necessary.
- */
-
-/* Code emission flags, passed in the 'opcode' field.  Opcode + flags
- * fit into 16 bits for now, so use duk_small_uint.t.
- */
-#define DUK__EMIT_FLAG_NO_SHUFFLE_A      (1 << 8)
-#define DUK__EMIT_FLAG_NO_SHUFFLE_B      (1 << 9)
-#define DUK__EMIT_FLAG_NO_SHUFFLE_C      (1 << 10)
-#define DUK__EMIT_FLAG_A_IS_SOURCE       (1 << 11)  /* slot A is a source (default: target) */
-#define DUK__EMIT_FLAG_B_IS_TARGET       (1 << 12)  /* slot B is a target (default: source) */
-#define DUK__EMIT_FLAG_C_IS_TARGET       (1 << 13)  /* slot C is a target (default: source) */
-#define DUK__EMIT_FLAG_B_IS_TARGETSOURCE (1 << 14)  /* slot B is both a target and a source (used by extraops like DUK_EXTRAOP_INSTOF */
-#define DUK__EMIT_FLAG_RESERVE_JUMPSLOT  (1 << 15)  /* reserve a jumpslot after instr before target spilling, used for NEXTENUM */
-
-/* XXX: clarify on when and where DUK__CONST_MARKER is allowed */
-/* XXX: opcode specific assertions on when consts are allowed */
-
-/* XXX: macro smaller than call? */
-DUK_LOCAL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx) {
-	duk_compiler_func *func;
-	func = &comp_ctx->curr_func;
-	return (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &func->bw_code) / sizeof(duk_compiler_instr));
-}
-
-DUK_LOCAL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc) {
-	DUK_ASSERT(pc >= 0);
-	DUK_ASSERT((duk_size_t) pc < (duk_size_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr)));
-	return ((duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code)) + pc;
-}
-
-/* emit instruction; could return PC but that's not needed in the majority
- * of cases.
- */
-DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) {
-#if defined(DUK_USE_PC2LINE)
-	duk_int_t line;
-#endif
-	duk_compiler_instr *instr;
-
-	DUK_DDD(DUK_DDDPRINT("duk__emit: 0x%08lx curr_token.start_line=%ld prev_token.start_line=%ld pc=%ld --> %!I",
-	                     (unsigned long) ins,
-	                     (long) comp_ctx->curr_token.start_line,
-	                     (long) comp_ctx->prev_token.start_line,
-	                     (long) duk__get_current_pc(comp_ctx),
-	                     (duk_instr_t) ins));
-
-	instr = (duk_compiler_instr *) (void *) DUK_BW_ENSURE_GETPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
-	DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
-
-#if defined(DUK_USE_PC2LINE)
-	/* The line number tracking is a bit inconsistent right now, which
-	 * affects debugger accuracy.  Mostly call sites emit opcodes when
-	 * they have parsed a token (say a terminating semicolon) and called
-	 * duk__advance().  In this case the line number of the previous
-	 * token is the most accurate one (except in prologue where
-	 * prev_token.start_line is 0).  This is probably not 100% correct
-	 * right now.
-	 */
-	/* approximation, close enough */
-	line = comp_ctx->prev_token.start_line;
-	if (line == 0) {
-		line = comp_ctx->curr_token.start_line;
-	}
-#endif
-
-	instr->ins = ins;
-#if defined(DUK_USE_PC2LINE)
-	instr->line = line;
-#endif
-#if defined(DUK_USE_DEBUGGER_SUPPORT)
-	if (line < comp_ctx->curr_func.min_line) {
-		comp_ctx->curr_func.min_line = line;
-	}
-	if (line > comp_ctx->curr_func.max_line) {
-		comp_ctx->curr_func.max_line = line;
-	}
-#endif
-
-	/* Limit checks for bytecode byte size and line number. */
-	if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) {
-		goto fail_bc_limit;
-	}
-#if defined(DUK_USE_PC2LINE) && defined(DUK_USE_ESBC_LIMITS)
-#if defined(DUK_USE_BUFLEN16)
-	/* Buffer length is bounded to 0xffff automatically, avoid compile warning. */
-	if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) {
-		goto fail_bc_limit;
-	}
-#else
-	if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) {
-		goto fail_bc_limit;
-	}
-#endif
-#endif
-
-	return;
-
-  fail_bc_limit:
-	DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_BYTECODE_LIMIT);
-}
-
-/* Update function min/max line from current token.  Needed to improve
- * function line range information for debugging, so that e.g. opening
- * curly brace is covered by line range even when no opcodes are emitted
- * for the line containing the brace.
- */
-DUK_LOCAL void duk__update_lineinfo_currtoken(duk_compiler_ctx *comp_ctx) {
-#if defined(DUK_USE_DEBUGGER_SUPPORT)
-	duk_int_t line;
-
-	line = comp_ctx->curr_token.start_line;
-	if (line == 0) {
-		return;
-	}
-	if (line < comp_ctx->curr_func.min_line) {
-		comp_ctx->curr_func.min_line = line;
-	}
-	if (line > comp_ctx->curr_func.max_line) {
-		comp_ctx->curr_func.max_line = line;
-	}
-#else
-	DUK_UNREF(comp_ctx);
-#endif
-}
-
-#if 0 /* unused */
-DUK_LOCAL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op) {
-	duk__emit(comp_ctx, DUK_ENC_OP_ABC(op, 0));
-}
-#endif
-
-/* Important main primitive. */
-DUK_LOCAL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c) {
-	duk_instr_t ins = 0;
-	duk_int_t a_out = -1;
-	duk_int_t b_out = -1;
-	duk_int_t c_out = -1;
-	duk_int_t tmp;
-
-	DUK_DDD(DUK_DDDPRINT("emit: op_flags=%04lx, a=%ld, b=%ld, c=%ld",
-	                     (unsigned long) op_flags, (long) a, (long) b, (long) c));
-
-	/* We could rely on max temp/const checks: if they don't exceed BC
-	 * limit, nothing here can either (just asserts would be enough).
-	 * Currently we check for the limits, which provides additional
-	 * protection against creating invalid bytecode due to compiler
-	 * bugs.
-	 */
-
-	DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN);  /* unsigned */
-	DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
-
-	/* Input shuffling happens before the actual operation, while output
-	 * shuffling happens afterwards.  Output shuffling decisions are still
-	 * made at the same time to reduce branch clutter; output shuffle decisions
-	 * are recorded into X_out variables.
-	 */
-
-	/* Slot A */
-
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-	if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
-#else
-	if (a <= DUK_BC_A_MAX) {
-#endif
-		;
-	} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
-		DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but shuffle prohibited, a: %ld", (long) a));
-		goto error_outofregs;
-	} else if (a <= DUK_BC_BC_MAX) {
-		comp_ctx->curr_func.needs_shuffle = 1;
-		tmp = comp_ctx->curr_func.shuffle1;
-		if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) {
-			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
-		} else {
-			duk_small_int_t op = op_flags & 0xff;
-			if (op == DUK_OP_CSVAR || op == DUK_OP_CSREG || op == DUK_OP_CSPROP) {
-				/* Special handling for call setup instructions.  The target
-				 * is expressed indirectly, but there is no output shuffling.
-				 */
-				DUK_ASSERT((op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) == 0);
-				duk__emit_load_int32_noshuffle(comp_ctx, tmp, a);
-				DUK_ASSERT(DUK_OP_CSVARI == DUK_OP_CSVAR + 1);
-				DUK_ASSERT(DUK_OP_CSREGI == DUK_OP_CSREG + 1);
-				DUK_ASSERT(DUK_OP_CSPROPI == DUK_OP_CSPROP + 1);
-				op_flags++;  /* indirect opcode follows direct */
-			} else {
-				/* Output shuffle needed after main operation */
-				a_out = a;
-			}
-		}
-		a = tmp;
-	} else {
-		DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but does not fit into BC, a: %ld", (long) a));
-		goto error_outofregs;
-	}
-
-	/* Slot B */
-
-	if (b & DUK__CONST_MARKER) {
-		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) == 0);
-		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
-		DUK_ASSERT((op_flags & 0xff) != DUK_OP_CALL);
-		DUK_ASSERT((op_flags & 0xff) != DUK_OP_NEW);
-		b = b & ~DUK__CONST_MARKER;
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-		if (0) {
-#else
-		if (b <= 0xff) {
-#endif
-			ins |= DUK_ENC_OP_A_B_C(0, 0, 0x100, 0);  /* const flag for B */
-		} else if (b <= DUK_BC_BC_MAX) {
-			comp_ctx->curr_func.needs_shuffle = 1;
-			tmp = comp_ctx->curr_func.shuffle2;
-			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, b));
-			b = tmp;
-		} else {
-			DUK_D(DUK_DPRINT("out of regs: 'b' (const) needs shuffling but does not fit into BC, b: %ld", (long) b));
-			goto error_outofregs;
-		}
-	} else {
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-		if (b <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B)) {
-#else
-		if (b <= 0xff) {
-#endif
-			;
-		} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) {
-			if (b > DUK_BC_B_MAX) {
-				/* Note: 0xff != DUK_BC_B_MAX */
-				DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but shuffle prohibited, b: %ld", (long) b));
-				goto error_outofregs;
-			}
-		} else if (b <= DUK_BC_BC_MAX) {
-			comp_ctx->curr_func.needs_shuffle = 1;
-			tmp = comp_ctx->curr_func.shuffle2;
-			if (op_flags & DUK__EMIT_FLAG_B_IS_TARGET) {
-				/* Output shuffle needed after main operation */
-				b_out = b;
-			}
-			if (!(op_flags & DUK__EMIT_FLAG_B_IS_TARGET) || (op_flags & DUK__EMIT_FLAG_B_IS_TARGETSOURCE)) {
-				duk_small_int_t op = op_flags & 0xff;
-				if (op == DUK_OP_CALL || op == DUK_OP_NEW ||
-				    op == DUK_OP_MPUTOBJ || op == DUK_OP_MPUTARR) {
-					/* Special handling for CALL/NEW/MPUTOBJ/MPUTARR shuffling.
-					 * For each, slot B identifies the first register of a range
-					 * of registers, so normal shuffling won't work.  Instead,
-					 * an indirect version of the opcode is used.
-					 */
-					DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
-					duk__emit_load_int32_noshuffle(comp_ctx, tmp, b);
-					DUK_ASSERT(DUK_OP_CALLI == DUK_OP_CALL + 1);
-					DUK_ASSERT(DUK_OP_NEWI == DUK_OP_NEW + 1);
-					DUK_ASSERT(DUK_OP_MPUTOBJI == DUK_OP_MPUTOBJ + 1);
-					DUK_ASSERT(DUK_OP_MPUTARRI == DUK_OP_MPUTARR + 1);
-					op_flags++;  /* indirect opcode follows direct */
-				} else {
-					duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, b));
-				}
-			}
-			b = tmp;
-		} else {
-			DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but does not fit into BC, b: %ld", (long) b));
-			goto error_outofregs;
-		}
-	}
-
-	/* Slot C */
-
-	if (c & DUK__CONST_MARKER) {
-		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) == 0);
-		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
-		c = c & ~DUK__CONST_MARKER;
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-		if (0) {
-#else
-		if (c <= 0xff) {
-#endif
-			ins |= DUK_ENC_OP_A_B_C(0, 0, 0, 0x100);  /* const flag for C */
-		} else if (c <= DUK_BC_BC_MAX) {
-			comp_ctx->curr_func.needs_shuffle = 1;
-			tmp = comp_ctx->curr_func.shuffle3;
-			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, c));
-			c = tmp;
-		} else {
-			DUK_D(DUK_DPRINT("out of regs: 'c' (const) needs shuffling but does not fit into BC, c: %ld", (long) c));
-			goto error_outofregs;
-		}
-	} else {
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-		if (c <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C)) {
-#else
-		if (c <= 0xff) {
-#endif
-			;
-		} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) {
-			if (c > DUK_BC_C_MAX) {
-				/* Note: 0xff != DUK_BC_C_MAX */
-				DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but shuffle prohibited, c: %ld", (long) c));
-				goto error_outofregs;
-			}
-		} else if (c <= DUK_BC_BC_MAX) {
-			comp_ctx->curr_func.needs_shuffle = 1;
-			tmp = comp_ctx->curr_func.shuffle3;
-			if (op_flags & DUK__EMIT_FLAG_C_IS_TARGET) {
-				/* Output shuffle needed after main operation */
-				c_out = c;
-			} else {
-				duk_small_int_t op = op_flags & 0xff;
-				if (op == DUK_OP_EXTRA &&
-				    (a == DUK_EXTRAOP_INITGET || a == DUK_EXTRAOP_INITSET)) {
-					/* Special shuffling for INITGET/INITSET, where slot C
-					 * identifies a register pair and cannot be shuffled
-					 * normally.  Use an indirect variant instead.
-					 */
-					DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
-					duk__emit_load_int32_noshuffle(comp_ctx, tmp, c);
-					DUK_ASSERT(DUK_EXTRAOP_INITGETI == DUK_EXTRAOP_INITGET + 1);
-					DUK_ASSERT(DUK_EXTRAOP_INITSETI == DUK_EXTRAOP_INITSET + 1);
-					a++;  /* indirect opcode follows direct */
-				} else {
-					duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, c));
-				}
-			}
-			c = tmp;
-		} else {
-			DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but does not fit into BC, c: %ld", (long) c));
-			goto error_outofregs;
-		}
-	}
-
-	/* Main operation */
-
-	DUK_ASSERT_DISABLE(a >= DUK_BC_A_MIN);  /* unsigned */
-	DUK_ASSERT(a <= DUK_BC_A_MAX);
-	DUK_ASSERT_DISABLE(b >= DUK_BC_B_MIN);  /* unsigned */
-	DUK_ASSERT(b <= DUK_BC_B_MAX);
-	DUK_ASSERT_DISABLE(c >= DUK_BC_C_MIN);  /* unsigned */
-	DUK_ASSERT(c <= DUK_BC_C_MAX);
-
-	ins |= DUK_ENC_OP_A_B_C(op_flags & 0xff, a, b, c);
-	duk__emit(comp_ctx, ins);
-
-	/* NEXTENUM needs a jump slot right after the main instruction.
-	 * When the JUMP is taken, output spilling is not needed so this
-	 * workaround is possible.  The jump slot PC is exceptionally
-	 * plumbed through comp_ctx to minimize call sites.
-	 */
-	if (op_flags & DUK__EMIT_FLAG_RESERVE_JUMPSLOT) {
-		comp_ctx->emit_jumpslot_pc = duk__get_current_pc(comp_ctx);
-		duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
-	}
-
-	/* Output shuffling: only one output register is realistically possible.
-	 *
-	 * (Zero would normally be an OK marker value: if the target register
-	 * was zero, it would never be shuffled.  But with DUK_USE_SHUFFLE_TORTURE
-	 * this is no longer true, so use -1 as a marker instead.)
-	 */
-
-	if (a_out >= 0) {
-		DUK_ASSERT(b_out < 0);
-		DUK_ASSERT(c_out < 0);
-		duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, a, a_out));
-	} else if (b_out >= 0) {
-		DUK_ASSERT(a_out < 0);
-		DUK_ASSERT(c_out < 0);
-		duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, b, b_out));
-	} else if (c_out >= 0) {
-		DUK_ASSERT(b_out < 0);
-		DUK_ASSERT(c_out < 0);
-		duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, c, c_out));
-	}
-
-	return;
-
- error_outofregs:
-	DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
-}
-
-DUK_LOCAL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b) {
-	duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, b, 0);
-}
-
-#if 0  /* unused */
-DUK_LOCAL void duk__emit_a(duk_compiler_ctx *comp_ctx, int op_flags, int a) {
-	duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_B | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, 0, 0);
-}
-#endif
-
-DUK_LOCAL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc) {
-	duk_instr_t ins;
-	duk_int_t tmp;
-
-	/* allow caller to give a const number with the DUK__CONST_MARKER */
-	bc = bc & (~DUK__CONST_MARKER);
-
-	DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN);  /* unsigned */
-	DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
-	DUK_ASSERT_DISABLE(bc >= DUK_BC_BC_MIN);  /* unsigned */
-	DUK_ASSERT(bc <= DUK_BC_BC_MAX);
-	DUK_ASSERT((bc & DUK__CONST_MARKER) == 0);
-
-	if (bc <= DUK_BC_BC_MAX) {
-		;
-	} else {
-		/* No BC shuffling now. */
-		goto error_outofregs;
-	}
-
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-	if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
-#else
-	if (a <= DUK_BC_A_MAX) {
-#endif
-		ins = DUK_ENC_OP_A_BC(op_flags & 0xff, a, bc);
-		duk__emit(comp_ctx, ins);
-	} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
-		goto error_outofregs;
-	} else if (a <= DUK_BC_BC_MAX) {
-		comp_ctx->curr_func.needs_shuffle = 1;
-		tmp = comp_ctx->curr_func.shuffle1;
-		ins = DUK_ENC_OP_A_BC(op_flags & 0xff, tmp, bc);
-		if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) {
-			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
-			duk__emit(comp_ctx, ins);
-		} else {
-			duk__emit(comp_ctx, ins);
-			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, tmp, a));
-		}
-	} else {
-		goto error_outofregs;
-	}
-	return;
-
- error_outofregs:
-	DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
-}
-
-DUK_LOCAL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc) {
-	duk_instr_t ins;
-
-	DUK_ASSERT_DISABLE(op >= DUK_BC_OP_MIN);  /* unsigned */
-	DUK_ASSERT(op <= DUK_BC_OP_MAX);
-	DUK_ASSERT_DISABLE(abc >= DUK_BC_ABC_MIN);  /* unsigned */
-	DUK_ASSERT(abc <= DUK_BC_ABC_MAX);
-	DUK_ASSERT((abc & DUK__CONST_MARKER) == 0);
-
-	if (abc <= DUK_BC_ABC_MAX) {
-		;
-	} else {
-		goto error_outofregs;
-	}
-	ins = DUK_ENC_OP_ABC(op, abc);
-	DUK_DDD(DUK_DDDPRINT("duk__emit_abc: 0x%08lx line=%ld pc=%ld op=%ld (%!C) abc=%ld (%!I)",
-	                     (unsigned long) ins, (long) comp_ctx->curr_token.start_line,
-	                     (long) duk__get_current_pc(comp_ctx), (long) op, (long) op,
-	                     (long) abc, (duk_instr_t) ins));
-	duk__emit(comp_ctx, ins);
-	return;
-
- error_outofregs:
-	DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
-}
-
-DUK_LOCAL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c) {
-	DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-	DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
-	/* Setting "no shuffle A" is covered by the assert, but it's needed
-	 * with DUK_USE_SHUFFLE_TORTURE.
-	 */
-	duk__emit_a_b_c(comp_ctx,
-	                DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff),  /* transfer flags */
-	                extraop_flags & 0xff,
-	                b,
-	                c);
-}
-
-DUK_LOCAL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b) {
-	DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-	DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
-	/* Setting "no shuffle A" is covered by the assert, but it's needed
-	 * with DUK_USE_SHUFFLE_TORTURE.
-	 */
-	duk__emit_a_b_c(comp_ctx,
-	                DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff),  /* transfer flags */
-	                extraop_flags & 0xff,
-	                b,
-	                0);
-}
-
-DUK_LOCAL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc) {
-	DUK_ASSERT_DISABLE(extraop >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-	DUK_ASSERT(extraop <= DUK_BC_EXTRAOP_MAX);
-	/* Setting "no shuffle A" is covered by the assert, but it's needed
-	 * with DUK_USE_SHUFFLE_TORTURE.
-	 */
-	duk__emit_a_bc(comp_ctx,
-	               DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-	               extraop,
-	               bc);
-}
-
-DUK_LOCAL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags) {
-	DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-	DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
-	/* Setting "no shuffle A" is covered by the assert, but it's needed
-	 * with DUK_USE_SHUFFLE_TORTURE.
-	 */
-	duk__emit_a_b_c(comp_ctx,
-	                DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_B |
-	                    DUK__EMIT_FLAG_NO_SHUFFLE_C | (extraop_flags & ~0xff),  /* transfer flags */
-	                extraop_flags & 0xff,
-	                0,
-	                0);
-}
-
-DUK_LOCAL void duk__emit_load_int32_raw(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val, duk_small_uint_t op_flags) {
-	/* XXX: Shuffling support could be implemented here so that LDINT+LDINTX
-	 * would only shuffle once (instead of twice).  The current code works
-	 * though, and has a smaller compiler footprint.
-	 */
-
-	if ((val >= (duk_int32_t) DUK_BC_BC_MIN - (duk_int32_t) DUK_BC_LDINT_BIAS) &&
-	    (val <= (duk_int32_t) DUK_BC_BC_MAX - (duk_int32_t) DUK_BC_LDINT_BIAS)) {
-		DUK_DDD(DUK_DDDPRINT("emit LDINT to reg %ld for %ld", (long) reg, (long) val));
-		duk__emit_a_bc(comp_ctx, DUK_OP_LDINT | op_flags, reg, (duk_regconst_t) (val + (duk_int32_t) DUK_BC_LDINT_BIAS));
-	} else {
-		duk_int32_t hi = val >> DUK_BC_LDINTX_SHIFT;
-		duk_int32_t lo = val & ((((duk_int32_t) 1) << DUK_BC_LDINTX_SHIFT) - 1);
-		DUK_ASSERT(lo >= 0);
-		DUK_DDD(DUK_DDDPRINT("emit LDINT+LDINTX to reg %ld for %ld -> hi %ld, lo %ld",
-		                     (long) reg, (long) val, (long) hi, (long) lo));
-		duk__emit_a_bc(comp_ctx, DUK_OP_LDINT | op_flags, reg, (duk_regconst_t) (hi + (duk_int32_t) DUK_BC_LDINT_BIAS));
-		duk__emit_a_bc(comp_ctx, DUK_OP_LDINTX | op_flags, reg, (duk_regconst_t) lo);
-	}
-}
-
-DUK_LOCAL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
-	duk__emit_load_int32_raw(comp_ctx, reg, val, 0 /*op_flags*/);
-}
-
-#if defined(DUK_USE_SHUFFLE_TORTURE)
-/* Used by duk__emit*() calls so that we don't shuffle the loadints that
- * are needed to handle indirect opcodes.
- */
-DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
-	duk__emit_load_int32_raw(comp_ctx, reg, val, DUK__EMIT_FLAG_NO_SHUFFLE_A /*op_flags*/);
-}
-#else
-DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
-	/* When torture not enabled, can just use the same helper because
-	 * 'reg' won't get spilled.
-	 */
-	DUK_ASSERT(reg <= DUK_BC_A_MAX);
-	duk__emit_load_int32(comp_ctx, reg, val);
-}
-#endif
-
-DUK_LOCAL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc) {
-	duk_int_t curr_pc;
-	duk_int_t offset;
-
-	curr_pc = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr));
-	offset = (duk_int_t) target_pc - (duk_int_t) curr_pc - 1;
-	DUK_ASSERT(offset + DUK_BC_JUMP_BIAS >= DUK_BC_ABC_MIN);
-	DUK_ASSERT(offset + DUK_BC_JUMP_BIAS <= DUK_BC_ABC_MAX);
-	duk__emit_abc(comp_ctx, DUK_OP_JUMP, (duk_regconst_t) (offset + DUK_BC_JUMP_BIAS));
-}
-
-DUK_LOCAL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx) {
-	duk_int_t ret;
-
-	ret = duk__get_current_pc(comp_ctx);  /* useful for patching jumps later */
-	duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
-	return ret;
-}
-
-/* Insert an empty jump in the middle of code emitted earlier.  This is
- * currently needed for compiling for-in.
- */
-DUK_LOCAL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
-#if defined(DUK_USE_PC2LINE)
-	duk_int_t line;
-#endif
-	duk_compiler_instr *instr;
-	duk_size_t offset;
-
-	offset = jump_pc * sizeof(duk_compiler_instr),
-	instr = (duk_compiler_instr *) (void *)
-	        DUK_BW_INSERT_ENSURE_AREA(comp_ctx->thr,
-	                                  &comp_ctx->curr_func.bw_code,
-	                                  offset,
-	                                  sizeof(duk_compiler_instr));
-
-#if defined(DUK_USE_PC2LINE)
-	line = comp_ctx->curr_token.start_line;  /* approximation, close enough */
-#endif
-	instr->ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, 0);
-#if defined(DUK_USE_PC2LINE)
-	instr->line = line;
-#endif
-
-	DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr));
-	if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) {
-		goto fail_bc_limit;
-	}
-	return;
-
-  fail_bc_limit:
-	DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_BYTECODE_LIMIT);
-}
-
-/* Does not assume that jump_pc contains a DUK_OP_JUMP previously; this is intentional
- * to allow e.g. an INVALID opcode be overwritten with a JUMP (label management uses this).
- */
-DUK_LOCAL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc) {
-	duk_compiler_instr *instr;
-	duk_int_t offset;
-
-	/* allow negative PCs, behave as a no-op */
-	if (jump_pc < 0) {
-		DUK_DDD(DUK_DDDPRINT("duk__patch_jump(): nop call, jump_pc=%ld (<0), target_pc=%ld",
-		                     (long) jump_pc, (long) target_pc));
-		return;
-	}
-	DUK_ASSERT(jump_pc >= 0);
-
-	/* XXX: range assert */
-	instr = duk__get_instr_ptr(comp_ctx, jump_pc);
-	DUK_ASSERT(instr != NULL);
-
-	/* XXX: range assert */
-	offset = target_pc - jump_pc - 1;
-
-	instr->ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, offset + DUK_BC_JUMP_BIAS);
-	DUK_DDD(DUK_DDDPRINT("duk__patch_jump(): jump_pc=%ld, target_pc=%ld, offset=%ld",
-	                     (long) jump_pc, (long) target_pc, (long) offset));
-}
-
-DUK_LOCAL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
-	duk__patch_jump(comp_ctx, jump_pc, duk__get_current_pc(comp_ctx));
-}
-
-DUK_LOCAL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags) {
-	duk_compiler_instr *instr;
-
-	DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0);
-
-	instr = duk__get_instr_ptr(comp_ctx, ldconst_pc);
-	DUK_ASSERT(DUK_DEC_OP(instr->ins) == DUK_OP_LDCONST);
-	DUK_ASSERT(instr != NULL);
-	if (const_varname & DUK__CONST_MARKER) {
-		/* Have a catch variable. */
-		const_varname = const_varname & (~DUK__CONST_MARKER);
-		if (reg_catch > DUK_BC_BC_MAX || const_varname > DUK_BC_BC_MAX) {
-			/* Catch attempts to use out-of-range reg/const.  Without this
-			 * check Duktape 0.12.0 could generate invalid code which caused
-			 * an assert failure on execution.  This error is triggered e.g.
-			 * for functions with a lot of constants and a try-catch statement.
-			 * Shuffling or opcode semantics change is needed to fix the issue.
-			 * See: test-bug-trycatch-many-constants.js.
-			 */
-			DUK_D(DUK_DPRINT("failed to patch trycatch: flags=%ld, reg_catch=%ld, const_varname=%ld (0x%08lx)",
-			                 (long) flags, (long) reg_catch, (long) const_varname, (long) const_varname));
-			DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_REG_LIMIT);
-		}
-		instr->ins |= DUK_ENC_OP_A_BC(0, 0, const_varname);
-	} else {
-		/* No catch variable, e.g. a try-finally; replace LDCONST with
-		 * NOP to avoid a bogus LDCONST.
-		 */
-		instr->ins = DUK_ENC_OP_A(DUK_OP_EXTRA, DUK_EXTRAOP_NOP);
-	}
-
-	instr = duk__get_instr_ptr(comp_ctx, trycatch_pc);
-	DUK_ASSERT(instr != NULL);
-	DUK_ASSERT_DISABLE(flags >= DUK_BC_A_MIN);
-	DUK_ASSERT(flags <= DUK_BC_A_MAX);
-	instr->ins = DUK_ENC_OP_A_BC(DUK_OP_TRYCATCH, flags, reg_catch);
-}
-
-DUK_LOCAL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) {
-	duk__emit_a_b_c(comp_ctx,
-	                DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-	                0 /*false*/,
-	                regconst,
-	                0 /*unused*/);
-}
-
-DUK_LOCAL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) {
-	duk__emit_a_b_c(comp_ctx,
-	                DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-	                1 /*true*/,
-	                regconst,
-	                0 /*unused*/);
-}
-
-DUK_LOCAL void duk__emit_invalid(duk_compiler_ctx *comp_ctx) {
-	duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_INVALID, 0);
-}
-
-/*
- *  Peephole optimizer for finished bytecode.
- *
- *  Does not remove opcodes; currently only straightens out unconditional
- *  jump chains which are generated by several control structures.
- */
-
-DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx) {
-	duk_compiler_instr *bc;
-	duk_small_uint_t iter;
-	duk_int_t i, n;
-	duk_int_t count_opt;
-
-	bc = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code);
-#if defined(DUK_USE_BUFLEN16)
-	/* No need to assert, buffer size maximum is 0xffff. */
-#else
-	DUK_ASSERT((duk_size_t) DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr) <= (duk_size_t) DUK_INT_MAX);  /* bytecode limits */
-#endif
-	n = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr));
-
-	for (iter = 0; iter < DUK_COMPILER_PEEPHOLE_MAXITER; iter++) {
-		count_opt = 0;
-
-		for (i = 0; i < n; i++) {
-			duk_instr_t ins;
-			duk_int_t target_pc1;
-			duk_int_t target_pc2;
-
-			ins = bc[i].ins;
-			if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
-				continue;
-			}
-
-			target_pc1 = i + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;
-			DUK_DDD(DUK_DDDPRINT("consider jump at pc %ld; target_pc=%ld", (long) i, (long) target_pc1));
-			DUK_ASSERT(target_pc1 >= 0);
-			DUK_ASSERT(target_pc1 < n);
-
-			/* Note: if target_pc1 == i, we'll optimize a jump to itself.
-			 * This does not need to be checked for explicitly; the case
-			 * is rare and max iter breaks us out.
-			 */
-
-			ins = bc[target_pc1].ins;
-			if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
-				continue;
-			}
-
-			target_pc2 = target_pc1 + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;
-
-			DUK_DDD(DUK_DDDPRINT("optimizing jump at pc %ld; old target is %ld -> new target is %ld",
-			                     (long) i, (long) target_pc1, (long) target_pc2));
-
-			bc[i].ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, target_pc2 - (i + 1) + DUK_BC_JUMP_BIAS);
-
-			count_opt++;
-		}
-
-		DUK_DD(DUK_DDPRINT("optimized %ld jumps on peephole round %ld", (long) count_opt, (long) (iter + 1)));
-
-		if (count_opt == 0) {
-			break;
-		}
-	}
-}
-
-/*
- *  Intermediate value helpers
- */
-
-#define DUK__ISREG(comp_ctx,x)              (((x) & DUK__CONST_MARKER) == 0)
-#define DUK__ISCONST(comp_ctx,x)            (((x) & DUK__CONST_MARKER) != 0)
-#define DUK__ISTEMP(comp_ctx,x)             (DUK__ISREG((comp_ctx), (x)) && (duk_regconst_t) (x) >= (duk_regconst_t) ((comp_ctx)->curr_func.temp_first))
-#define DUK__GETTEMP(comp_ctx)              ((comp_ctx)->curr_func.temp_next)
-#define DUK__SETTEMP(comp_ctx,x)            ((comp_ctx)->curr_func.temp_next = (x))  /* dangerous: must only lower (temp_max not updated) */
-#define DUK__SETTEMP_CHECKMAX(comp_ctx,x)   duk__settemp_checkmax((comp_ctx),(x))
-#define DUK__ALLOCTEMP(comp_ctx)            duk__alloctemp((comp_ctx))
-#define DUK__ALLOCTEMPS(comp_ctx,count)     duk__alloctemps((comp_ctx),(count))
-
-/* Flags for intermediate value coercions.  A flag for using a forced reg
- * is not needed, the forced_reg argument suffices and generates better
- * code (it is checked as it is used).
- */
-#define DUK__IVAL_FLAG_ALLOW_CONST          (1 << 0)  /* allow a constant to be returned */
-#define DUK__IVAL_FLAG_REQUIRE_TEMP         (1 << 1)  /* require a (mutable) temporary as a result (or a const if allowed) */
-#define DUK__IVAL_FLAG_REQUIRE_SHORT        (1 << 2)  /* require a short (8-bit) reg/const which fits into bytecode B/C slot */
-
-/* XXX: some code might benefit from DUK__SETTEMP_IFTEMP(ctx,x) */
-
-#if 0  /* enable manually for dumping */
-#define DUK__DUMP_ISPEC(compctx,ispec) do { duk__dump_ispec((compctx), (ispec)); } while (0)
-#define DUK__DUMP_IVALUE(compctx,ivalue) do { duk__dump_ivalue((compctx), (ivalue)); } while (0)
-
-DUK_LOCAL void duk__dump_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *x) {
-	DUK_D(DUK_DPRINT("ispec dump: t=%ld regconst=0x%08lx, valstack_idx=%ld, value=%!T",
-	                 (long) x->t, (unsigned long) x->regconst, (long) x->valstack_idx,
-	                 duk_get_tval((duk_context *) comp_ctx->thr, x->valstack_idx)));
-}
-DUK_LOCAL void duk__dump_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *x) {
-	DUK_D(DUK_DPRINT("ivalue dump: t=%ld op=%ld "
-	                 "x1={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T} "
-	                 "x2={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T}",
-		         (long) x->t, (long) x->op,
-	                 (long) x->x1.t, (unsigned long) x->x1.regconst, (long) x->x1.valstack_idx,
-	                 duk_get_tval((duk_context *) comp_ctx->thr, x->x1.valstack_idx),
-	                 (long) x->x2.t, (unsigned long) x->x2.regconst, (long) x->x2.valstack_idx,
-	                 duk_get_tval((duk_context *) comp_ctx->thr, x->x2.valstack_idx)));
-}
-#else
-#define DUK__DUMP_ISPEC(comp_ctx,x) do {} while (0)
-#define DUK__DUMP_IVALUE(comp_ctx,x) do {} while (0)
-#endif
-
-DUK_LOCAL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst) {
-	duk_context *ctx = (duk_context *) comp_ctx->thr;
-
-	dst->t = src->t;
-	dst->regconst = src->regconst;
-	duk_copy(ctx, src->valstack_idx, dst->valstack_idx);
-}
-
-DUK_LOCAL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst) {
-	duk_context *ctx = (duk_context *) comp_ctx->thr;
-
-	dst->t = src->t;
-	dst->op = src->op;
-	dst->x1.t = src->x1.t;
-	dst->x1.regconst = src->x1.regconst;
-	dst->x2.t = src->x2.t;
-	dst->x2.regconst = src->x2.regconst;
-	duk_copy(ctx, src->x1.valstack_idx, dst->x1.valstack_idx);
-	duk_copy(ctx, src->x2.valstack_idx, dst->x2.valstack_idx);
-}
-
-/* XXX: to util */
-DUK_LOCAL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival) {
-	duk_small_int_t c;
-	duk_int32_t t;
-
-	c = DUK_FPCLASSIFY(x);
-	if (c == DUK_FP_NORMAL || (c == DUK_FP_ZERO && !DUK_SIGNBIT(x))) {
-		/* Don't allow negative zero as it will cause trouble with
-		 * LDINT+LDINTX.  But positive zero is OK.
-		 */
-		t = (duk_int32_t) x;
-		if ((duk_double_t) t == x) {
-			*ival = t;
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-DUK_LOCAL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num) {
-	duk_reg_t res;
-
-	res = comp_ctx->curr_func.temp_next;
-	comp_ctx->curr_func.temp_next += num;
-
-	if (comp_ctx->curr_func.temp_next > DUK__MAX_TEMPS) {  /* == DUK__MAX_TEMPS is OK */
-		DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_TEMP_LIMIT);
-	}
-
-	/* maintain highest 'used' temporary, needed to figure out nregs of function */
-	if (comp_ctx->curr_func.temp_next > comp_ctx->curr_func.temp_max) {
-		comp_ctx->curr_func.temp_max = comp_ctx->curr_func.temp_next;
-	}
-
-	return res;
-}
-
-DUK_LOCAL duk_reg_t duk__alloctemp(duk_compiler_ctx *comp_ctx) {
-	return duk__alloctemps(comp_ctx, 1);
-}
-
-DUK_LOCAL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next) {
-	comp_ctx->curr_func.temp_next = temp_next;
-	if (temp_next > comp_ctx->curr_func.temp_max) {
-		comp_ctx->curr_func.temp_max = temp_next;
-	}
-}
-
-/* get const for value at valstack top */
-DUK_LOCAL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx) {
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-	duk_compiler_func *f = &comp_ctx->curr_func;
-	duk_tval *tv1;
-	duk_int_t i, n, n_check;
-
-	n = (duk_int_t) duk_get_length(ctx, f->consts_idx);
-
-	tv1 = DUK_GET_TVAL_NEGIDX(ctx, -1);
-	DUK_ASSERT(tv1 != NULL);
-
-#if defined(DUK_USE_FASTINT)
-	/* Explicit check for fastint downgrade. */
-	DUK_TVAL_CHKFAST_INPLACE(tv1);
-#endif
-
-	/* Sanity workaround for handling functions with a large number of
-	 * constants at least somewhat reasonably.  Otherwise checking whether
-	 * we already have the constant would grow very slow (as it is O(N^2)).
-	 */
-	n_check = (n > DUK__GETCONST_MAX_CONSTS_CHECK ? DUK__GETCONST_MAX_CONSTS_CHECK : n);
-	for (i = 0; i < n_check; i++) {
-		duk_tval *tv2 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, f->h_consts, i);
-
-		/* Strict equality is NOT enough, because we cannot use the same
-		 * constant for e.g. +0 and -0.
-		 */
-		if (duk_js_samevalue(tv1, tv2)) {
-			DUK_DDD(DUK_DDDPRINT("reused existing constant for %!T -> const index %ld",
-			                     (duk_tval *) tv1, (long) i));
-			duk_pop(ctx);
-			return (duk_regconst_t) (i | DUK__CONST_MARKER);
-		}
-	}
-
-	if (n > DUK__MAX_CONSTS) {
-		DUK_ERROR_RANGE(comp_ctx->thr, DUK_STR_CONST_LIMIT);
-	}
-
-	DUK_DDD(DUK_DDDPRINT("allocating new constant for %!T -> const index %ld",
-	                     (duk_tval *) tv1, (long) n));
-	(void) duk_put_prop_index(ctx, f->consts_idx, n);  /* invalidates tv1, tv2 */
-	return (duk_regconst_t) (n | DUK__CONST_MARKER);
-}
-
-/* Get the value represented by an duk_ispec to a register or constant.
- * The caller can control the result by indicating whether or not:
- *
- *   (1) a constant is allowed (sometimes the caller needs the result to
- *       be in a register)
- *
- *   (2) a temporary register is required (usually when caller requires
- *       the register to be safely mutable; normally either a bound
- *       register or a temporary register are both OK)
- *
- *   (3) a forced register target needs to be used
- *
- * Bytecode may be emitted to generate the necessary value.  The return
- * value is either a register or a constant.
- */
-
-DUK_LOCAL
-duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx,
-                                         duk_ispec *x,
-                                         duk_reg_t forced_reg,
-                                         duk_small_uint_t flags) {
-	duk_hthread *thr = comp_ctx->thr;
-	duk_context *ctx = (duk_context *) thr;
-
-	DUK_DDD(DUK_DDDPRINT("duk__ispec_toregconst_raw(): x={%ld:%ld:%!T}, "
-	                     "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
-	                     (long) x->t,
-	                     (long) x->regconst,
-	                     (duk_tval *) duk_get_tval(ctx, x->valstack_idx),
-	                     (long) forced_reg,
-	                     (unsigned long) flags,
-	                     (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0),
-	                     (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0),
-	                     (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0)));
-
-	switch (x->t) {
-	case DUK_ISPEC_VALUE: {
-		duk_tval *tv;
-
-		tv = DUK_GET_TVAL_POSIDX(ctx, x->valstack_idx);
-		DUK_ASSERT(tv != NULL);
-
-		switch (DUK_TVAL_GET_TAG(tv)) {
-		case DUK_TAG_UNDEFINED: {
-			/* Note: although there is no 'undefined' literal, undefined
-			 * values can occur during compilation as a result of e.g.
-			 * the 'void' operator.
-			 */
-			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-			duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDUNDEF, (duk_regconst_t) dest);
-			return (duk_regconst_t) dest;
-		}
-		case DUK_TAG_NULL: {
-			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-			duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDNULL, (duk_regconst_t) dest);
-			return (duk_regconst_t) dest;
-		}
-		case DUK_TAG_BOOLEAN: {
-			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-			duk__emit_extraop_bc(comp_ctx,
-			                     (DUK_TVAL_GET_BOOLEAN(tv) ? DUK_EXTRAOP_LDTRUE : DUK_EXTRAOP_LDFALSE),
-			                     (duk_regconst_t) dest);
-			return (duk_regconst_t) dest;
-		}
-		case DUK_TAG_POINTER: {
-			DUK_UNREACHABLE();
-			break;
-		}
-		case DUK_TAG_STRING: {
-			duk_hstring *h;
-			duk_reg_t dest;
-			duk_regconst_t constidx;
-
-			h = DUK_TVAL_GET_STRING(tv);
-			DUK_UNREF(h);
-			DUK_ASSERT(h != NULL);
-
-#if 0  /* XXX: to be implemented? */
-			/* Use special opcodes to load short strings */
-			if (DUK_HSTRING_GET_BYTELEN(h) <= 2) {
-				/* Encode into a single opcode (18 bits can encode 1-2 bytes + length indicator) */
-			} else if (DUK_HSTRING_GET_BYTELEN(h) <= 6) {
-				/* Encode into a double constant (53 bits can encode 6*8 = 48 bits + 3-bit length */
-			}
-#endif
-			duk_dup(ctx, x->valstack_idx);
-			constidx = duk__getconst(comp_ctx);
-
-			if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
-				return constidx;
-			}
-
-			dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-			duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
-			return (duk_regconst_t) dest;
-		}
-		case DUK_TAG_OBJECT: {
-			DUK_UNREACHABLE();
-			break;
-		}
-		case DUK_TAG_BUFFER: {
-			DUK_UNREACHABLE();
-			break;
-		}
-		case DUK_TAG_LIGHTFUNC: {
-			DUK_UNREACHABLE();
-			break;
-		}
-#if defined(DUK_USE_FASTINT)
-		case DUK_TAG_FASTINT:
-#endif
-		default: {
-			/* number */
-			duk_reg_t dest;
-			duk_regconst_t constidx;
-			duk_double_t dval;
-			duk_int32_t ival;
-
-			DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
-			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-			dval = DUK_TVAL_GET_NUMBER(tv);
-
-			if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
-				/* A number can be loaded either through a constant, using
-				 * LDINT, or using LDINT+LDINTX.  LDINT is always a size win,
-				 * LDINT+LDINTX is not if the constant is used multiple times.
-				 * Currently always prefer LDINT+LDINTX over a double constant.
-				 */
-
-				if (duk__is_whole_get_int32(dval, &ival)) {
-					dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-					duk__emit_load_int32(comp_ctx, dest, ival);
-					return (duk_regconst_t) dest;
-				}
-			}
-
-			duk_dup(ctx, x->valstack_idx);
-			constidx = duk__getconst(comp_ctx);
-
-			if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
-				return constidx;
-			} else {
-				dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-				duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
-				return (duk_regconst_t) dest;
-			}
-		}
-		}  /* end switch */
-	}
-	case DUK_ISPEC_REGCONST: {
-		if (forced_reg >= 0) {
-			if (x->regconst & DUK__CONST_MARKER) {
-				duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, forced_reg, x->regconst);
-			} else if (x->regconst != (duk_regconst_t) forced_reg) {
-				duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst);
-			} else {
-				; /* already in correct reg */
-			}
-			return (duk_regconst_t) forced_reg;
-		}
-
-		DUK_ASSERT(forced_reg < 0);
-		if (x->regconst & DUK__CONST_MARKER) {
-			if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
-				duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
-				duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, x->regconst);
-				return (duk_regconst_t) dest;
-			}
-			return x->regconst;
-		}
-
-		DUK_ASSERT(forced_reg < 0 && !(x->regconst & DUK__CONST_MARKER));
-		if ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) && !DUK__ISTEMP(comp_ctx, x->regconst)) {
-			duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
-

<TRUNCATED>

Mime
View raw message