/*
    * Copyright (C) 2020-2021 Jo-Philipp Wich <jo@mein.io>
    *
    * Permission to use, copy, modify, and/or distribute this software for any
    * purpose with or without fee is hereby granted, provided that the above
    * copyright notice and this permission notice appear in all copies.
    *
    * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  
  #include <assert.h>
  #include <errno.h>
  
  #include "ucode/internal/compiler.h"
  #include "ucode/internal/chunk.h"
  #include "ucode/internal/vm.h" /* ISA: I_*, uc_vm_insn_t */
  #include "ucode/internal/program.h"
  #include "ucode/internal/lib.h" /* uc_error_context_format() */
  
  #ifndef NO_COMPILE
  
  static void uc_compiler_compile_unary(uc_compiler_t *compiler);
  static void uc_compiler_compile_binary(uc_compiler_t *compiler);
  static void uc_compiler_compile_delete(uc_compiler_t *compiler);
  static void uc_compiler_compile_typeof(uc_compiler_t *compiler);
  static void uc_compiler_compile_importcall(uc_compiler_t *compiler);
  static void uc_compiler_compile_paren(uc_compiler_t *compiler);
  static void uc_compiler_compile_call(uc_compiler_t *compiler);
  static void uc_compiler_compile_post_inc(uc_compiler_t *compiler);
  static void uc_compiler_compile_constant(uc_compiler_t *compiler);
  static void uc_compiler_compile_template(uc_compiler_t *compiler);
  static void uc_compiler_compile_comma(uc_compiler_t *compiler);
  static void uc_compiler_compile_labelexpr(uc_compiler_t *compiler);
  static void uc_compiler_compile_funcexpr(uc_compiler_t *compiler);
  static void uc_compiler_compile_and(uc_compiler_t *compiler);
  static void uc_compiler_compile_or(uc_compiler_t *compiler);
  static void uc_compiler_compile_nullish(uc_compiler_t *compiler);
  static void uc_compiler_compile_dot(uc_compiler_t *compiler);
  static void uc_compiler_compile_subscript(uc_compiler_t *compiler);
  static void uc_compiler_compile_ternary(uc_compiler_t *compiler);
  static void uc_compiler_compile_array(uc_compiler_t *compiler);
  static void uc_compiler_compile_object(uc_compiler_t *compiler);
  
  static bool uc_compiler_compile_destructuring(uc_compiler_t *compiler);
  static void uc_compiler_compile_destructuring_declaration(uc_compiler_t *compiler, bool constant);
  
  static uc_tokentype_t uc_compiler_compile_declaration(uc_compiler_t *compiler);
  static uc_tokentype_t uc_compiler_compile_statement(uc_compiler_t *compiler);
  static uc_tokentype_t uc_compiler_compile_expstmt(uc_compiler_t *compiler);
  
  static uc_parse_rule_t
  uc_compiler_parse_rules[TK_ERROR + 1] = {
          [TK_LPAREN]             = { uc_compiler_compile_paren, uc_compiler_compile_call, P_CALL },
          [TK_QLPAREN]    = { NULL, uc_compiler_compile_call, P_CALL },
          [TK_SUB]                = { uc_compiler_compile_unary, uc_compiler_compile_binary, P_ADD },
          [TK_ADD]                = { uc_compiler_compile_unary, uc_compiler_compile_binary, P_ADD },
          [TK_COMPL]              = { uc_compiler_compile_unary, NULL, P_UNARY },
          [TK_NOT]                = { uc_compiler_compile_unary, NULL, P_UNARY },
          [TK_DELETE]             = { uc_compiler_compile_delete, NULL, P_UNARY },
          [TK_TYPEOF]             = { uc_compiler_compile_typeof, NULL, P_UNARY },
          [TK_IMPORT]             = { uc_compiler_compile_importcall, NULL, P_UNARY },
          [TK_INC]                = { uc_compiler_compile_unary, uc_compiler_compile_post_inc, P_INC },
          [TK_DEC]                = { uc_compiler_compile_unary, uc_compiler_compile_post_inc, P_INC },
          [TK_DIV]                = { NULL, uc_compiler_compile_binary, P_MUL },
          [TK_MUL]                = { NULL, uc_compiler_compile_binary, P_MUL },
          [TK_MOD]                = { NULL, uc_compiler_compile_binary, P_MUL },
          [TK_EXP]                = { NULL, uc_compiler_compile_binary, P_EXP },
          [TK_NUMBER]             = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_DOUBLE]             = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_STRING]             = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_TRUE]               = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_FALSE]              = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_NULL]               = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_THIS]               = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_REGEXP]             = { uc_compiler_compile_constant, NULL, P_NONE },
          [TK_TEMPLATE]   = { uc_compiler_compile_template, NULL, P_NONE },
          [TK_COMMA]              = { NULL, uc_compiler_compile_comma, P_COMMA },
          [TK_LABEL]              = { uc_compiler_compile_labelexpr, NULL, P_NONE },
          [TK_FUNC]               = { uc_compiler_compile_funcexpr, NULL, P_NONE },
          [TK_AND]                = { NULL, uc_compiler_compile_and, P_AND },
          [TK_OR]                 = { NULL, uc_compiler_compile_or, P_OR },
          [TK_NULLISH]    = { NULL, uc_compiler_compile_nullish, P_OR },
          [TK_BOR]                = { NULL, uc_compiler_compile_binary, P_BOR },
          [TK_BXOR]               = { NULL, uc_compiler_compile_binary, P_BXOR },
          [TK_BAND]               = { NULL, uc_compiler_compile_binary, P_BAND },
          [TK_EQ]                 = { NULL, uc_compiler_compile_binary, P_EQUAL },
          [TK_EQS]                = { NULL, uc_compiler_compile_binary, P_EQUAL },
          [TK_NE]                 = { NULL, uc_compiler_compile_binary, P_EQUAL },
          [TK_NES]                = { NULL, uc_compiler_compile_binary, P_EQUAL },
          [TK_LT]                 = { NULL, uc_compiler_compile_binary, P_COMPARE },
          [TK_LE]                 = { NULL, uc_compiler_compile_binary, P_COMPARE },
          [TK_GT]                 = { NULL, uc_compiler_compile_binary, P_COMPARE },
          [TK_GE]                 = { NULL, uc_compiler_compile_binary, P_COMPARE },
         [TK_IN]                 = { NULL, uc_compiler_compile_binary, P_COMPARE },
         [TK_LSHIFT]             = { NULL, uc_compiler_compile_binary, P_SHIFT },
         [TK_RSHIFT]             = { NULL, uc_compiler_compile_binary, P_SHIFT },
         [TK_DOT]                = { NULL, uc_compiler_compile_dot, P_CALL },
         [TK_QDOT]               = { NULL, uc_compiler_compile_dot, P_CALL },
         [TK_LBRACK]             = { uc_compiler_compile_array, uc_compiler_compile_subscript, P_CALL },
         [TK_QLBRACK]    = { NULL, uc_compiler_compile_subscript, P_CALL },
         [TK_QMARK]              = { NULL, uc_compiler_compile_ternary, P_TERNARY },
         [TK_LBRACE]             = { uc_compiler_compile_object, NULL, P_NONE },
 };
 
 static ssize_t
 uc_compiler_declare_local(uc_compiler_t *compiler, uc_value_t *name, bool constant);
 
 static ssize_t
 uc_compiler_initialize_local(uc_compiler_t *compiler);
 
 static bool
 uc_compiler_exprstack_is(uc_compiler_t *compiler, uc_exprflag_t flag)
 {
         uc_exprstack_t *expr;
 
         for (expr = compiler->exprstack; expr; expr = expr->parent)
                 if (expr->flags & flag)
                         return true;
 
         return false;
 }
 
 static void
 uc_compiler_init(uc_compiler_t *compiler, const char *name, uc_source_t *source, size_t srcpos, uc_program_t *program, bool strict)
 {
         uc_value_t *varname = ucv_string_new("(callee)");
         uc_function_t *fn;
 
         compiler->scope_depth = 0;
         compiler->try_depth = 0;
 
         compiler->program = program;
         compiler->function = uc_program_function_new(program, name, source, srcpos);
 
         compiler->locals.count = 0;
         compiler->locals.entries = NULL;
 
         compiler->upvals.count = 0;
         compiler->upvals.entries = NULL;
 
         compiler->patchlist = NULL;
 
         compiler->parent = NULL;
 
         compiler->current_srcpos = srcpos;
         compiler->tailcall_off = SIZE_MAX;
 
         fn = (uc_function_t *)compiler->function;
         fn->strict = strict;
 
         /* reserve stack slot 0 */
         uc_compiler_declare_local(compiler, varname, false);
         uc_compiler_initialize_local(compiler);
         ucv_put(varname);
 }
 
 static uc_chunk_t *
 uc_compiler_current_chunk(uc_compiler_t *compiler)
 {
         uc_function_t *fn = (uc_function_t *)compiler->function;
 
         return &fn->chunk;
 }
 
 static uc_source_t *
 uc_compiler_current_source(uc_compiler_t *compiler)
 {
         return uc_program_function_source(compiler->function);
 }
 
 __attribute__((format(printf, 3, 0))) static void
 uc_compiler_syntax_error(uc_compiler_t *compiler, size_t off, const char *fmt, ...)
 {
         uc_source_t *source = uc_compiler_current_source(compiler);
         uc_stringbuf_t *buf = compiler->parser->error;
         size_t line = 0, byte = 0, len = 0, startoff = 0, endoff = 0;
         va_list ap;
         char *s;
 
         if (compiler->parser->synchronizing)
                 return;
 
         compiler->parser->synchronizing = true;
 
         if (!buf)
                 buf = compiler->parser->error = xprintbuf_new();
 
         if (!off)
                 off = uc_program_function_srcpos(compiler->function,
                         uc_compiler_current_chunk(compiler)->count);
 
         byte = off;
         line = uc_source_get_line(source, &byte);
 
         va_start(ap, fmt);
         len = xvasprintf(&s, fmt, ap);
         va_end(ap);
 
         ucv_stringbuf_append(buf, "Syntax error: ");
         ucv_stringbuf_addstr(buf, s, len);
         ucv_stringbuf_append(buf, "\n");
 
         free(s);
 
         if (line) {
                 ucv_stringbuf_append(buf, "In ");
 
                 if (compiler->program->sources.count > 1) {
                         len = strlen(source->filename);
 
                         if (len > 48)
                                 ucv_stringbuf_printf(buf, "...%s", source->filename + len - 45);
                         else
                                 ucv_stringbuf_addstr(buf, source->filename, len);
 
                         ucv_stringbuf_append(buf, ", ");
                 }
 
                 ucv_stringbuf_printf(buf, "line %zu, byte %zu:\n", line, byte);
         }
 
         /* underline the innermost statement being compiled rather than pointing at
          * the offending token alone; SIZE_MAX lies beyond the last instruction, so
          * no closed statement can cover it and the lookup comes down to the one
          * still open, i.e. the statement which the error aborted. Left at zero, and
          * so ignored, when there is no such statement. */
         uc_program_function_stmt_bounds(compiler->function, SIZE_MAX, &startoff, &endoff);
 
         if (uc_error_context_format(buf, source, NULL, startoff, endoff, off))
                 ucv_stringbuf_append(buf, "\n\n");
 }
 
 static size_t
 uc_compiler_set_srcpos(uc_compiler_t *compiler, size_t srcpos)
 {
         size_t delta;
 
         /* ensure that lines counts are strictly increasing */
         assert(srcpos == 0 || srcpos >= compiler->current_srcpos ||
                compiler->parser->error);
 
         /* after a syntax error, code may be emitted for tokens in front of the
          * current position, e.g. after the expression of a template literal
          * placeholder has been terminated prematurely. The generated code is
          * discarded, but a negative offset would be taken for an enormous one */
         if (srcpos < compiler->current_srcpos)
                 srcpos = 0;
 
         delta = srcpos ? srcpos - compiler->current_srcpos : 0;
         compiler->current_srcpos += delta;
 
         return delta;
 }
 
 static void
 uc_compiler_parse_advance(uc_compiler_t *compiler)
 {
         ucv_put(compiler->parser->prev.uv);
         compiler->parser->prev = compiler->parser->curr;
 
         while (true) {
                 uc_token_t *tok = uc_lexer_next_token(&compiler->parser->lex);
 
                 if (tok->type == TK_COMMENT || tok->type == TK_LSTM) {
                         ucv_put(tok->uv);
                         continue;
                 }
                 else if (tok->type == TK_RSTM) {
                         tok->type = TK_SCOL;
                 }
 
                 compiler->parser->curr = *tok;
 
                 if (compiler->parser->curr.type != TK_ERROR)
                         break;
 
                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "%s",
                         ucv_string_get(compiler->parser->curr.uv));
 
                 ucv_put(compiler->parser->curr.uv);
                 compiler->parser->curr.uv = NULL;
         }
 }
 
 static void
 uc_compiler_parse_consume(uc_compiler_t *compiler, uc_tokentype_t type)
 {
         if (compiler->parser->curr.type == type) {
                 uc_compiler_parse_advance(compiler);
 
                 return;
         }
 
         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                 "Unexpected token\nExpecting %s", uc_tokenname(type));
 }
 
 static bool
 uc_compiler_parse_check(uc_compiler_t *compiler, uc_tokentype_t type)
 {
         return (compiler->parser->curr.type == type);
 }
 
 static bool
 uc_compiler_parse_match(uc_compiler_t *compiler, uc_tokentype_t type)
 {
         if (!uc_compiler_parse_check(compiler, type))
                 return false;
 
         uc_compiler_parse_advance(compiler);
 
         return true;
 }
 
 static bool
 uc_compiler_keyword_check(uc_compiler_t *compiler, const char *keyword)
 {
         size_t keywordlen = strlen(keyword);
 
         return (compiler->parser->curr.type == TK_LABEL &&
                 ucv_string_length(compiler->parser->curr.uv) == keywordlen &&
                 strcmp(ucv_string_get(compiler->parser->curr.uv), keyword) == 0);
 }
 
 static bool
 uc_compiler_keyword_match(uc_compiler_t *compiler, const char *keyword)
 {
         if (!uc_compiler_keyword_check(compiler, keyword))
                 return false;
 
         uc_compiler_parse_advance(compiler);
 
         return true;
 }
 
 static void
 uc_compiler_keyword_consume(uc_compiler_t *compiler, const char *keyword)
 {
         if (uc_compiler_keyword_check(compiler, keyword)) {
                 uc_compiler_parse_advance(compiler);
 
                 return;
         }
 
         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                 "Unexpected token\nExpecting '%s'", keyword);
 }
 
 static void
 uc_compiler_parse_synchronize(uc_compiler_t *compiler)
 {
         compiler->parser->synchronizing = false;
 
         while (compiler->parser->curr.type != TK_EOF) {
                 if (compiler->parser->prev.type == TK_SCOL)
                         return;
 
                 switch (compiler->parser->curr.type) {
                 case TK_IF:
                 case TK_FOR:
                 case TK_WHILE:
                 case TK_SWITCH:
                 case TK_FUNC:
                 case TK_TRY:
                 case TK_RETURN:
                 case TK_BREAK:
                 case TK_CONTINUE:
                 case TK_LOCAL:
                         return;
 
                 default:
                         break;
                 }
 
                 uc_compiler_parse_advance(compiler);
         }
 }
 
 static uc_parse_rule_t *
 uc_compiler_parse_rule(uc_tokentype_t type)
 {
         return &uc_compiler_parse_rules[type];
 }
 
 static bool
 uc_compiler_parse_at_assignment_op(uc_compiler_t *compiler)
 {
         switch (compiler->parser->curr.type) {
         case TK_ASBAND:
         case TK_ASBXOR:
         case TK_ASBOR:
         case TK_ASLEFT:
         case TK_ASRIGHT:
         case TK_ASMUL:
         case TK_ASDIV:
         case TK_ASMOD:
         case TK_ASADD:
         case TK_ASSUB:
         case TK_ASAND:
         case TK_ASOR:
         case TK_ASEXP:
         case TK_ASNULLISH:
         case TK_ASSIGN:
                 return true;
 
         default:
                 return false;
         }
 }
 
 static void
 uc_compiler_backpatch(uc_compiler_t *compiler, size_t break_addr, size_t next_addr);
 
 static void
 uc_compiler_parse_precedence_for_token(uc_compiler_t *compiler, uc_precedence_t precedence, uc_token_t *token)
 {
         uc_parse_rule_t *rule;
 
         rule = uc_compiler_parse_rule(token->type);
 
         if (!rule->prefix) {
                 uc_compiler_syntax_error(compiler, token->pos, "Expecting expression");
 
                 return;
         }
 
         uc_compiler_exprstack_push(compiler, token->type,
                 (precedence <= P_ASSIGN) ? F_ASSIGNABLE : 0);
 
         compiler->patchlist = &(uc_patchlist_t){
                 .parent = compiler->patchlist,
                 .token = TK_EXP,
         };
 
         rule->prefix(compiler);
 
         while (precedence <= uc_compiler_parse_rule(compiler->parser->curr.type)->precedence) {
                 compiler->exprstack->token = compiler->parser->curr.type;
 
                 rule = uc_compiler_parse_rule(compiler->exprstack->token);
 
                 if (!rule->infix) {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting ';' or binary operator");
                         uc_compiler_parse_advance(compiler);
 
                         uc_compiler_backpatch(compiler, compiler->patchlist->depth, 0);
                         uc_compiler_exprstack_pop(compiler);
 
                         return;
                 }
 
                 /* allow reserved words in property accessors */
                 if (rule->infix == uc_compiler_compile_dot)
                         compiler->parser->lex.no_keyword = true;
 
                 uc_compiler_parse_advance(compiler);
 
                 rule->infix(compiler);
         }
 
         uc_compiler_backpatch(compiler, compiler->patchlist->depth, 0);
 
         uc_compiler_exprstack_pop(compiler);
 }
 
 static void
 uc_compiler_parse_precedence(uc_compiler_t *compiler, uc_precedence_t precedence)
 {
         uc_token_t token = compiler->parser->curr;
         uc_parse_rule_t *rule = uc_compiler_parse_rule(token.type);
 
         /* allow reserved words as property names in object literals */
         if (rule->prefix == uc_compiler_compile_object)
                 compiler->parser->lex.no_keyword = true;
 
         /* unless a sub-expression follows, treat subsequent slash as division
          * operator and not as beginning of regexp literal */
         if (rule->prefix != uc_compiler_compile_paren &&
             rule->prefix != uc_compiler_compile_unary &&
             rule->prefix != uc_compiler_compile_array)
                 compiler->parser->lex.no_regexp = true;
 
         uc_compiler_parse_advance(compiler);
         uc_compiler_parse_precedence_for_token(compiler, precedence, &token);
 }
 
 static size_t
 uc_compiler_reladdr32(uc_compiler_t *compiler, size_t from, size_t to)
 {
         ssize_t delta = to - from;
 
         if (delta < -0x7fffffff || delta > 0x7fffffff) {
                 uc_compiler_syntax_error(compiler, 0, "Jump address too far");
 
                 return 0;
         }
 
         return (size_t)(delta + 0x7fffffff);
 }
 
 static void
 uc_compiler_emit_stmt_start(uc_compiler_t *compiler, uc_token_t *tok)
 {
         uc_chunk_stmt_start(
                 uc_compiler_current_chunk(compiler),
                 uc_compiler_set_srcpos(compiler, tok->pos));
 }
 
 static void
 uc_compiler_emit_stmt_end(uc_compiler_t *compiler)
 {
         uc_chunk_stmt_end(
                 uc_compiler_current_chunk(compiler),
                 uc_compiler_set_srcpos(compiler, compiler->parser->prev.end));
 }
 
 static size_t
 uc_compiler_reladdr16(uc_compiler_t *compiler, size_t from, size_t to)
 {
         ssize_t delta = to - from;
 
         if (delta < -0x7fff || delta > 0x7fff) {
                 uc_compiler_syntax_error(compiler, 0, "Jump address too far");
 
                 return 0;
         }
 
         return (size_t)(delta + 0x7fff);
 }
 
 static size_t
 uc_compiler_emit_insn(uc_compiler_t *compiler, size_t srcpos, uc_vm_insn_t insn)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos);
 
         compiler->last_insn = uc_chunk_add(chunk, (uint8_t)insn, lineoff);
 
         return compiler->last_insn;
 }
 
 static size_t
 uc_compiler_emit_u8(uc_compiler_t *compiler, size_t srcpos, uint8_t n)
 {
         return uc_chunk_add(
                 uc_compiler_current_chunk(compiler),
                 n,
                 uc_compiler_set_srcpos(compiler, srcpos));
 }
 
 static size_t
 uc_compiler_emit_u16(uc_compiler_t *compiler, size_t srcpos, uint16_t n)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos);
 
         uc_chunk_add(chunk, n / 0x100, lineoff);
         uc_chunk_add(chunk, n % 0x100, 0);
 
         return chunk->count - 2;
 }
 
 static size_t
 uc_compiler_emit_u32(uc_compiler_t *compiler, size_t srcpos, uint32_t n)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos);
 
         uc_chunk_add(chunk, n / 0x1000000, lineoff);
         uc_chunk_add(chunk, (n / 0x10000) % 0x100, 0);
         uc_chunk_add(chunk, (n / 0x100) % 0x100, 0);
         uc_chunk_add(chunk, n % 0x100, 0);
 
         return chunk->count - 4;
 }
 
 static size_t
 uc_compiler_emit_s32(uc_compiler_t *compiler, size_t srcpos, int32_t n)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos);
         uint32_t v;
 
         if (n <= 0)
                 v = n + 0x7fffffff;
         else
                 v = (uint32_t)n + 0x7fffffff;
 
         uc_chunk_add(chunk, v / 0x1000000, lineoff);
         uc_chunk_add(chunk, (v / 0x10000) % 0x100, 0);
         uc_chunk_add(chunk, (v / 0x100) % 0x100, 0);
         uc_chunk_add(chunk, v % 0x100, 0);
 
         return chunk->count - 4;
 }
 
 static uint32_t
 uc_compiler_get_u32(uc_compiler_t *compiler, size_t off)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         return chunk->entries[off + 0] * 0x1000000 +
                chunk->entries[off + 1] * 0x10000 +
                chunk->entries[off + 2] * 0x100 +
                chunk->entries[off + 3];
 }
 
 static void
 uc_compiler_set_u32(uc_compiler_t *compiler, size_t off, uint32_t n)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         chunk->entries[off + 0] = n / 0x1000000;
         chunk->entries[off + 1] = (n / 0x10000) % 0x100;
         chunk->entries[off + 2] = (n / 0x100) % 0x100;
         chunk->entries[off + 3] = n % 0x100;
 }
 
 /* Returns true if the most recently emitted instruction sequence is a function
  * call whose operands end exactly at the current end of the chunk, i.e. the call
  * is the last thing compiled before the upcoming return. */
 static bool
 uc_compiler_last_insn_is_tailcall(uc_compiler_t *compiler)
 {
         /* tailcall_off records the chunk end right after the last emitted call's
          * operands; it is a tail call candidate only if nothing has been compiled
          * since, so it must equal the current chunk end */
         return compiler->tailcall_off ==
                 uc_compiler_current_chunk(compiler)->count;
 }
 
 /* Invoking a function in tail position allows the VM to reuse the current call
  * frame for the callee, which permits unbounded tail recursion.
  *
  * A function call in return position is marked by emitting a 0x00 marker byte
  * immediately after the enclosing I_RETURN. The VM recognizes a call whose
  * operands are followed by I_RETURN + marker as a tail call and reuses the
  * current frame for the callee.
  *
  * The marker is placed after the return so that neither VM ever executes it:
  * older VMs return (and unwind) before reaching it, and the optimized VM jumps
  * to the callee at the call site. It is therefore pure data, and the emitted
  * bytecode remains compatible with interpreters predating tail call
  * optimization.
  *
  * uc_compiler_tailcall_pending() must be called before the I_RETURN is emitted
  * (while the call is still the last instruction); if it returns true, the
  * caller must emit the I_RETURN and then uc_compiler_emit_tailcall_marker(). */
 
 static bool
 uc_compiler_tailcall_pending(uc_compiler_t *compiler)
 {
         /* an enclosing try block might need to catch exceptions raised by the
          * invoked function, which requires the current frame to stay in place */
         if (compiler->try_depth > 0)
                 return false;
 
         return uc_compiler_last_insn_is_tailcall(compiler);
 }
 
 static void
 uc_compiler_emit_tailcall_marker(uc_compiler_t *compiler)
 {
         uc_chunk_add(uc_compiler_current_chunk(compiler), 0x00, 0);
 }
 
 static size_t
 uc_compiler_emit_constant_index(uc_compiler_t *compiler, size_t srcpos, uc_value_t *val)
 {
         size_t cidx = uc_program_add_constant(compiler->program, val);
 
         uc_compiler_emit_u32(compiler, srcpos, cidx);
 
         return cidx;
 }
 
 static size_t
 uc_compiler_emit_constant(uc_compiler_t *compiler, size_t srcpos, uc_value_t *val)
 {
         size_t cidx;
 
         uc_compiler_emit_insn(compiler, srcpos, I_LOAD);
 
         cidx = uc_compiler_emit_constant_index(compiler, srcpos, val);
 
         return cidx;
 }
 
 static size_t
 uc_compiler_emit_regexp(uc_compiler_t *compiler, size_t srcpos, uc_value_t *val)
 {
         size_t cidx = uc_program_add_constant(compiler->program, val);
 
         uc_compiler_emit_insn(compiler, srcpos, I_LREXP);
         uc_compiler_emit_u32(compiler, 0, cidx);
 
         return cidx;
 }
 
 static size_t
 uc_compiler_emit_jmp(uc_compiler_t *compiler, size_t srcpos)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         uc_compiler_emit_insn(compiler, srcpos, I_JMP);
         uc_compiler_emit_u32(compiler, 0, 0);
 
         return chunk->count - 5;
 }
 
 static size_t
 uc_compiler_emit_jmpz(uc_compiler_t *compiler, size_t srcpos)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         uc_compiler_emit_insn(compiler, srcpos, I_JMPZ);
         uc_compiler_emit_u32(compiler, 0, 0);
 
         return chunk->count - 5;
 }
 
 static size_t
 uc_compiler_emit_jmp_dest(uc_compiler_t *compiler, size_t srcpos, uint32_t dest)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         uc_compiler_emit_insn(compiler, srcpos, I_JMP);
         uc_compiler_emit_u32(compiler, 0, uc_compiler_reladdr32(compiler, chunk->count - 1, dest));
 
         return chunk->count - 5;
 }
 
 static size_t
 uc_compiler_emit_jmpnt(uc_compiler_t *compiler, size_t srcpos, uint16_t types, uint8_t depth)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         uc_vector_push(compiler->patchlist,
                 uc_compiler_emit_insn(compiler, srcpos, I_JMPNT));
 
         uc_compiler_emit_u32(compiler, 0,
                 uc_compiler_reladdr16(compiler, 0, TK_BREAK)
                         | ((types & 0x1fff) << 16)
                         | ((depth & 0x7) << 29));
 
         return chunk->count - 5;
 }
 
 static size_t
 uc_compiler_emit_copy(uc_compiler_t *compiler, size_t srcpos, uint8_t depth)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         uc_compiler_emit_insn(compiler, srcpos, I_COPY);
         uc_compiler_emit_u8(compiler, 0, depth);
 
         return chunk->count - 2;
 }
 
 /* Invoke a standard library function by slot: the arguments are the values on
  * the stack, the result is pushed back.
  *
  * Naming the slot of uc_stdlib_functions[] with a uc_stdlib_fn_t value instead
  * of looking the function up in the runtime namespace keeps such a call
  * independent of user code shadowing its name, and makes the callee readable
  * in the emitted code; an empty or stale slot is reported by the VM at the
  * instruction. */
 static void
 uc_compiler_emit_stcall(uc_compiler_t *compiler, size_t srcpos, size_t slot, size_t nargs)
 {
         assert(slot <= 0xffff && nargs <= 0xffff);
 
         /* the instruction is newer than the oldest bytecode this release writes, so
          * record that this program cannot be run by a VM predating it */
         uc_program_require_version(compiler->program, UCODE_BYTECODE_VERSION);
 
         uc_compiler_emit_insn(compiler, srcpos, I_STCALL);
         uc_compiler_emit_u32(compiler, 0, ((uint32_t)slot << 16) | (uint32_t)nargs);
 }
 
 static ssize_t
 uc_compiler_get_jmpaddr(uc_compiler_t *compiler, size_t off)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t width = (chunk->entries[off] == I_JMPNT) ? 2 : 4;
 
         assert(chunk->entries[off] == I_JMP || chunk->entries[off] == I_JMPZ || chunk->entries[off] == I_JMPNT);
         assert(off + 4 < chunk->count);
 
         if (width == 2)
                 return (
                         chunk->entries[off + 3] * 0x100UL +
                         chunk->entries[off + 4]
                 ) - 0x7fff;
         else
                 return (
                         chunk->entries[off + 1] * 0x1000000UL +
                         chunk->entries[off + 2] * 0x10000UL +
                         chunk->entries[off + 3] * 0x100UL +
                         chunk->entries[off + 4]
                 ) - 0x7fffffff;
 }
 
 static void
 uc_compiler_set_jmpaddr(uc_compiler_t *compiler, size_t off, uint32_t dest)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t width = (chunk->entries[off] == I_JMPNT) ? 2 : 4;
         size_t addr;
 
         assert(chunk->entries[off] == I_JMP || chunk->entries[off] == I_JMPZ || chunk->entries[off] == I_JMPNT);
         assert(off + 4 < chunk->count);
 
         if (width == 2) {
                 addr = uc_compiler_reladdr16(compiler, off, dest);
                 chunk->entries[off + 3] = addr / 0x100;
                 chunk->entries[off + 4] = addr % 0x100;
         }
         else {
                 addr = uc_compiler_reladdr32(compiler, off, dest);
                 chunk->entries[off + 1] = addr / 0x1000000;
                 chunk->entries[off + 2] = (addr / 0x10000) % 0x100;
                 chunk->entries[off + 3] = (addr / 0x100) % 0x100;
                 chunk->entries[off + 4] = addr % 0x100;
         }
 }
 
 static void
 uc_compiler_inc_exportnum(uc_compiler_t *compiler)
 {
         uc_source_t *root = uc_program_function_source(uc_program_entry(compiler->program));
         uint64_t u;
 
         if (root->exports.count == 0) {
                 uc_vector_push(&root->exports, ucv_uint64_new(1));
         }
         else {
                 u = ucv_uint64_get(root->exports.entries[0]);
 
                 ucv_put(root->exports.entries[0]);
 
                 root->exports.entries[0] = ucv_uint64_new(u + 1);
         }
 }
 
 static size_t
 uc_compiler_get_exportnum(uc_compiler_t *compiler)
 {
         uc_source_t *root = uc_program_function_source(uc_program_entry(compiler->program));
 
         return root->exports.count ? ucv_uint64_get(root->exports.entries[0]) : 0;
 }
 
 static void
 uc_compiler_emit_exports(uc_compiler_t *compiler) {
         size_t i;
 
         if (!compiler->patchlist || compiler->patchlist->token != TK_EXPORT)
                 return;
 
         for (i = 0; i < compiler->patchlist->count; i++) {
                 uc_compiler_emit_insn(compiler, 0, I_EXPORT);
                 uc_compiler_emit_u32(compiler, 0, compiler->patchlist->entries[i]);
         }
 }
 
 static uc_function_t *
 uc_compiler_finish(uc_compiler_t *compiler, uc_tokentype_t last_statement_type)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_locals_t *locals = &compiler->locals;
         uc_upvals_t *upvals = &compiler->upvals;
         size_t i;
 
         if (compiler->function->module)
                 uc_compiler_emit_exports(compiler);
 
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         uc_compiler_emit_insn(compiler, 0, I_RETURN);
 
         for (i = 0; i < locals->count; i++) {
                 uc_chunk_debug_add_variable(chunk,
                         locals->entries[i].from,
                         chunk->count,
                         i,
                         false,
                         locals->entries[i].name);
 
                 ucv_put(locals->entries[i].name);
         }
 
         for (i = 0; i < upvals->count; i++) {
                 uc_chunk_debug_add_variable(chunk,
                         0,
                         chunk->count,
                         i,
                         true,
                         upvals->entries[i].name);
 
                 ucv_put(upvals->entries[i].name);
         }
 
         uc_vector_clear(locals);
         uc_vector_clear(upvals);
 
         if (compiler->parser->error) {
                 uc_program_function_free(compiler->function);
 
                 return NULL;
         }
 
         return compiler->function;
 }
 
 static void
 uc_compiler_enter_scope(uc_compiler_t *compiler)
 {
         compiler->scope_depth++;
 }
 
 static void
 uc_compiler_leave_scope(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_locals_t *locals = &compiler->locals;
 
         compiler->scope_depth--;
 
         while (locals->count > 0 && locals->entries[locals->count - 1].depth > (ssize_t)compiler->scope_depth) {
                 locals->count--;
 
                 uc_chunk_debug_add_variable(chunk,
                         locals->entries[locals->count].from,
                         chunk->count,
                         locals->count,
                         false,
                         locals->entries[locals->count].name);
 
                 ucv_put(locals->entries[locals->count].name);
                 locals->entries[locals->count].name = NULL;
 
                 uc_compiler_emit_insn(compiler, 0,
                         locals->entries[locals->count].captured ? I_CUPV : I_POP);
         }
 }
 
 static bool
 uc_compiler_is_strict(uc_compiler_t *compiler)
 {
         uc_function_t *fn = (uc_function_t *)compiler->function;
 
         return fn->strict;
 }
 
 static ssize_t
 uc_compiler_declare_local(uc_compiler_t *compiler, uc_value_t *name, bool constant)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_locals_t *locals = &compiler->locals;
         const char *str1, *str2;
         size_t i, len1, len2;
 
         if (locals->count >= 0x00FFFFFF) {
                 uc_compiler_syntax_error(compiler, 0, "Too many local variables");
 
                 return -1;
         }
 
         str1 = ucv_string_get(name);
         len1 = ucv_string_length(name);
 
         for (i = locals->count; i > 0; i--) {
                 if (locals->entries[i - 1].depth != -1 && locals->entries[i - 1].depth < (ssize_t)compiler->scope_depth)
                         break;
 
                 str2 = ucv_string_get(locals->entries[i - 1].name);
                 len2 = ucv_string_length(locals->entries[i - 1].name);
 
                 if (str1 && str2 && len1 == len2 && !memcmp(str1, str2, len1)) {
                         if (locals->entries[i - 1].funcstub) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Variable '%s' redeclared", str2);
 
                                 return -1;
                         }
 
                         if (uc_compiler_is_strict(compiler)) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Variable '%s' redeclared", str2);
 
                                 return -1;
                         }
 
                         return i - 1;
                 }
         }
 
         uc_vector_push(locals, {
                 .name = ucv_get(name),
                 .depth = -1,
                 .captured = false,
                 .from = chunk->count,
                 .constant = constant
         });
 
         return -1;
 }
 
 static ssize_t
 uc_compiler_initialize_local(uc_compiler_t *compiler)
 {
         uc_locals_t *locals = &compiler->locals;
 
         locals->entries[locals->count - 1].depth = compiler->scope_depth;
 
         return locals->count - 1;
 }
 
 static ssize_t
 uc_compiler_resolve_local(uc_compiler_t *compiler, uc_value_t *name, bool *constant)
 {
         uc_locals_t *locals = &compiler->locals;
         const char *str1, *str2;
         size_t i, len1, len2;
 
         str1 = ucv_string_get(name);
         len1 = ucv_string_length(name);
 
         for (i = locals->count; i > 0; i--) {
                 str2 = ucv_string_get(locals->entries[i - 1].name);
                 len2 = ucv_string_length(locals->entries[i - 1].name);
 
                 if (!str1 || !str2 || len1 != len2 || memcmp(str1, str2, len1))
                         continue;
 
                 if (locals->entries[i - 1].depth == -1) {
                         uc_compiler_syntax_error(compiler, 0,
                                 "Can't access lexical declaration '%s' before initialization", str2);
 
                         return -1;
                 }
 
                 *constant = locals->entries[i - 1].constant;
 
                 return i - 1;
         }
 
         return -1;
 }
 
 static ssize_t
 uc_compiler_resolve_funcstub(uc_compiler_t *compiler, uc_value_t *name)
 {
         uc_locals_t *locals = &compiler->locals;
         const char *str1, *str2;
         size_t i, len1, len2;
 
         str1 = ucv_string_get(name);
         len1 = ucv_string_length(name);
 
         for (i = locals->count; i > 0; i--) {
                 if (locals->entries[i - 1].depth != -1 &&
                     locals->entries[i - 1].depth < (ssize_t)compiler->scope_depth)
                         break;
 
                 str2 = ucv_string_get(locals->entries[i - 1].name);
                 len2 = ucv_string_length(locals->entries[i - 1].name);
 
                 if (str1 && str2 && len1 == len2 && !memcmp(str1, str2, len1))
                         return locals->entries[i - 1].funcstub ? (ssize_t)(i - 1) : -1;
         }
 
         return -1;
 }
 
 static ssize_t
 uc_compiler_add_upval(uc_compiler_t *compiler, size_t idx, bool local, uc_value_t *name, bool constant)
 {
         uc_function_t *function = (uc_function_t *)compiler->function;
         uc_upvals_t *upvals = &compiler->upvals;
         uc_upval_t *uv;
         size_t i;
 
         for (i = 0, uv = upvals->entries; i < upvals->count; i++, uv = upvals->entries + i)
                 if (uv->index == idx && uv->local == local)
                         return i;
 
         /* XXX: encoding... */
         if (upvals->count >= (2 << 14)) {
                 uc_compiler_syntax_error(compiler, 0, "Too many upvalues");
 
                 return -1;
         }
 
         uc_vector_push(upvals, {
                 .local = local,
                 .index = idx,
                 .name  = ucv_get(name),
                 .constant = constant
         });
 
         function->nupvals++;
 
         return upvals->count - 1;
 }
 
 static ssize_t
 uc_compiler_resolve_upval(uc_compiler_t *compiler, uc_value_t *name, bool *constant)
 {
         uc_upvals_t *upvals = &compiler->upvals;
         uc_upval_t *uv;
         ssize_t idx;
         size_t i;
 
         if (!compiler->parent) {
                 for (i = 0, uv = upvals->entries; i < upvals->count; i++, uv = upvals->entries + i) {
                         if (ucv_is_equal(uv->name, name) && uv->local == false) {
                                 *constant = uv->constant;
 
                                 return i;
                         }
                 }
 
                 return -1;
         }
 
         idx = uc_compiler_resolve_local(compiler->parent, name, constant);
 
         if (idx > -1) {
                 compiler->parent->locals.entries[idx].captured = true;
 
                 return uc_compiler_add_upval(compiler, idx, true, name, *constant);
         }
 
         idx = uc_compiler_resolve_upval(compiler->parent, name, constant);
 
         if (idx > -1)
                 return uc_compiler_add_upval(compiler, idx, false, name, *constant);
 
         return -1;
 }
 
 static void
 uc_compiler_backpatch(uc_compiler_t *compiler, size_t break_addr, size_t next_addr)
 {
         uc_patchlist_t *pl = compiler->patchlist;
         volatile ssize_t jmpaddr;
         size_t i;
 
         for (i = 0; i < pl->count; i++) {
                 jmpaddr = uc_compiler_get_jmpaddr(compiler, pl->entries[i]);
 
                 switch (jmpaddr) {
                 case TK_BREAK:
                         /* if we have a break addr, patch instruction */
                         if (break_addr) {
                                 uc_compiler_set_jmpaddr(compiler, pl->entries[i], break_addr);
                                 continue;
                         }
 
                         break;
 
                 case TK_CONTINUE:
                         /* if we have a continue addr, patch instruction */
                         if (next_addr) {
                                 uc_compiler_set_jmpaddr(compiler, pl->entries[i], next_addr);
                                 continue;
                         }
 
                         break;
                 }
 
                 /* there should be no unhandled instructions */
                 assert(0);
         }
 
         free(pl->entries);
 
         compiler->patchlist = pl->parent;
 }
 
 static bool
 uc_compiler_check_assignment_lhs(uc_compiler_t *compiler)
 {
         return (
                 compiler->patchlist == NULL ||
                 compiler->patchlist->count == 0 ||
                 compiler->patchlist->token != TK_EXP
         );
 }
 
 static void
 uc_compiler_emit_inc_dec(uc_compiler_t *compiler, uc_tokentype_t toktype, bool is_postfix)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_value_t *varname = NULL;
         uc_vm_insn_t type;
         uint32_t cidx = 0;
         int insn;
 
         /* determine kind of emitted load instruction and operand value (if any) */
         type = chunk->entries ? chunk->entries[compiler->last_insn] : 0;
 
         if (type == I_LVAR || type == I_LLOC || type == I_LUPV) {
                 cidx = uc_compiler_get_u32(compiler, compiler->last_insn + 1);
 
                 if (type == I_LLOC && compiler->locals.entries[cidx].constant)
                         varname = compiler->locals.entries[cidx].name;
                 else if (type == I_LUPV && compiler->upvals.entries[cidx].constant)
                         varname = compiler->upvals.entries[cidx].name;
 
                 if (varname)
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Invalid increment/decrement of constant '%s'",
                                 ucv_string_get(varname));
 
                 uc_chunk_pop(chunk);
                 uc_chunk_pop(chunk);
                 uc_chunk_pop(chunk);
                 uc_chunk_pop(chunk);
                 uc_chunk_pop(chunk);
         }
 
         /* if we're mutating an object or array field, pop the last lval instruction
          * to leave object + last field name value on stack */
         else if (type == I_LVAL) {
                 if (!uc_compiler_check_assignment_lhs(compiler)) {
                         uc_compiler_syntax_error(compiler, 0,
                                 "Invalid left-hand side expression for increment/decrement");
 
                         return;
                 }
 
                 uc_chunk_pop(chunk);
         }
         else {
                 uc_compiler_syntax_error(compiler, 0, "Invalid increment/decrement operand");
 
                 return;
         }
 
         insn = (toktype == TK_INC) ? I_PLUS : I_MINUS;
 
         /* add / subtract 1 */
         uc_compiler_emit_insn(compiler, 0, I_LOAD8);
         uc_compiler_emit_u8(compiler, 0, 1);
 
         /* depending on variable type, emit corresponding increment instruction */
         switch (type) {
         case I_LVAR:
                 uc_compiler_emit_insn(compiler, 0, I_UVAR);
                 uc_compiler_emit_u32(compiler, 0, (insn << 24) | cidx);
                 break;
 
         case I_LLOC:
                 uc_compiler_emit_insn(compiler, 0, I_ULOC);
                 uc_compiler_emit_u32(compiler, 0, (insn << 24) | cidx);
                 break;
 
         case I_LUPV:
                 uc_compiler_emit_insn(compiler, 0, I_UUPV);
                 uc_compiler_emit_u32(compiler, 0, (insn << 24) | cidx);
                 break;
 
         case I_LVAL:
                 uc_compiler_emit_insn(compiler, 0, I_UVAL);
                 uc_compiler_emit_u8(compiler, 0, insn);
                 break;
 
         default:
                 break;
         }
 
         /* for post increment or decrement, add/subtract 1 to yield final value */
         if (is_postfix) {
                 uc_compiler_emit_insn(compiler, 0, I_LOAD8);
                 uc_compiler_emit_u8(compiler, 0, 1);
 
                 uc_compiler_emit_insn(compiler, 0, (toktype == TK_INC) ? I_SUB : I_ADD);
         }
 }
 
 
 static void
 uc_compiler_compile_unary(uc_compiler_t *compiler)
 {
         uc_tokentype_t type = compiler->parser->prev.type;
 
         uc_compiler_parse_precedence(compiler, P_UNARY);
 
         switch (type) {
         case TK_SUB:
                 uc_compiler_emit_insn(compiler, 0, I_MINUS);
                 break;
 
         case TK_ADD:
                 uc_compiler_emit_insn(compiler, 0, I_PLUS);
                 break;
 
         case TK_NOT:
                 uc_compiler_emit_insn(compiler, 0, I_NOT);
                 break;
 
         case TK_COMPL:
                 uc_compiler_emit_insn(compiler, 0, I_COMPL);
                 break;
 
         case TK_INC:
         case TK_DEC:
                 uc_compiler_emit_inc_dec(compiler, type, false);
                 break;
 
         default:
                 return;
         }
 }
 
 static void
 uc_compiler_compile_binary(uc_compiler_t *compiler)
 {
         uc_tokentype_t type = compiler->parser->prev.type;
 
         uc_compiler_parse_precedence(compiler, uc_compiler_parse_rule(type)->precedence + 1);
         uc_compiler_emit_insn(compiler, 0, I_BOR + (type - TK_BOR));
 }
 
 static void
 uc_compiler_compile_delete(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_vm_insn_t type;
 
         uc_compiler_parse_precedence(compiler, P_UNARY);
 
         type = (compiler->last_insn < chunk->count)
                 ? chunk->entries[compiler->last_insn] : 0;
 
         if (type != I_LVAL) {
                 uc_compiler_syntax_error(compiler, 0,
                         "expecting a property access expression");
 
                 return;
         }
 
         chunk->entries[compiler->last_insn] = I_DELETE;
 }
 
 /* `typeof` is sugar for the standard library's type() function; the value's
  * type name is pushed, or null for a null value, exactly as type() returns. */
 static void
 uc_compiler_compile_typeof(uc_compiler_t *compiler)
 {
         uc_compiler_parse_precedence(compiler, P_UNARY);
 
         uc_compiler_emit_stcall(compiler, 0, UC_FN_TYPE, 1);
 }
 
 static uc_vm_insn_t
 uc_compiler_emit_variable_rw(uc_compiler_t *compiler, uc_value_t *varname, uc_tokentype_t type)
 {
         uc_vm_insn_t insn;
         uint32_t sub_insn;
         bool constant;
         ssize_t idx;
 
         switch (type) {
         case TK_ASADD:     sub_insn = I_ADD;     break;
         case TK_ASSUB:     sub_insn = I_SUB;     break;
         case TK_ASMUL:     sub_insn = I_MUL;     break;
         case TK_ASDIV:     sub_insn = I_DIV;     break;
         case TK_ASMOD:     sub_insn = I_MOD;     break;
         case TK_ASBAND:    sub_insn = I_BAND;    break;
         case TK_ASBXOR:    sub_insn = I_BXOR;    break;
         case TK_ASBOR:     sub_insn = I_BOR;     break;
         case TK_ASLEFT:    sub_insn = I_LSHIFT;  break;
         case TK_ASRIGHT:   sub_insn = I_RSHIFT;  break;
         case TK_ASEXP:     sub_insn = I_EXP;     break;
         default:           sub_insn = 0;         break;
         }
 
         if (!varname) {
                 if (sub_insn != 0)
                         insn = I_UVAL;
                 else if (type != 0 && type != TK_QDOT && type != TK_QLBRACK)
                         insn = I_SVAL;
                 else
                         insn = I_LVAL;
 
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn);
 
                 if (sub_insn)
                         uc_compiler_emit_u8(compiler, compiler->parser->prev.pos, sub_insn);
         }
         else if ((idx = uc_compiler_resolve_local(compiler, varname, &constant)) > -1) {
                 insn = sub_insn ? I_ULOC : (type ? I_SLOC : I_LLOC);
 
                 if (insn != I_LLOC && constant)
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Invalid assignment to constant '%s'", ucv_string_get(varname));
 
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn);
                 uc_compiler_emit_u32(compiler, compiler->parser->prev.pos,
                         ((sub_insn & 0xff) << 24) | idx);
         }
         else if ((idx = uc_compiler_resolve_upval(compiler, varname, &constant)) > -1) {
                 insn = sub_insn ? I_UUPV : (type ? I_SUPV : I_LUPV);
 
                 if (insn != I_LUPV && constant)
                         uc_compiler_syntax_error(compiler, 0,
                                 "Invalid assignment to constant '%s'", ucv_string_get(varname));
 
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn);
                 uc_compiler_emit_u32(compiler, compiler->parser->prev.pos,
                         ((sub_insn & 0xff) << 24) | idx);
         }
         else {
                 idx = uc_program_add_constant(compiler->program, varname);
                 insn = sub_insn ? I_UVAR : (type ? I_SVAR : I_LVAR);
 
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn);
                 uc_compiler_emit_u32(compiler, compiler->parser->prev.pos,
                         ((sub_insn & 0xff) << 24) | idx);
         }
 
         return insn;
 }
 
 static void
 uc_compiler_emit_variable_copy(uc_compiler_t *compiler, uc_value_t *var)
 {
         if (!var) {
                 uc_compiler_emit_copy(compiler, 0, 1);
                 uc_compiler_emit_copy(compiler, 0, 1);
         }
 
         uc_compiler_emit_variable_rw(compiler, var, 0);
 }
 
 static void
 uc_compiler_compile_and(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off;
 
         uc_compiler_emit_copy(compiler, 0, 0);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         uc_compiler_emit_insn(compiler, 0, I_POP);
         uc_compiler_parse_precedence(compiler, P_AND);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_and_assignment(uc_compiler_t *compiler, uc_value_t *var)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off;
 
         uc_compiler_emit_variable_copy(compiler, var);
         uc_compiler_emit_copy(compiler, 0, 0);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         uc_compiler_emit_insn(compiler, 0, I_POP);
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_emit_variable_rw(compiler, var, TK_ASSIGN);
 }
 
 static void
 uc_compiler_compile_or(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off;
 
         uc_compiler_emit_copy(compiler, 0, 0);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_emit_insn(compiler, 0, I_POP);
         uc_compiler_parse_precedence(compiler, P_OR);
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_or_assignment(uc_compiler_t *compiler, uc_value_t *var)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off;
 
         uc_compiler_emit_variable_copy(compiler, var);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         uc_compiler_emit_variable_rw(compiler, var, 0);
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
         uc_compiler_emit_variable_rw(compiler, var, TK_ASSIGN);
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_nullish(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off;
 
         uc_compiler_emit_copy(compiler, 0, 0);
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         uc_compiler_emit_insn(compiler, 0, I_NES);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_emit_insn(compiler, 0, I_POP);
         uc_compiler_parse_precedence(compiler, P_OR);
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_nullish_assignment(uc_compiler_t *compiler, uc_value_t *var)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off;
 
         uc_compiler_emit_variable_copy(compiler, var);
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         uc_compiler_emit_insn(compiler, 0, I_NES);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         uc_compiler_emit_variable_rw(compiler, var, 0);
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
         uc_compiler_emit_variable_rw(compiler, var, TK_ASSIGN);
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_expression(uc_compiler_t *compiler, bool tag_stmt)
 {
         if (tag_stmt)
                 uc_compiler_emit_stmt_start(compiler, &compiler->parser->curr);
 
         uc_compiler_parse_precedence(compiler, P_COMMA);
 
         if (tag_stmt)
                 uc_compiler_emit_stmt_end(compiler);
 }
 
 static bool
 uc_compiler_compile_assignment(uc_compiler_t *compiler, uc_value_t *var)
 {
         uc_tokentype_t type = compiler->parser->curr.type;
 
         if (!uc_compiler_parse_at_assignment_op(compiler))
                 return false;
 
         if (!uc_compiler_check_assignment_lhs(compiler)) {
                 uc_compiler_syntax_error(compiler, 0,
                         "Invalid left-hand side expression for assignment");
 
                 return false;
         }
 
         switch (type)
         {
         case TK_ASNULLISH:
                 uc_compiler_parse_advance(compiler);
                 uc_compiler_compile_nullish_assignment(compiler, var);
                 break;
 
         case TK_ASOR:
                 uc_compiler_parse_advance(compiler);
                 uc_compiler_compile_or_assignment(compiler, var);
                 break;
 
         case TK_ASAND:
                 uc_compiler_parse_advance(compiler);
                 uc_compiler_compile_and_assignment(compiler, var);
                 break;
 
         default:
                 uc_compiler_parse_advance(compiler);
                 uc_compiler_parse_precedence(compiler, P_ASSIGN);
                 uc_compiler_emit_variable_rw(compiler, var, type);
                 break;
         }
 
         return true;
 }
 
 static bool
 uc_compiler_compile_arrowfn(uc_compiler_t *compiler, uc_value_t *args, bool restarg)
 {
         uc_tokentype_t last_statement_type = TK_NULL;
         bool array = (ucv_type(args) == UC_ARRAY);
         uc_compiler_t fncompiler = { 0 };
         size_t i, pos, load_off;
         uc_function_t *fn;
         ssize_t slot;
 
         if (!uc_compiler_parse_match(compiler, TK_ARROW))
                 return false;
 
         pos = compiler->parser->prev.pos;
 
         uc_compiler_init(&fncompiler, NULL, uc_compiler_current_source(compiler),
                 compiler->parser->prev.pos,
                 compiler->program,
                 uc_compiler_is_strict(compiler));
 
         fncompiler.parent = compiler;
         fncompiler.parser = compiler->parser;
         fncompiler.exprstack = compiler->exprstack;
 
         fn = (uc_function_t *)fncompiler.function;
         fn->arrow = true;
         fn->vararg = args ? restarg : false;
         fn->nargs = array ? ucv_array_length(args) : !!args;
 
         uc_compiler_enter_scope(&fncompiler);
 
         /* declare local variables for arguments */
         for (i = 0; i < fn->nargs; i++) {
                 slot = uc_compiler_declare_local(&fncompiler,
                         array ? ucv_array_get(args, i) : args, false);
 
                 if (slot != -1)
                         uc_compiler_syntax_error(&fncompiler, pos,
                                 "Duplicate argument names are not allowed in this context");
 
                 uc_compiler_initialize_local(&fncompiler);
         }
 
         /* parse and compile body */
         if (uc_compiler_parse_match(&fncompiler, TK_LBRACE)) {
                 while (!uc_compiler_parse_check(&fncompiler, TK_RBRACE) &&
                        !uc_compiler_parse_check(&fncompiler, TK_EOF))
                         uc_compiler_compile_declaration(&fncompiler);
 
                 uc_compiler_parse_consume(&fncompiler, TK_RBRACE);
 
                 /* emit final return */
                 if (last_statement_type != TK_RETURN) {
                         uc_compiler_emit_insn(&fncompiler, 0, I_LNULL);
                         uc_compiler_emit_insn(&fncompiler, 0, I_RETURN);
                 }
         }
         else {
                 uc_compiler_emit_stmt_start(&fncompiler, &compiler->parser->curr);
                 uc_compiler_parse_precedence(&fncompiler, P_ASSIGN);
 
                 /* invoke a function call in tail position to avoid growing the stack */
                 bool tailcall = uc_compiler_tailcall_pending(&fncompiler);
 
                 uc_compiler_emit_insn(&fncompiler, 0, I_RETURN);
 
                 if (tailcall)
                         uc_compiler_emit_tailcall_marker(&fncompiler);
 
                 uc_compiler_emit_stmt_end(&fncompiler);
         }
 
         /* emit load instruction for function value */
         uc_compiler_emit_insn(compiler, pos, I_ARFN);
         load_off = uc_compiler_emit_u32(compiler, 0, 0);
 
         /* encode upvalue information */
         for (i = 0; i < fn->nupvals; i++)
                 uc_compiler_emit_s32(compiler, 0,
                         fncompiler.upvals.entries[i].local
                                 ? -(fncompiler.upvals.entries[i].index + 1)
                                 : fncompiler.upvals.entries[i].index);
 
         /* finalize function compiler */
         fn = uc_compiler_finish(&fncompiler, TK_RETURN);
 
         if (fn)
                 uc_compiler_set_u32(compiler, load_off,
                         uc_program_function_id(compiler->program, fn));
 
         return true;
 }
 
 static uc_tokentype_t
 uc_compiler_compile_var_or_arrowfn(uc_compiler_t *compiler, uc_value_t *name)
 {
         uc_tokentype_t rv;
 
         if (uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) && uc_compiler_compile_assignment(compiler, name)) {
                 rv = TK_ASSIGN;
         }
         else if (uc_compiler_compile_arrowfn(compiler, name, false)) {
                 rv = TK_ARROW;
         }
         else {
                 uc_compiler_emit_variable_rw(compiler, name, 0);
                 rv = TK_LABEL;
         }
 
         return rv;
 }
 
 static void
 uc_compiler_compile_paren(uc_compiler_t *compiler)
 {
         uc_value_t *varnames = NULL, *varname;
         bool maybe_arrowfn = false;
         bool restarg = false;
 
         /* First try to parse a complete parameter expression and remember the
          * consumed label tokens as we go. */
         while (true) {
                 if (uc_compiler_parse_check(compiler, TK_LABEL)) {
                         if (!varnames)
                                 varnames = ucv_array_new(NULL);
 
                         ucv_array_push(varnames, ucv_get(compiler->parser->curr.uv));
 
                         /* A subsequent slash cannot be a regular expression literal */
                         compiler->parser->lex.no_regexp = true;
                         uc_compiler_parse_advance(compiler);
                 }
                 else if (uc_compiler_parse_match(compiler, TK_ELLIP)) {
                         uc_compiler_parse_consume(compiler, TK_LABEL);
 
                         if (!varnames)
                                 varnames = ucv_array_new(NULL);
 
                         ucv_array_push(varnames, ucv_get(compiler->parser->prev.uv));
 
                         /* A subsequent slash cannot be a regular expression literal */
                         compiler->parser->lex.no_regexp = true;
                         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
                         maybe_arrowfn = true;
                         restarg = true;
 
                         break;
                 }
                 else if (uc_compiler_parse_check(compiler, TK_COMMA)) {
                         /* Reject consecutive commas */
                         if (compiler->parser->prev.type == TK_COMMA)
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Expecting expression");
 
                         uc_compiler_parse_advance(compiler);
 
                         continue;
                 }
                 else {
                         maybe_arrowfn = uc_compiler_parse_check(compiler, TK_RPAREN);
 
                         if (maybe_arrowfn) {
                                 /* A subsequent slash cannot be a regular expression literal */
                                 compiler->parser->lex.no_regexp = true;
                                 uc_compiler_parse_advance(compiler);
                         }
 
                         /* If we encounter a dot, treat potential subsequent keyword as label */
                         if (uc_compiler_parse_check(compiler, TK_DOT) ||
                             uc_compiler_parse_check(compiler, TK_QDOT))
                                 compiler->parser->lex.no_keyword = true;
 
                         break;
                 }
         }
 
         /* The lhs we parsed so far is eligible for an arrow function arg list,
          * try to continue compiling into arrow function... */
         if (maybe_arrowfn) {
                 /* If we can parse the remainder as arrow function, we're done */
                 if (uc_compiler_compile_arrowfn(compiler, varnames, restarg))
                         goto out;
 
                 /* ... otherwise disallow the `...` spread operator and empty
                  * parenthesized expressions */
                 if (restarg || !varnames) {
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Expecting '=>' after parameter list");
 
                         goto out;
                 }
         }
 
         /* If we reach this, the expression we parsed so far cannot be a parameter
          * list for an arrow function and we might have consumed one or multiple
          * consecutive labels. */
         if (varnames) {
                 /* Get last variable name */
                 varname = ucv_array_get(varnames,
                         ucv_array_length(varnames) - 1);
 
                 /* If we consumed the right paren, the expression is complete and we
                  * only need to emit a variable read operation for the last parsed
                  * label since previous read operations are shadowed by subsequent ones
                  * in comma expressions and since pure variable reads are without
                  * side effects. */
                 if (maybe_arrowfn) {
                         uc_compiler_emit_variable_rw(compiler, varname, 0);
 
                         goto out;
                 }
 
                 /* ... otherwise if the last token was a label, try continue parsing as
                  * assignment or arrow function expression and if that fails, as
                  * relational one */
                 if (compiler->parser->prev.type == TK_LABEL) {
                         uc_compiler_exprstack_push(compiler, TK_LABEL, F_ASSIGNABLE);
 
                         if (uc_compiler_compile_var_or_arrowfn(compiler, varname) == TK_LABEL) {
                                 /* parse operand and rhs */
                                 while (P_TERNARY <= uc_compiler_parse_rule(compiler->parser->curr.type)->precedence) {
                                         uc_parse_rule_t *rule =
                                                 uc_compiler_parse_rule(compiler->parser->curr.type);
 
                                         if (!rule->infix)
                                                 break;
 
                                         uc_compiler_parse_advance(compiler);
                                         rule->infix(compiler);
                                 }
                         }
 
                         /* If we're not at the end of the expression, we require a comma.
                          * Also pop intermediate result in this case. */
                         if (!uc_compiler_parse_check(compiler, TK_RPAREN)) {
                                 uc_compiler_emit_insn(compiler, 0, I_POP);
                                 uc_compiler_parse_consume(compiler, TK_COMMA);
                         }
 
                         uc_compiler_exprstack_pop(compiler);
                 }
         }
 
         /* When we reach this point, all already complete expression possibilities
          * have been eliminated and we either need to compile the next, non-label
          * expression or reached the closing paren. If neither applies, we have a
          * syntax error. */
         if (!uc_compiler_parse_check(compiler, TK_RPAREN))
                 uc_compiler_compile_expression(compiler, false);
 
         /* A subsequent slash cannot be a regular expression literal */
         compiler->parser->lex.no_regexp = true;
 
         /* At this point we expect the end of the parenthesized expression, anything
          * else is a syntax error */
         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
 out:
         ucv_put(varnames);
 }
 
 static void
 uc_compiler_compile_call(uc_compiler_t *compiler)
 {
         bool optional_chaining = (compiler->parser->prev.type == TK_QLPAREN);
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_jmplist_t spreads = { 0 };
         uc_vm_insn_t type;
         size_t i, nargs = 0;
         bool mcall;
 
         /* determine the kind of the lhs */
         type = (compiler->last_insn < chunk->count)
                 ? chunk->entries[compiler->last_insn] : 0;
         mcall = (type == I_LVAL);
 
         if (mcall) {
                 uc_chunk_pop(chunk);
                 uc_compiler_emit_insn(compiler, 0, I_PVAL);
         }
 
         if (optional_chaining)
                 uc_compiler_emit_jmpnt(compiler, compiler->parser->prev.pos,
                         (1u << UC_CFUNCTION) | (1u << UC_CLOSURE), mcall);
 
         /* compile arguments */
         if (!uc_compiler_parse_check(compiler, TK_RPAREN)) {
                 do {
                         /* if this is a spread arg, remember the argument index */
                         if (uc_compiler_parse_match(compiler, TK_ELLIP))
                                 uc_vector_push(&spreads, nargs);
 
                         /* compile argument expression */
                         uc_compiler_parse_precedence(compiler, P_ASSIGN);
                         nargs++;
                 }
                 while (uc_compiler_parse_match(compiler, TK_COMMA));
         }
 
         /* after a function call expression, no regexp literal can follow */
         compiler->parser->lex.no_regexp = true;
         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
         /* if lhs is a dot or bracket expression, emit a method call */
         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_CALL);
 
         if (nargs > 0xffff || spreads.count > 0x7fff)
                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                         "Too many function call arguments");
 
         /* encode ordinary (bits 0..15) and spread argument (bits 16..30) count
            as well as method call indication (bit 31) */
         uc_compiler_emit_u32(compiler, 0,
                 (mcall ? 0x80000000 : 0) | ((spreads.count & 0x7fff) << 16) | nargs);
 
         /* encode spread arg positions */
         for (i = 0; i < spreads.count; i++)
                 uc_compiler_emit_u16(compiler, 0, nargs - spreads.entries[i] - 1);
 
         uc_vector_clear(&spreads);
 
         /* remember the chunk end right after the invocation's operands for potential
          * tail call optimization */
         compiler->tailcall_off = uc_compiler_current_chunk(compiler)->count;
 
         compiler->patchlist->depth = uc_compiler_current_chunk(compiler)->count;
 }
 
 static void
 uc_compiler_compile_post_inc(uc_compiler_t *compiler)
 {
         uc_compiler_emit_inc_dec(compiler, compiler->parser->prev.type, true);
 }
 
 static bool
 uc_compiler_is_use_strict_pragma(uc_compiler_t *compiler)
 {
         uc_value_t *v;
 
         if (uc_compiler_current_chunk(compiler)->count > 0)
                 return false;
 
         if (compiler->parser->lex.block != STATEMENTS)
                 return false;
 
         v = compiler->parser->prev.uv;
 
         return (strcmp(ucv_string_get(v), "use strict") == 0);
 }
 
 static void
 uc_compiler_compile_constant(uc_compiler_t *compiler)
 {
         uc_function_t *fn;
         uint64_t u;
 
         switch (compiler->parser->prev.type) {
         case TK_THIS:
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LTHIS);
                 break;
 
         case TK_NULL:
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL);
                 break;
 
         case TK_TRUE:
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LTRUE);
                 break;
 
         case TK_FALSE:
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LFALSE);
                 break;
 
         case TK_STRING:
                 if (uc_compiler_is_use_strict_pragma(compiler)) {
                         fn = (uc_function_t *)compiler->function;
                         fn->strict = true;
                 }
 
                 /* fall through */
 
         case TK_DOUBLE:
                 uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
                 break;
 
         case TK_REGEXP:
                 uc_compiler_emit_regexp(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
                 break;
 
         case TK_NUMBER:
                 u = ucv_uint64_get(compiler->parser->prev.uv);
                 assert(errno == 0);
 
                 if (u <= 0xff) {
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD8);
                         uc_compiler_emit_u8(compiler, compiler->parser->prev.pos, u);
                 }
                 else if (u <= 0xffff) {
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD16);
                         uc_compiler_emit_u16(compiler, compiler->parser->prev.pos, u);
                 }
                 else if (u <= 0xffffffff) {
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD32);
                         uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, u);
                 }
                 else {
                         uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
                 }
 
                 break;
 
         default:
                 break;
         }
 }
 
 static void
 uc_compiler_compile_template(uc_compiler_t *compiler)
 {
         uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
 
         while (true) {
                 if (uc_compiler_parse_check(compiler, TK_TEMPLATE)) {
                         /* a TK_TEMPLATE token only continues the current literal when the
                          * previous one was left open by a `${...}` placeholder, in which
                          * case the lexer emits a TK_PLACEH token in between; two adjacent
                          * TK_TEMPLATE tokens are separate literals and must be joined
                          * with an explicit operator
                          */
                         if (compiler->parser->prev.type == TK_TEMPLATE) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Adjacent template literals are not implicitly concatenated");
 
                                 return;
                         }
 
                         uc_compiler_parse_advance(compiler);
                         uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
                         uc_compiler_emit_insn(compiler, 0, I_ADD);
                 }
                 else if (uc_compiler_parse_match(compiler, TK_PLACEH)) {
                         uc_compiler_compile_expression(compiler, true);
                         uc_compiler_emit_insn(compiler, 0, I_ADD);
                         uc_compiler_parse_consume(compiler, TK_RBRACE);
                 }
                 else {
                         break;
                 }
         }
 }
 
 static void
 uc_compiler_compile_comma(uc_compiler_t *compiler)
 {
         uc_compiler_emit_insn(compiler, compiler->parser->curr.pos, I_POP);
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 }
 
 static void
 uc_compiler_compile_labelexpr(uc_compiler_t *compiler)
 {
         uc_value_t *label = ucv_get(compiler->parser->prev.uv);
 
         uc_compiler_compile_var_or_arrowfn(compiler, label);
         ucv_put(label);
 }
 
 static uc_tokentype_t
 uc_compiler_compile_delimitted_block(uc_compiler_t *compiler, uc_tokentype_t endtype)
 {
         uc_tokentype_t last_statement_type = TK_NULL;
 
         while (!uc_compiler_parse_check(compiler, endtype) &&
                !uc_compiler_parse_check(compiler, TK_EOF))
                 last_statement_type = uc_compiler_compile_declaration(compiler);
 
         return uc_compiler_parse_check(compiler, endtype) ? last_statement_type : TK_EOF;
 }
 
 static void
 uc_compiler_compile_funcexpr_common(uc_compiler_t *compiler, bool require_name)
 {
         uc_tokentype_t last_statement_type = TK_NULL;
         uc_compiler_t fncompiler = { 0 };
         uc_value_t *name = NULL;
         ssize_t slot = -1, pos;
         uc_tokentype_t type;
         size_t i, load_off;
         uc_function_t *fn;
 
         pos = compiler->parser->prev.pos;
         type = compiler->parser->prev.type;
 
         if (uc_compiler_parse_match(compiler, TK_LABEL)) {
                 name = compiler->parser->prev.uv;
 
                 if (require_name && uc_compiler_parse_check(compiler, TK_SCOL)) {
                         slot = uc_compiler_resolve_funcstub(compiler, name);
 
                         if (slot > -1) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Function '%s' redeclared", ucv_string_get(name));
 
                                 return;
                         }
 
                         slot = uc_compiler_declare_local(compiler, name, true);
 
                         if (slot > -1) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Variable '%s' redeclared", ucv_string_get(name));
 
                                 return;
                         }
 
                         compiler->locals.entries[compiler->locals.count - 1].funcstub = true;
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL);
                         uc_compiler_initialize_local(compiler);
                         uc_compiler_parse_consume(compiler, TK_SCOL);
 
                         return;
                 }
 
                 /* A function declaration binds its name in the enclosing scope. A named
                  * function expression must not: its name is only visible inside its own
                  * body (for self-reference), and declaring it in the enclosing scope
                  * would both leak it and shift the local slots, corrupting the
                  * initialisation state of a `let`/`const` the expression initialises. */
                 if (require_name) {
                         slot = uc_compiler_resolve_funcstub(compiler, name);
 
                         if (slot > -1) {
                                 compiler->locals.entries[slot].funcstub = false;
                         }
                         else {
                                 slot = uc_compiler_declare_local(compiler, name,
                                         uc_compiler_is_strict(compiler));
 
                                 if (slot == -1)
                                         uc_compiler_initialize_local(compiler);
                                 else if (compiler->locals.entries[slot].constant)
                                         uc_compiler_syntax_error(compiler, pos,
                                                 "Redeclaration of constant '%s'",
                                                 ucv_string_get(name));
                         }
                 }
         }
         else if (require_name) {
                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting function name");
         }
 
         uc_compiler_init(&fncompiler,
                 name ? ucv_string_get(name) : NULL,
                 uc_compiler_current_source(compiler),
                 compiler->parser->prev.pos,
                 compiler->program,
                 uc_compiler_is_strict(compiler));
 
         /* Bind a named function expression's name to its own callee slot so the
          * body can reference itself for recursion, without touching the enclosing
          * scope. Declarations keep the name in the enclosing scope (handled above). */
         if (name && !require_name) {
                 ucv_put(fncompiler.locals.entries[0].name);
                 fncompiler.locals.entries[0].name = ucv_get(name);
         }
 
         fncompiler.parent = compiler;
         fncompiler.parser = compiler->parser;
         fncompiler.exprstack = compiler->exprstack;
         fn = (uc_function_t *)fncompiler.function;
 
         uc_compiler_parse_consume(&fncompiler, TK_LPAREN);
 
         uc_compiler_enter_scope(&fncompiler);
 
         /* compile argument specification */
         while (true) {
                 if (uc_compiler_parse_check(&fncompiler, TK_RPAREN))
                         break;
 
                 if (uc_compiler_parse_match(&fncompiler, TK_ELLIP))
                         fn->vararg = true;
 
                 if (uc_compiler_parse_match(&fncompiler, TK_LABEL)) {
                         fn->nargs++;
 
                         uc_compiler_declare_local(&fncompiler, fncompiler.parser->prev.uv, false);
                         uc_compiler_initialize_local(&fncompiler);
 
                         if (fn->vararg ||
                             !uc_compiler_parse_match(&fncompiler, TK_COMMA))
                                 break;
                 }
                 else {
                         uc_compiler_syntax_error(&fncompiler, fncompiler.parser->curr.pos,
                                 "Expecting Label");
 
                         break;
                 }
         }
 
         uc_compiler_parse_consume(&fncompiler, TK_RPAREN);
 
         /* parse and compile function body */
         if (uc_compiler_parse_match(&fncompiler, TK_COLON)) {
                 last_statement_type = uc_compiler_compile_delimitted_block(&fncompiler, TK_ENDFUNC);
                 uc_compiler_parse_consume(&fncompiler, TK_ENDFUNC);
         }
         else if (uc_compiler_parse_match(&fncompiler, TK_LBRACE)) {
                 last_statement_type = uc_compiler_compile_delimitted_block(&fncompiler, TK_RBRACE);
                 uc_compiler_parse_consume(&fncompiler, TK_RBRACE);
         }
         else {
                 uc_compiler_syntax_error(&fncompiler, fncompiler.parser->curr.pos,
                         "Expecting '{' or ':' after function parameters");
         }
 
         /* emit load instruction for function value */
         uc_compiler_emit_insn(compiler, pos, (type == TK_ARROW) ? I_ARFN : I_CLFN);
         load_off = uc_compiler_emit_u32(compiler, 0, 0);
 
         /* encode upvalue information */
         for (i = 0; i < fn->nupvals; i++)
                 uc_compiler_emit_s32(compiler, 0,
                         fncompiler.upvals.entries[i].local
                                 ? -(fncompiler.upvals.entries[i].index + 1)
                                 : fncompiler.upvals.entries[i].index);
 
         /* finalize function compiler */
         fn = uc_compiler_finish(&fncompiler, last_statement_type);
 
         if (fn)
                 uc_compiler_set_u32(compiler, load_off,
                         uc_program_function_id(compiler->program, fn));
 
         /* if a local variable of the same name already existed, overwrite its value
          * with the compiled function here */
         if (slot != -1) {
                 uc_compiler_emit_insn(compiler, 0, I_SLOC);
                 uc_compiler_emit_u32(compiler, 0, slot);
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 }
 
 static void
 uc_compiler_compile_funcexpr(uc_compiler_t *compiler)
 {
         return uc_compiler_compile_funcexpr_common(compiler, false);
 }
 
 static void
 uc_compiler_compile_funcdecl(uc_compiler_t *compiler)
 {
         return uc_compiler_compile_funcexpr_common(compiler, true);
 }
 
 static void
 uc_compiler_compile_dot(uc_compiler_t *compiler)
 {
         bool optional_chaining = (compiler->parser->prev.type == TK_QDOT);
 
         /* no regexp literal possible after property access */
         compiler->parser->lex.no_regexp = true;
 
         if (optional_chaining)
                 uc_compiler_emit_jmpnt(compiler, compiler->parser->prev.pos,
                         (1u << UC_ARRAY) | (1u << UC_OBJECT) | (1u << UC_RESOURCE), 0);
 
         /* parse label lhs */
         uc_compiler_parse_consume(compiler, TK_LABEL);
         uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
 
         /* depending on context, compile into I_UVAL, I_SVAL or I_LVAL operation */
         if (!uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) || !uc_compiler_compile_assignment(compiler, NULL))
                 uc_compiler_emit_variable_rw(compiler, NULL, optional_chaining ? TK_QDOT : 0);
 
         compiler->patchlist->depth = uc_compiler_current_chunk(compiler)->count;
 }
 
 static void
 uc_compiler_compile_subscript(uc_compiler_t *compiler)
 {
         bool optional_chaining = (compiler->parser->prev.type == TK_QLBRACK);
 
         if (optional_chaining)
                 uc_compiler_emit_jmpnt(compiler, compiler->parser->prev.pos,
                         (1u << UC_ARRAY) | (1u << UC_OBJECT) | (1u << UC_RESOURCE), 0);
 
         /* compile lhs */
         uc_compiler_compile_expression(compiler, false);
 
         /* no regexp literal possible after computed property access */
         compiler->parser->lex.no_regexp = true;
         uc_compiler_parse_consume(compiler, TK_RBRACK);
 
         /* depending on context, compile into I_UVAL, I_SVAL or I_LVAL operation */
         if (!uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) || !uc_compiler_compile_assignment(compiler, NULL))
                 uc_compiler_emit_variable_rw(compiler, NULL, optional_chaining ? TK_QLBRACK : 0);
 
         compiler->patchlist->depth = uc_compiler_current_chunk(compiler)->count;
 }
 
 static void
 uc_compiler_compile_ternary(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off;
 
         /* jump to false branch */
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
 
         /* compile true branch */
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 
         /* jump after false branch */
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
 
         uc_compiler_parse_consume(compiler, TK_COLON);
 
         /* compile false branch */
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_parse_precedence(compiler, P_TERNARY);
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_array(uc_compiler_t *compiler)
 {
         size_t hint_off, hint_count = 0, len = 0;
 
         /* a literal followed by `=` is a destructuring assignment */
         if (uc_compiler_compile_destructuring(compiler))
                 return;
 
         /* create empty array on stack */
         uc_compiler_emit_insn(compiler, 0, I_NARR);
         hint_off = uc_compiler_emit_u32(compiler, 0, 0);
 
         /* parse initializer values */
         do {
                 if (uc_compiler_parse_check(compiler, TK_RBRACK)) {
                         break;
                 }
                 else if (uc_compiler_parse_match(compiler, TK_ELLIP)) {
                         /* push items on stack so far... */
                         if (len > 0) {
                                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR);
                                 uc_compiler_emit_u32(compiler, 0, len);
                                 len = 0;
                         }
 
                         /* compile spread value expression */
                         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 
                         /* emit merge operation */
                         uc_compiler_emit_insn(compiler, 0, I_MARR);
                 }
                 else {
                         /* push items on stack so far... */
                         if (len >= 0xffffffff) {
                                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR);
                                 uc_compiler_emit_u32(compiler, 0, len);
                                 len = 0;
                         }
 
                         /* compile item value expression */
                         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 
                         hint_count++;
                         len++;
                 }
         }
         while (uc_compiler_parse_match(compiler, TK_COMMA));
 
         /* no regexp literal possible after array literal */
         compiler->parser->lex.no_regexp = true;
         uc_compiler_parse_consume(compiler, TK_RBRACK);
 
         /* push items on stack */
         if (len > 0) {
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR);
                 uc_compiler_emit_u32(compiler, 0, len);
         }
 
         /* set initial size hint */
         uc_compiler_set_u32(compiler, hint_off, hint_count);
 }
 
 static void
 uc_compiler_compile_method(uc_compiler_t *compiler, uc_value_t *method_name)
 {
         uc_compiler_t fncompiler = { 0 };
         uc_function_t *fn;
         size_t i, load_off;
 
         uc_compiler_init(&fncompiler, method_name ? ucv_string_get(method_name) : NULL,
                          uc_compiler_current_source(compiler),
                          compiler->parser->prev.pos,
                          compiler->program,
                          uc_compiler_is_strict(compiler));
 
         fncompiler.parent = compiler;
         fncompiler.parser = compiler->parser;
         fncompiler.exprstack = compiler->exprstack;
 
         fn = (uc_function_t *)fncompiler.function;
 
         /* parse parameters - '(' is already consumed, expect parameters or ')' */
         uc_compiler_enter_scope(&fncompiler);
 
         while (true) {
                 if (uc_compiler_parse_check(&fncompiler, TK_RPAREN))
                         break;
 
                 if (uc_compiler_parse_match(&fncompiler, TK_ELLIP))
                         fn->vararg = true;
 
                 uc_compiler_parse_consume(&fncompiler, TK_LABEL);
                 fn->nargs++;
 
                 uc_compiler_declare_local(&fncompiler,
                         fncompiler.parser->prev.uv, false);
                 uc_compiler_initialize_local(&fncompiler);
 
                 if (fn->vararg ||
                     !uc_compiler_parse_match(&fncompiler, TK_COMMA))
                         break;
         }
 
         uc_compiler_parse_consume(&fncompiler, TK_RPAREN);
 
         /* parse function body - must be a block */
         uc_compiler_parse_consume(&fncompiler, TK_LBRACE);
 
         while (!uc_compiler_parse_check(&fncompiler, TK_RBRACE) &&
                !uc_compiler_parse_check(&fncompiler, TK_EOF))
                 uc_compiler_compile_declaration(&fncompiler);
 
         uc_compiler_parse_consume(&fncompiler, TK_RBRACE);
 
         /* emit load instruction for method */
         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_CLFN);
         load_off = uc_compiler_emit_u32(compiler, 0, 0);
 
         /* encode upvalue information */
         for (i = 0; i < fn->nupvals; i++)
                 uc_compiler_emit_s32(compiler, 0,
                         fncompiler.upvals.entries[i].local
                                 ? -(fncompiler.upvals.entries[i].index + 1)
                                 : fncompiler.upvals.entries[i].index);
 
         /* finalize function compiler */
         fn = uc_compiler_finish(&fncompiler, TK_RETURN);
 
         if (fn)
                 uc_compiler_set_u32(compiler, load_off,
                         uc_program_function_id(compiler->program, fn));
 }
 
 
 static void
 uc_compiler_compile_object(uc_compiler_t *compiler)
 {
         size_t hint_off, hint_count = 0, len = 0;
 
         /* a literal followed by `=` is a destructuring assignment */
         if (uc_compiler_compile_destructuring(compiler))
                 return;
 
         /* create empty object on stack */
         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_NOBJ);
         hint_off = uc_compiler_emit_u32(compiler, 0, 0);
 
         /* parse initializer values */
         do {
                 /* End of object literal */
                 if (uc_compiler_parse_check(compiler, TK_RBRACE))
                         break;
 
                 /* Spread operator */
                 if (uc_compiler_parse_match(compiler, TK_ELLIP)) {
                         /* set items on stack so far... */
                         if (len > 0) {
                                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ);
                                 uc_compiler_emit_u32(compiler, 0, len);
                                 len = 0;
                         }
 
                         /* compile spread value expression */
                         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 
                         /* emit merge operation */
                         uc_compiler_emit_insn(compiler, 0, I_MOBJ);
 
                         compiler->parser->lex.no_keyword = true;
                         continue;
                 }
 
                 /* Computed property/method name */
                 if (uc_compiler_parse_match(compiler, TK_LBRACK)) {
                         /* parse property name expression */
                         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 
                         /* consume closing bracket */
                         uc_compiler_parse_consume(compiler, TK_RBRACK);
 
                         /* Check if this is a computed method: [expr]() { ... } */
                         if (uc_compiler_parse_match(compiler, TK_LPAREN)) {
                                 /* compile method - key is already on stack from [expr] */
                                 uc_compiler_compile_method(compiler, NULL);
                         }
                         else {
                                 /* regular computed property: [expr]: value */
                                 uc_compiler_parse_consume(compiler, TK_COLON);
                                 uc_compiler_parse_precedence(compiler, P_ASSIGN);
                         }
                 }
 
                 /* Property/method declaration or property shorthand */
                 else {
                         /* parse key expression */
                         uc_tokentype_t key_type = compiler->parser->curr.type;
                         if (!uc_compiler_parse_match(compiler, TK_LABEL) &&
                             !uc_compiler_parse_match(compiler, TK_STRING))
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Expecting label");
 
                         /* hold a reference to the key: matching TK_LPAREN below advances
                          * the parser, which releases the underlying prev.uv token value */
                         uc_value_t *key = ucv_get(compiler->parser->prev.uv);
 
                         /* load label */
                         uc_compiler_emit_constant(compiler, compiler->parser->prev.pos,
                                 key);
 
                         /* Check if this is a shorthand method: foo() { ... } */
                         if (uc_compiler_parse_match(compiler, TK_LPAREN)) {
                                 /* disallow keywords as method names */
                                 if (uc_lexer_is_keyword(key))
                                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                                 "Invalid identifier");
 
                                 uc_compiler_compile_method(compiler, key);
                         }
                         /* Check if this is property shorthand: foo */
                         else if (key_type == TK_LABEL &&
                                  (uc_compiler_parse_check(compiler, TK_COMMA) ||
                                   uc_compiler_parse_check(compiler, TK_RBRACE))) {
                                 /* disallow keywords in this case */
                                 if (uc_lexer_is_keyword(key))
                                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                                 "Invalid identifier");
 
                                 uc_compiler_emit_variable_rw(compiler, key, 0);
                         }
                         /* ... otherwise treat it as ordinary `key: value` tuple */
                         else {
                                 uc_compiler_parse_consume(compiler, TK_COLON);
 
                                 /* parse value expression */
                                 uc_compiler_parse_precedence(compiler, P_ASSIGN);
                         }
 
                         ucv_put(key);
                 }
 
                 /* set items on stack so far... */
                 if (len >= 0xfffffffe) {
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ);
                         uc_compiler_emit_u32(compiler, 0, len);
                         len = 0;
                 }
 
                 hint_count += 2;
                 len += 2;
 
                 compiler->parser->lex.no_keyword = true;
         }
         while (uc_compiler_parse_match(compiler, TK_COMMA));
 
         /* no regexp literal possible after object literal */
         compiler->parser->lex.no_regexp = true;
         uc_compiler_parse_consume(compiler, TK_RBRACE);
 
         /* set items on stack */
         if (len > 0) {
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ);
                 uc_compiler_emit_u32(compiler, 0, len);
         }
 
         /* set initial size hint */
         uc_compiler_set_u32(compiler, hint_off, hint_count);
 }
 
 
 static void
 uc_compiler_declare_local_null(uc_compiler_t *compiler, size_t srcpos, uc_value_t *varname)
 {
         ssize_t existing_slot = uc_compiler_declare_local(compiler, varname, false);
 
         uc_compiler_emit_insn(compiler, srcpos, I_LNULL);
 
         if (existing_slot == -1) {
                 uc_compiler_initialize_local(compiler);
         }
         else {
                 uc_compiler_emit_insn(compiler, 0, I_SLOC);
                 uc_compiler_emit_u32(compiler, 0, existing_slot);
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 }
 
 static size_t
 uc_compiler_declare_internal(uc_compiler_t *compiler, size_t srcpos, const char *name)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_locals_t *locals = &compiler->locals;
 
         uc_vector_push(locals, {
                 .name = ucv_string_new(name),
                 .depth = compiler->scope_depth,
                 .captured = false,
                 .from = chunk->count
         });
 
         return locals->count - 1;
 }
 
 /*
  * Destructuring
  *
  * Whether a leading `[` or `{` starts a literal or a pattern is determined by
  * scanning ahead to the matching closing bracket and checking whether an `=`
  * follows, see uc_compiler_scan_literal(). Nothing is compiled or tokenized
  * while doing so, the parser state is not affected.
  *
  * The initializer of a pattern has to be evaluated first, but follows the
  * pattern in the source text. To generate code in source order nevertheless,
  * the code of the pattern precedes the code of the initializer and jumps are
  * used to run them in the right order, see uc_compiler_compile_pattern_assignment().
  */
 
 static int
 uc_bracket_cmp(const void *a, const void *b)
 {
         size_t x = ((const uc_bracket_t *)a)->pos, y = ((const uc_bracket_t *)b)->pos;
 
         return (x > y) - (x < y);
 }
 
 /* Whether the literal whose opening bracket has just been consumed is followed
  * by an equals sign. */
 static uc_follow_t
 uc_compiler_literal_follow(uc_compiler_t *compiler)
 {
         uc_parser_t *parser = compiler->parser;
         uc_bracketlist_t enclosed = { 0 };
         size_t pos = parser->prev.pos, end;
         uc_bracket_t *hit;
         uc_follow_t follow;
 
         /* the first token already tells that most literals are not patterns, which
          * start with an assignment target, a nested pattern, a hole or a rest
          * element in case of arrays and with a key in case of objects */
         switch (parser->curr.type) {
         case TK_LABEL:
         case TK_LBRACK:
         case TK_ELLIP:
                 break;
 
         case TK_THIS:
         case TK_LPAREN:
         case TK_COMMA:
         case TK_LBRACE:
         case TK_RBRACK:
                 if (parser->prev.type != TK_LBRACK)
                         return UC_FOLLOW_OTHER;
 
                 break;
 
         case TK_STRING:
         case TK_RBRACE:
                 if (parser->prev.type != TK_LBRACE)
                         return UC_FOLLOW_OTHER;
 
                 break;
 
         default:
                 return UC_FOLLOW_OTHER;
         }
 
         /* a literal enclosed in one that has been scanned already is known not to
          * be followed by an equals sign unless found back then */
         if (pos > parser->scanned.from && pos < parser->scanned.to) {
                 uc_bracket_t probe = { .pos = pos };
 
                 if (!parser->scanned.count)
                         return UC_FOLLOW_OTHER;
 
                 hit = bsearch(&probe, parser->scanned.entries, parser->scanned.count,
                         sizeof(uc_bracket_t), uc_bracket_cmp);
 
                 if (!hit)
                         return UC_FOLLOW_OTHER;
 
                 return hit->follow;
         }
 
         if (!uc_lexer_skip_balanced(&parser->lex, parser->prev.end, &end, &follow, &enclosed))
                 return UC_FOLLOW_OTHER;
 
         /* remember the result for the literals enclosed in this one */
         free(parser->scanned.entries);
 
         if (enclosed.count > 1)
                 qsort(enclosed.entries, enclosed.count, sizeof(uc_bracket_t), uc_bracket_cmp);
 
         parser->scanned.from = pos;
         parser->scanned.to = end;
         parser->scanned.count = enclosed.count;
         parser->scanned.entries = enclosed.entries;
 
         return follow;
 }
 
 static void
 uc_compiler_emit_uint(uc_compiler_t *compiler, uint64_t u)
 {
         if (u <= 0xff) {
                 uc_compiler_emit_insn(compiler, 0, I_LOAD8);
                 uc_compiler_emit_u8(compiler, 0, u);
         }
         else if (u <= 0xffff) {
                 uc_compiler_emit_insn(compiler, 0, I_LOAD16);
                 uc_compiler_emit_u16(compiler, 0, u);
         }
         else {
                 uc_compiler_emit_insn(compiler, 0, I_LOAD32);
                 uc_compiler_emit_u32(compiler, 0, u);
         }
 }
 
 /* Replace the value on top of the stack by the default value, if it is null.
  * The default value expression is the next one in the source text. */
 static void
 uc_compiler_compile_default(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off;
 
         uc_compiler_emit_copy(compiler, 0, 0);
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         uc_compiler_emit_insn(compiler, 0, I_NES);
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
         uc_compiler_emit_insn(compiler, 0, I_POP);
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 uc_declare_vector(uc_keylist_t, uc_value_t *);
 
 typedef struct {
         bool array;        /* array pattern, otherwise object pattern */
         bool decl;         /* declaration, otherwise assignment */
         bool constant;     /* declaration of constants */
         size_t slot;       /* declaration: local holding the container */
         size_t depth;      /* assignment: stack entries above the container */
         size_t index;      /* array pattern: index of the current element */
         uc_keylist_t keys; /* object pattern: preceding constant keys */
         bool computed;     /* object pattern: preceding computed keys */
 } uc_pattern_t;
 
 static void
 uc_compiler_compile_pattern_body(uc_compiler_t *compiler, uc_pattern_t *pat);
 
 /* Make the variables declared since `first` (in)accessible, e.g. while
  * compiling code which runs before they are assigned. */
 static void
 uc_compiler_locals_set_depth(uc_compiler_t *compiler, size_t first, ssize_t depth)
 {
         size_t i;
 
         for (i = first; i < compiler->locals.count; i++)
                 compiler->locals.entries[i].depth = depth;
 }
 
 /* Compile a nested pattern. The value to destructure is on top of the stack
  * and the opening bracket is the current token. The default value, if any,
  * follows the closing bracket in the source text but needs to run first, so
  * it is emitted behind the code of the pattern:
  *
  *       COPY 0; LNULL; NES; JMPZ default
  *   pat:  <pattern>
  *       JMP end
  *   default: POP; <default value>; JMP pat
  *   end:
  */
 static void
 uc_compiler_compile_nested_pattern(uc_compiler_t *compiler, bool decl, bool constant)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_pattern_t nested = {
                 .array = uc_compiler_parse_check(compiler, TK_LBRACK),
                 .decl = decl,
                 .constant = constant
         };
 
         size_t jmpz_off = 0, jmp_off = 0, pat_off, first;
         uc_follow_t follow;
         size_t end;
         bool dflt = false;
 
         if (!nested.array)
                 compiler->parser->lex.no_keyword = true;
 
         uc_compiler_parse_advance(compiler);
 
         /* the value on the stack becomes a local variable holding the container */
         if (decl) {
                 nested.slot = uc_compiler_declare_internal(compiler, 0, "(destructure)");
                 uc_compiler_initialize_local(compiler);
         }
 
         first = compiler->locals.count;
 
         if (uc_lexer_skip_balanced(&compiler->parser->lex, compiler->parser->prev.end,
                                    &end, &follow, NULL))
                 dflt = (follow == UC_FOLLOW_ASSIGN);
 
         if (dflt) {
                 uc_compiler_emit_copy(compiler, 0, 0);
                 uc_compiler_emit_insn(compiler, 0, I_LNULL);
                 uc_compiler_emit_insn(compiler, 0, I_NES);
                 jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
         }
 
         pat_off = chunk->count;
 
         uc_compiler_compile_pattern_body(compiler, &nested);
 
         if (dflt && uc_compiler_parse_match(compiler, TK_ASSIGN)) {
                 jmp_off = uc_compiler_emit_jmp(compiler, 0);
                 uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
 
                 /* variables of the pattern are not assigned yet */
                 uc_compiler_locals_set_depth(compiler, first, -1);
 
                 uc_compiler_emit_insn(compiler, 0, I_POP);
                 uc_compiler_parse_precedence(compiler, P_ASSIGN);
                 uc_compiler_emit_jmp_dest(compiler, 0, pat_off);
 
                 uc_compiler_locals_set_depth(compiler, first, compiler->scope_depth);
                 uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
         }
 }
 
 /* Emit code loading the property of the container selected by the current
  * item. */
 static void
 uc_compiler_emit_pattern_load(uc_compiler_t *compiler, uc_pattern_t *pat, size_t depth)
 {
         if (pat->decl) {
                 uc_compiler_emit_insn(compiler, 0, I_LLOC);
                 uc_compiler_emit_u32(compiler, 0, pat->slot);
         }
         else if (depth > 0xff) {
                 uc_compiler_syntax_error(compiler, 0, "Destructuring pattern too complex");
         }
         else {
                 uc_compiler_emit_copy(compiler, 0, depth);
         }
 }
 
 /* Compile a rest element, leaving the collected value on top of the stack.
  *
  * The copy destination is created *below* the container, so that the merge
  * consumes the value the pattern load pushed and the stack stays as balanced
  * as it does for an ordinary item.
  *
  * The container is copied first and the items already bound are taken off the
  * copy: an array copy keeps its tail once `splice` removed the bound items
  * from it, an object copy keeps its unbound keys once `rawdelete` dropped the
  * bound ones. Both copies are plain values, so neither operation dispatches
  * metamethods, and the merge is what reports an unsuitable container - `MARR`
  * for a non-array, `MOBJ` for a non-container - like a literal spread does. */
 static void
 uc_compiler_compile_pattern_rest(uc_compiler_t *compiler, uc_pattern_t *pat, size_t depth)
 {
         size_t i;
 
         if (pat->array) {
                 /* copy the array */
                 uc_compiler_emit_insn(compiler, 0, I_NARR);
                 uc_compiler_emit_u32(compiler, 0, 0);
                 /* the destination was pushed first, so the container lies one deeper */
                 uc_compiler_emit_pattern_load(compiler, pat, depth + 1);
                 uc_compiler_emit_insn(compiler, 0, I_MARR);
 
                 /* drop the items already bound; splice removes them from the copy and
                  * returns it, so the copy holding the tail is the result */
                 uc_compiler_emit_insn(compiler, 0, I_LOAD8);
                 uc_compiler_emit_u8(compiler, 0, 0);
                 uc_compiler_emit_uint(compiler, pat->index);
                 uc_compiler_emit_stcall(compiler, 0, UC_FN_SPLICE, 3);
         }
         else {
                 /* copy the properties */
                 uc_compiler_emit_insn(compiler, 0, I_NOBJ);
                 uc_compiler_emit_u32(compiler, 0, 0);
                 uc_compiler_emit_pattern_load(compiler, pat, depth + 1);
                 uc_compiler_emit_insn(compiler, 0, I_MOBJ);
 
                 /* drop the keys the pattern binds; the call consumes its arguments, so
                  * each key is dropped from a duplicate of the copy */
                 for (i = 0; i < pat->keys.count; i++) {
                         uc_compiler_emit_copy(compiler, 0, 0);
                         uc_compiler_emit_constant(compiler, 0, pat->keys.entries[i]);
                         uc_compiler_emit_stcall(compiler, 0, UC_FN_RAWDELETE, 2);
                         uc_compiler_emit_insn(compiler, 0, I_POP);
                 }
         }
 }
 
 /* Compile an item of a pattern, returns true for a rest element. */
 static bool
 uc_compiler_compile_pattern_item(uc_compiler_t *compiler, uc_pattern_t *pat)
 {
         enum { T_NAME, T_VAR, T_MEMBER, T_NESTED } target = T_NAME;
         uc_exprstack_t barrier = { .token = TK_LABEL }, *exprstack;
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_value_t *key = NULL, *name = NULL, *cname;
         size_t start, d = pat->depth, operand = 0, tpos = 0;
         bool rest, computed = false, loaded = false;
         uc_vm_insn_t store = 0, load;
         ssize_t slot = -1;
 
         rest = uc_compiler_parse_match(compiler, TK_ELLIP);
 
         /* property key */
         if (!pat->array && !rest) {
                 if (uc_compiler_parse_match(compiler, TK_LBRACK)) {
                         computed = true;
                         pat->computed = true;
 
                         if (pat->decl) {
                                 /* the container is loaded first, followed by the key */
                                 uc_compiler_emit_pattern_load(compiler, pat, 0);
                                 uc_compiler_parse_precedence(compiler, P_ASSIGN);
                                 uc_compiler_emit_insn(compiler, 0, I_LVAL);
                                 loaded = true;
                         }
                         else {
                                 /* the key stays on the stack below the target */
                                 uc_compiler_parse_precedence(compiler, P_ASSIGN);
                                 d++;
                         }
 
                         uc_compiler_parse_consume(compiler, TK_RBRACK);
                         uc_compiler_parse_consume(compiler, TK_COLON);
                 }
                 else if (uc_compiler_parse_match(compiler, TK_LABEL) ||
                          uc_compiler_parse_match(compiler, TK_STRING)) {
                         bool label = (compiler->parser->prev.type == TK_LABEL);
 
                         key = ucv_get(compiler->parser->prev.uv);
 
                         if (!uc_compiler_parse_match(compiler, TK_COLON)) {
                                 if (!label || uc_lexer_is_keyword(key))
                                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                                 label ? "Invalid identifier" : "Unexpected token\nExpecting ':'");
 
                                 /* shorthand property, the key is also the variable name */
                                 name = ucv_get(key);
                         }
 
                         uc_vector_push(&pat->keys, ucv_get(key));
                 }
                 else {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting label");
 
                         return true;
                 }
         }
 
         /* declarations load the value before the target is parsed */
         if (pat->decl && !loaded) {
                 if (rest) {
                         if (!pat->array && pat->computed)
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Computed keys cannot precede a rest element");
 
                         uc_compiler_compile_pattern_rest(compiler, pat, 0);
                 }
                 else {
                         uc_compiler_emit_pattern_load(compiler, pat, 0);
 
                         if (pat->array)
                                 uc_compiler_emit_uint(compiler, pat->index);
                         else
                                 uc_compiler_emit_constant(compiler, 0, key);
 
                         uc_compiler_emit_insn(compiler, 0, I_LVAL);
                 }
 
                 loaded = true;
         }
 
         /* target */
         if (name) {
                 target = T_NAME;
         }
         else if (uc_compiler_parse_check(compiler, TK_LBRACK) ||
                  uc_compiler_parse_check(compiler, TK_LBRACE)) {
                 target = T_NESTED;
         }
         else if (pat->decl) {
                 if (!uc_compiler_parse_match(compiler, TK_LABEL)) {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting variable name or pattern");
 
                         ucv_put(key);
 
                         return true;
                 }
 
                 name = ucv_get(compiler->parser->prev.uv);
         }
         else {
                 tpos = compiler->parser->curr.pos;
                 start = chunk->count;
 
                 /* the target must not consume a following `= default` as assignment */
                 exprstack = compiler->exprstack;
                 compiler->exprstack = &barrier;
                 uc_compiler_parse_precedence(compiler, P_CALL);
                 compiler->exprstack = exprstack;
 
                 load = (chunk->count > start) ? chunk->entries[compiler->last_insn] : 0;
 
                 if (chunk->count - start == 5 && (load == I_LLOC || load == I_LUPV || load == I_LVAR)) {
                         operand = uc_compiler_get_u32(compiler, compiler->last_insn + 1);
 
                         if ((load == I_LLOC && compiler->locals.entries[operand].constant) ||
                             (load == I_LUPV && compiler->upvals.entries[operand].constant)) {
                                 cname = (load == I_LLOC)
                                         ? compiler->locals.entries[operand].name
                                         : compiler->upvals.entries[operand].name;
 
                                 uc_compiler_syntax_error(compiler, tpos,
                                         "Invalid assignment to constant '%s'", ucv_string_get(cname));
                         }
 
                         store = (load == I_LLOC) ? I_SLOC : (load == I_LUPV) ? I_SUPV : I_SVAR;
                         target = T_VAR;
 
                         for (int i = 0; i < 5; i++)
                                 uc_chunk_pop(chunk);
                 }
                 else if (load == I_LVAL && uc_compiler_check_assignment_lhs(compiler)) {
                         target = T_MEMBER;
                         d += 2;
 
                         uc_chunk_pop(chunk);
                 }
                 else {
                         uc_compiler_syntax_error(compiler, tpos, "Invalid destructuring target");
 
                         ucv_put(key);
 
                         return true;
                 }
         }
 
         /* a target is followed by a default value or the end of the item */
         if (!uc_compiler_parse_check(compiler, TK_COMMA) &&
             !uc_compiler_parse_check(compiler, TK_ASSIGN) &&
             !uc_compiler_parse_check(compiler, pat->array ? TK_RBRACK : TK_RBRACE) &&
             target != T_NESTED) {
                 uc_compiler_syntax_error(compiler, tpos ? tpos : compiler->parser->curr.pos,
                         "Invalid destructuring target");
         }
 
         /* assignments load the value after evaluating the target */
         if (!loaded) {
                 if (rest) {
                         if (!pat->array && pat->computed)
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Computed keys cannot precede a rest element");
 
                         uc_compiler_compile_pattern_rest(compiler, pat, d);
                 }
                 else {
                         uc_compiler_emit_pattern_load(compiler, pat, d);
 
                         if (pat->array)
                                 uc_compiler_emit_uint(compiler, pat->index);
                         else if (key)
                                 uc_compiler_emit_constant(compiler, 0, key);
                         else
                                 uc_compiler_emit_copy(compiler, 0, (target == T_MEMBER ? 2 : 0) + 1);
 
                         uc_compiler_emit_insn(compiler, 0, I_LVAL);
                 }
         }
 
         if (target == T_NESTED) {
                 if (rest && uc_compiler_parse_check(compiler, TK_ASSIGN))
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Rest element cannot have a default value");
 
                 uc_compiler_compile_nested_pattern(compiler, pat->decl, pat->constant);
 
                 if (!pat->decl)
                         uc_compiler_emit_insn(compiler, 0, I_POP);
         }
         else {
                 /* declare the variable before parsing the default value so that it
                  * cannot refer to itself */
                 if (pat->decl)
                         slot = uc_compiler_declare_local(compiler, name, pat->constant);
 
                 if (uc_compiler_parse_match(compiler, TK_ASSIGN)) {
                         if (rest)
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Rest element cannot have a default value");
 
                         uc_compiler_compile_default(compiler);
                 }
 
                 if (pat->decl) {
                         if (slot == -1) {
                                 uc_compiler_initialize_local(compiler);
                         }
                         else {
                                 uc_compiler_emit_insn(compiler, 0, I_SLOC);
                                 uc_compiler_emit_u32(compiler, 0, slot);
                                 uc_compiler_emit_insn(compiler, 0, I_POP);
                         }
                 }
                 else if (target == T_NAME) {
                         uc_compiler_emit_variable_rw(compiler, name, TK_ASSIGN);
                         uc_compiler_emit_insn(compiler, 0, I_POP);
                 }
                 else if (target == T_VAR) {
                         uc_compiler_emit_insn(compiler, 0, store);
                         uc_compiler_emit_u32(compiler, 0, operand);
                         uc_compiler_emit_insn(compiler, 0, I_POP);
                 }
                 else {
                         uc_compiler_emit_insn(compiler, 0, I_SVAL);
                         uc_compiler_emit_insn(compiler, 0, I_POP);
                 }
         }
 
         if (computed && !pat->decl)
                 uc_compiler_emit_insn(compiler, 0, I_POP);
 
         ucv_put(key);
         ucv_put(name);
 
         return rest;
 }
 
 static void
 uc_compiler_compile_pattern_body(uc_compiler_t *compiler, uc_pattern_t *pat)
 {
         uc_tokentype_t closer = pat->array ? TK_RBRACK : TK_RBRACE;
         size_t i;
 
         while (!uc_compiler_parse_check(compiler, closer)) {
                 /* hole */
                 if (pat->array && uc_compiler_parse_match(compiler, TK_COMMA)) {
                         pat->index++;
 
                         continue;
                 }
 
                 if (uc_compiler_compile_pattern_item(compiler, pat)) {
                         if (!uc_compiler_parse_check(compiler, closer))
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Rest element must be last element");
 
                         break;
                 }
 
                 pat->index++;
 
                 if (!pat->array)
                         compiler->parser->lex.no_keyword = true;
 
                 if (!uc_compiler_parse_match(compiler, TK_COMMA))
                         break;
         }
 
         uc_compiler_parse_consume(compiler, closer);
 
         for (i = 0; i < pat->keys.count; i++)
                 ucv_put(pat->keys.entries[i]);
 
         uc_vector_clear(&pat->keys);
 }
 
 /* Compile the pattern and initializer of a destructuring assignment or
  * declaration. The initializer has to be evaluated first but follows the
  * pattern in the source text, so the code of the pattern precedes the code of
  * the initializer and jumps are used to run them in the right order:
  *
  *       JMP init
  *   pat:  <pattern>
  *       JMP end
  *   init: <initializer>
  *       JMP pat
  *   end:
  *
  * The opening bracket has been consumed already. */
 static void
 uc_compiler_compile_pattern_assignment(uc_compiler_t *compiler, uc_pattern_t *pat)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t first = compiler->locals.count, jmp_init, jmp_end, pat_off;
 
         jmp_init = uc_compiler_emit_jmp(compiler, 0);
         pat_off = chunk->count;
 
         uc_compiler_compile_pattern_body(compiler, pat);
 
         jmp_end = uc_compiler_emit_jmp(compiler, 0);
         uc_compiler_set_jmpaddr(compiler, jmp_init, chunk->count);
 
         if (!uc_compiler_parse_match(compiler, TK_ASSIGN)) {
                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                         "Expecting initializer expression");
 
                 return;
         }
 
         /* declared variables must not be accessible from the initializer */
         uc_compiler_locals_set_depth(compiler, first, -1);
 
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
 
         uc_compiler_locals_set_depth(compiler, first, compiler->scope_depth);
 
         uc_compiler_emit_jmp_dest(compiler, 0, pat_off);
         uc_compiler_set_jmpaddr(compiler, jmp_end, chunk->count);
 }
 
 /* Compile a destructuring assignment if the array or object literal whose
  * opening bracket has just been consumed is followed by `=`. */
 static bool
 uc_compiler_compile_destructuring(uc_compiler_t *compiler)
 {
         uc_pattern_t pat = { .array = (compiler->parser->prev.type == TK_LBRACK) };
 
         /* a literal starting an assignment expression might be a pattern */
         if (!(compiler->exprstack->flags & F_ASSIGNABLE) ||
             uc_compiler_literal_follow(compiler) != UC_FOLLOW_ASSIGN)
                 return false;
 
         uc_compiler_compile_pattern_assignment(compiler, &pat);
 
         return true;
 }
 
 static void
 uc_compiler_compile_destructuring_declaration(uc_compiler_t *compiler, bool constant)
 {
         uc_pattern_t pat = {
                 .array = uc_compiler_parse_check(compiler, TK_LBRACK),
                 .decl = true,
                 .constant = constant
         };
 
         if (!pat.array)
                 compiler->parser->lex.no_keyword = true;
 
         uc_compiler_parse_advance(compiler);
 
         /* the initializer becomes the container */
         pat.slot = uc_compiler_declare_internal(compiler, 0, "(destructure)");
 
         uc_compiler_compile_pattern_assignment(compiler, &pat);
 }
 
 static void
 uc_compiler_compile_declexpr(uc_compiler_t *compiler, bool constant)
 {
         ssize_t slot;
 
         do {
                 /* destructuring declaration */
                 if (uc_compiler_parse_check(compiler, TK_LBRACK) ||
                     uc_compiler_parse_check(compiler, TK_LBRACE)) {
                         uc_compiler_compile_destructuring_declaration(compiler, constant);
 
                         continue;
                 }
 
                 /* parse variable name */
                 if (!uc_compiler_parse_match(compiler, TK_LABEL)) {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting variable name");
 
                         return;
                 }
 
                 /* declare local variable */
                 slot = uc_compiler_declare_local(compiler, compiler->parser->prev.uv, constant);
 
                 /* if followed by '=', parse initializer expression */
                 if (uc_compiler_parse_match(compiler, TK_ASSIGN))
                         uc_compiler_parse_precedence(compiler, P_ASSIGN);
                 /* otherwise, for writable variables, load implicit null */
                 else if (!constant)
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL);
                 /* for constant variables, a missing initializer is a syntax error */
                 else
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Expecting initializer expression");
 
                 /* initialize local */
                 if (slot == -1) {
                         uc_compiler_initialize_local(compiler);
                 }
                 /* if the variable was redeclared, overwrite it */
                 else {
                         uc_compiler_emit_insn(compiler, 0, I_SLOC);
                         uc_compiler_emit_u32(compiler, 0, slot);
                         uc_compiler_emit_insn(compiler, 0, I_POP);
                 }
         }
         while (uc_compiler_parse_match(compiler, TK_COMMA));
 }
 
 static void
 uc_compiler_compile_local(uc_compiler_t *compiler)
 {
         uc_compiler_emit_stmt_start(compiler, &compiler->parser->prev);
         uc_compiler_compile_declexpr(compiler, false);
         uc_compiler_parse_consume(compiler, TK_SCOL);
         uc_compiler_emit_stmt_end(compiler);
 }
 
 static void
 uc_compiler_compile_const(uc_compiler_t *compiler)
 {
         uc_compiler_emit_stmt_start(compiler, &compiler->parser->prev);
         uc_compiler_compile_declexpr(compiler, true);
         uc_compiler_parse_consume(compiler, TK_SCOL);
         uc_compiler_emit_stmt_end(compiler);
 }
 
 static uc_tokentype_t
 uc_compiler_compile_altifblock(uc_compiler_t *compiler)
 {
         uc_compiler_enter_scope(compiler);
 
         while (true) {
                 switch (compiler->parser->curr.type) {
                 case TK_ELIF:
                 case TK_ELSE:
                 case TK_ENDIF:
                 case TK_EOF:
                         uc_compiler_leave_scope(compiler);
 
                         return compiler->parser->curr.type;
 
                 default:
                         uc_compiler_compile_declaration(compiler);
                         break;
                 }
         }
 
         return 0;
 }
 
 static void
 uc_compiler_compile_if(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t jmpz_off, jmp_off, i;
         bool expect_endif = false;
         uc_jmplist_t elifs = { 0 };
         uc_tokentype_t type;
 
         /* parse & compile condition expression */
         uc_compiler_parse_consume(compiler, TK_LPAREN);
         uc_compiler_compile_expression(compiler, true);
         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
         /* conditional jump to else/elif branch */
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
 
         if (uc_compiler_parse_match(compiler, TK_COLON)) {
                 compiler->exprstack->flags |= F_ALTBLOCKMODE;
 
                 while (true) {
                         /* compile elsif or else branch */
                         type = uc_compiler_compile_altifblock(compiler);
 
                         /* we just compiled an elsif block */
                         if (!expect_endif && type == TK_ELIF) {
                                 /* emit jump to skip to the end */
                                 uc_vector_push(&elifs, uc_compiler_emit_jmp(compiler, 0));
 
                                 /* point previous conditional jump to beginning of branch */
                                 uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
 
                                 /* parse & compile elsif condition */
                                 uc_compiler_parse_advance(compiler);
                                 uc_compiler_parse_consume(compiler, TK_LPAREN);
                                 uc_compiler_compile_expression(compiler, true);
                                 uc_compiler_parse_consume(compiler, TK_RPAREN);
                                 uc_compiler_parse_consume(compiler, TK_COLON);
 
                                 /* conditional jump to else/elif branch */
                                 jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
                         }
                         else if (!expect_endif && type == TK_ELSE) {
                                 /* emit jump to skip to the end */
                                 uc_vector_push(&elifs, uc_compiler_emit_jmp(compiler, 0));
 
                                 /* point previous conditional jump to beginning of branch */
                                 uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
                                 jmpz_off = 0;
 
                                 /* skip "else" keyword */
                                 uc_compiler_parse_advance(compiler);
 
                                 expect_endif = true;
                         }
                         else if (type == TK_ENDIF) {
                                 /* if no else clause, point previous conditional jump after block */
                                 if (jmpz_off)
                                         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
 
                                 /* patch the elif branch jumps to point here after the else */
                                 for (i = 0; i < elifs.count; i++)
                                         uc_compiler_set_jmpaddr(compiler, elifs.entries[i],
                                                 chunk->count);
 
                                 /* skip the "endif" keyword */
                                 uc_compiler_parse_advance(compiler);
                                 break;
                         }
                         else {
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         expect_endif
                                                 ? "Expecting 'endif'"
                                                 : "Expecting 'elif', 'else' or 'endif'");
 
                                 break;
                         }
                 }
 
                 uc_vector_clear(&elifs);
         }
         else {
                 /* compile true branch */
                 uc_compiler_compile_statement(compiler);
 
                 /* ... when present, handle false branch */
                 if (uc_compiler_parse_match(compiler, TK_ELSE)) {
                         /* jump to skip else branch */
                         jmp_off = uc_compiler_emit_jmp(compiler, 0);
 
                         /* set conditional jump address */
                         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
 
                         /* compile false branch */
                         uc_compiler_compile_statement(compiler);
 
                         /* set else skip jump address */
                         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
                 }
                 /* ... otherwise point the conditional jump after the true branch */
                 else {
                         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
                 }
         }
 }
 
 static void
 uc_compiler_compile_while(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_patchlist_t p = { .depth = compiler->scope_depth, .token = TK_WHILE };
         size_t cond_off, jmpz_off, end_off;
 
         p.parent = compiler->patchlist;
         compiler->patchlist = &p;
 
         cond_off = chunk->count;
 
         /* parse & compile loop condition */
         uc_compiler_parse_consume(compiler, TK_LPAREN);
         uc_compiler_compile_expression(compiler, true);
         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
         /* conditional jump to end */
         jmpz_off = uc_compiler_emit_jmpz(compiler, 0);
 
         /* compile loop body */
         if (uc_compiler_parse_match(compiler, TK_COLON)) {
                 uc_compiler_enter_scope(compiler);
 
                 if (uc_compiler_compile_delimitted_block(compiler, TK_ENDWHILE) == TK_EOF)
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting 'endwhile'");
                 else
                         uc_compiler_parse_advance(compiler);
 
                 uc_compiler_leave_scope(compiler);
         }
         else {
                 uc_compiler_compile_statement(compiler);
         }
 
         end_off = chunk->count;
 
         /* jump back to condition */
         uc_compiler_emit_jmp_dest(compiler, 0, cond_off);
 
         /* set conditional jump target */
         uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count);
 
         /* patch up break/continue */
         uc_compiler_backpatch(compiler, chunk->count, end_off);
 }
 
 static void
 uc_compiler_compile_for_in(uc_compiler_t *compiler, bool local, uc_token_t *kvar, uc_token_t *vvar)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_patchlist_t p = { .depth = compiler->scope_depth + 1, .token = TK_FOR };
         size_t skip_jmp, test_jmp, key_slot, val_slot;
 
         p.parent = compiler->patchlist;
         compiler->patchlist = &p;
 
         uc_compiler_enter_scope(compiler);
 
         /* declare internal loop variables */
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         key_slot = uc_compiler_declare_internal(compiler, 0, "(for in key)");
 
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         val_slot = uc_compiler_declare_internal(compiler, 0, "(for in value)");
 
         /* declare loop variables */
         if (local) {
                 uc_compiler_declare_local_null(compiler, kvar->pos, kvar->uv);
 
                 if (vvar)
                         uc_compiler_declare_local_null(compiler, vvar->pos, vvar->uv);
         }
 
         /* value to iterate */
         uc_compiler_compile_expression(compiler, false);
         uc_compiler_emit_stmt_end(compiler);
         uc_compiler_parse_consume(compiler, TK_RPAREN);
         uc_compiler_emit_insn(compiler, 0, I_SLOC);
         uc_compiler_emit_u32(compiler, 0, val_slot);
 
         /* initial key value */
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         uc_compiler_emit_insn(compiler, 0, I_SLOC);
         uc_compiler_emit_u32(compiler, 0, key_slot);
 
         /* jump over variable read for first cycle */
         skip_jmp = uc_compiler_emit_jmp(compiler, 0);
 
         /* read value */
         uc_compiler_emit_insn(compiler, 0, I_LLOC);
         uc_compiler_emit_u32(compiler, 0, val_slot);
 
         /* read key */
         uc_compiler_emit_insn(compiler, 0, I_LLOC);
         uc_compiler_emit_u32(compiler, 0, key_slot);
 
         /* backpatch skip jump */
         uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count);
 
         /* load loop variable and get next key from object */
         uc_compiler_emit_insn(compiler, 0, vvar ? I_NEXTKV : I_NEXTK);
 
         /* set internal key variable */
         uc_compiler_emit_insn(compiler, 0, I_SLOC);
         uc_compiler_emit_u32(compiler, 0, key_slot);
 
         /* test for != null */
         uc_compiler_emit_insn(compiler, 0, I_LNULL);
         uc_compiler_emit_insn(compiler, 0, I_NES);
 
         /* jump after loop body if no next key */
         test_jmp = uc_compiler_emit_jmpz(compiler, 0);
 
         /* set key and value variables */
         if (vvar) {
                 uc_compiler_emit_variable_rw(compiler, vvar->uv, TK_ASSIGN);
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 
         /* set key variable */
         uc_compiler_emit_variable_rw(compiler, kvar->uv, TK_ASSIGN);
         uc_compiler_emit_insn(compiler, 0, I_POP);
 
         /* compile loop body */
         if (uc_compiler_parse_match(compiler, TK_COLON)) {
                 uc_compiler_enter_scope(compiler);
 
                 if (uc_compiler_compile_delimitted_block(compiler, TK_ENDFOR) == TK_EOF)
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting 'endfor'");
                 else
                         uc_compiler_parse_advance(compiler);
 
                 uc_compiler_leave_scope(compiler);
         }
         else {
                 uc_compiler_compile_statement(compiler);
         }
 
         /* jump back to retrieve next key */
         uc_compiler_emit_jmp_dest(compiler, 0, skip_jmp + 5);
 
         /* back patch conditional jump */
         uc_compiler_set_jmpaddr(compiler, test_jmp, chunk->count);
 
         /* pop loop variables */
         uc_compiler_emit_insn(compiler, 0, I_POP);
 
         if (vvar)
                 uc_compiler_emit_insn(compiler, 0, I_POP);
 
         /* patch up break/continue */
         uc_compiler_backpatch(compiler, chunk->count, skip_jmp + 5);
 
         uc_compiler_leave_scope(compiler);
 }
 
 static void
 uc_compiler_compile_for_count(uc_compiler_t *compiler, bool local, uc_token_t *predecl, uc_token_t *var)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t test_off = 0, incr_off, skip_off, cond_off = 0;
         uc_patchlist_t p = { .depth = compiler->scope_depth + 1, .token = TK_FOR };
 
         p.parent = compiler->patchlist;
         compiler->patchlist = &p;
 
         uc_compiler_enter_scope(compiler);
 
         /* Initializer ---------------------------------------------------------- */
 
         /* A leading declaration without initializer, e.g. the `x` in
          * `for (let x, y = 0; ...)`, was consumed while disambiguating for-in */
         if (predecl && local)
                 uc_compiler_declare_local_null(compiler, predecl->pos, predecl->uv);
 
         /* If we parsed at least one label, try continue parsing as variable
          * expression... */
         if (var) {
                 /* We parsed a `local x` or `local x, y` expression, so (re)declare
                  * last label as local initializer variable */
                 if (local)
                         uc_compiler_declare_local_null(compiler, var->pos, var->uv);
 
                 uc_compiler_exprstack_push(compiler, TK_FOR, F_ASSIGNABLE);
 
                 uc_compiler_compile_labelexpr(compiler);
                 uc_compiler_emit_insn(compiler, 0, I_POP);
 
                 /* If followed by a comma, continue parsing expression */
                 if (uc_compiler_parse_match(compiler, TK_COMMA)) {
                         /* Is a continuation of a declaration list... */
                         if (local) {
                                 uc_compiler_compile_declexpr(compiler, false);
                         }
                         /* ... otherwise an unrelated expression */
                         else {
                                 uc_compiler_compile_expression(compiler, false);
                                 uc_compiler_emit_insn(compiler, 0, I_POP);
                         }
                 }
 
                 uc_compiler_exprstack_pop(compiler);
         }
         /* ... otherwise try parsing an entire expression (which might be absent) */
         else if (!uc_compiler_parse_check(compiler, TK_SCOL)) {
                 uc_compiler_compile_expression(compiler, false);
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 
         uc_compiler_emit_stmt_end(compiler);
         uc_compiler_parse_consume(compiler, TK_SCOL);
 
 
         /* Condition ------------------------------------------------------------ */
         if (!uc_compiler_parse_check(compiler, TK_SCOL)) {
                 cond_off = chunk->count;
 
                 uc_compiler_compile_expression(compiler, true);
 
                 test_off = uc_compiler_emit_jmpz(compiler, 0);
         }
 
         uc_compiler_parse_consume(compiler, TK_SCOL);
 
         /* jump over incrementer */
         skip_off = uc_compiler_emit_jmp(compiler, 0);
 
 
         /* Incrementer ---------------------------------------------------------- */
         incr_off = chunk->count;
 
         if (!uc_compiler_parse_check(compiler, TK_RPAREN)) {
                 uc_compiler_compile_expression(compiler, true);
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 
         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
         /* if we have a condition, jump back to it, else continue to the loop body */
         if (test_off)
                 uc_compiler_emit_jmp_dest(compiler, 0, cond_off);
 
         /* back patch skip address */
         uc_compiler_set_jmpaddr(compiler, skip_off, chunk->count);
 
 
         /* Body ----------------------------------------------------------------- */
         if (uc_compiler_parse_match(compiler, TK_COLON)) {
                 uc_compiler_enter_scope(compiler);
 
                 if (uc_compiler_compile_delimitted_block(compiler, TK_ENDFOR) == TK_EOF)
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting 'endfor'");
                 else
                         uc_compiler_parse_advance(compiler);
 
                 uc_compiler_leave_scope(compiler);
         }
         else {
                 uc_compiler_compile_statement(compiler);
         }
 
         /* jump back to incrementer */
         uc_compiler_emit_jmp_dest(compiler, 0, incr_off);
 
         /* back patch conditional jump */
         if (test_off)
                 uc_compiler_set_jmpaddr(compiler, test_off, chunk->count);
 
         /* patch up break/continue */
         uc_compiler_backpatch(compiler, chunk->count, incr_off);
 
         uc_compiler_leave_scope(compiler);
 }
 
 static void
 uc_compiler_compile_for(uc_compiler_t *compiler)
 {
         uc_token_t keyvar = { 0 }, valvar = { 0 };
         bool local;
 
         uc_compiler_parse_consume(compiler, TK_LPAREN);
 
         uc_compiler_emit_stmt_start(compiler, &compiler->parser->curr);
 
         /* check the next few tokens and see if we have either a
          * `let x in` / `let x, y` expression or an ordinary initializer
          * statement */
 
         local = uc_compiler_parse_match(compiler, TK_LOCAL);
 
         if (uc_compiler_parse_match(compiler, TK_LABEL)) {
                 keyvar = compiler->parser->prev;
                 ucv_get(keyvar.uv);
 
                 if (uc_compiler_parse_match(compiler, TK_COMMA)) {
                         uc_compiler_parse_consume(compiler, TK_LABEL);
 
                         valvar = compiler->parser->prev;
                         ucv_get(valvar.uv);
                 }
 
                 /* is a for-in loop */
                 if (uc_compiler_parse_match(compiler, TK_IN)) {
                         uc_compiler_compile_for_in(compiler, local, &keyvar,
                                 valvar.type ? &valvar : NULL);
 
                         goto out;
                 }
         }
         else if (local) {
                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                         "Expecting label after 'local'");
 
                 goto out;
         }
 
         /*
          * The previous expression ruled out a for-in loop, so continue parsing
          * as counting for loop...
          */
         if (valvar.uv)
                 uc_compiler_compile_for_count(compiler, local,
                         keyvar.uv ? &keyvar : NULL, &valvar);
         else
                 uc_compiler_compile_for_count(compiler, local,
                         NULL, keyvar.uv ? &keyvar : NULL);
 
 out:
         ucv_put(keyvar.uv);
         ucv_put(valvar.uv);
 }
 
 static void
 uc_compiler_compile_switch(uc_compiler_t *compiler)
 {
         size_t i, test_jmp, skip_jmp, next_jmp = 0, value_slot, default_off = 0;
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_patchlist_t p = { .depth = compiler->scope_depth, .token = TK_SWITCH };
         uc_locals_t *locals = &compiler->locals;
         uc_jmplist_t cases = { 0 };
 
         p.parent = compiler->patchlist;
         compiler->patchlist = &p;
 
         uc_compiler_enter_scope(compiler);
 
         /* parse and compile match value */
         uc_compiler_parse_consume(compiler, TK_LPAREN);
         uc_compiler_compile_expression(compiler, true);
         uc_compiler_parse_consume(compiler, TK_RPAREN);
         uc_compiler_parse_consume(compiler, TK_LBRACE);
 
         value_slot = uc_compiler_declare_internal(compiler, 0, "(switch value)");
 
         /* jump to branch tests */
         test_jmp = uc_compiler_emit_jmp(compiler, 0);
 
         /* parse and compile case matches */
         while (!uc_compiler_parse_check(compiler, TK_RBRACE) &&
                !uc_compiler_parse_check(compiler, TK_EOF)) {
                 /* handle `default:` */
                 if (uc_compiler_parse_match(compiler, TK_DEFAULT)) {
                         if (default_off) {
                                 uc_vector_clear(&cases);
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "more than one switch default case");
 
                                 break;
                         }
 
                         uc_compiler_parse_consume(compiler, TK_COLON);
 
                         /* remember address of default branch */
                         default_off = chunk->count;
 
                         /* Store three values in case offset list:
                          *  1) amount of local variables declared so far
                          *  2) beginning of condition expression
                          *  3) end of condition expression
                          * For the `default` case, beginning and end offsets of the
                          * condition expression are equal.
                          */
                         uc_vector_extend(&cases, 3);
                         cases.entries[cases.count++] = (locals->count - 1) - value_slot;
                         cases.entries[cases.count++] = chunk->count;
                         cases.entries[cases.count++] = chunk->count;
                 }
 
                 /* handle `case …:` */
                 else if (uc_compiler_parse_match(compiler, TK_CASE)) {
                         /* jump over `case …:` label expression */
                         skip_jmp = uc_compiler_emit_jmp(compiler, 0);
 
                         /* compile case value expression */
                         uc_compiler_compile_expression(compiler, false);
                         uc_compiler_parse_consume(compiler, TK_COLON);
 
                         /* Store three values in case offset list:
                          *  1) amount of local variables declared so far
                          *  2) beginning of condition expression
                          *  3) end of condition expression
                          */
                         uc_vector_extend(&cases, 3);
                         cases.entries[cases.count++] = (locals->count - 1) - value_slot;
                         cases.entries[cases.count++] = skip_jmp + 5;
                         cases.entries[cases.count++] = uc_compiler_emit_jmp(compiler, 0);
 
                         /* patch jump skipping over the case value */
                         uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count);
                 }
 
                 /* handle interleaved statement */
                 else if (cases.count) {
                         uc_compiler_compile_declaration(compiler);
                 }
 
                 /* a statement or expression preceding any `default` or `case` is a
                  * syntax error */
                 else {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Expecting 'case' or 'default'");
 
                         break;
                 }
         }
 
         uc_compiler_parse_consume(compiler, TK_RBRACE);
 
         /* evaluate case matches */
         if (cases.count) {
                 skip_jmp = uc_compiler_emit_jmp(compiler, 0);
 
                 uc_compiler_set_jmpaddr(compiler, test_jmp, chunk->count);
 
                 for (i = 0, default_off = cases.count; i < cases.count; i += 3) {
                         /* remember and skip default case */
                         if (cases.entries[i + 1] == cases.entries[i + 2]) {
                                 default_off = i;
                                 continue;
                         }
 
                         /* read switch match value */
                         uc_compiler_emit_insn(compiler, 0, I_LLOC);
                         uc_compiler_emit_u32(compiler, 0, value_slot);
 
                         /* jump to case value expression code */
                         uc_compiler_emit_jmp_dest(compiler, 0, cases.entries[i + 1]);
 
                         /* patch final case value expression jump back here */
                         uc_compiler_set_jmpaddr(compiler, cases.entries[i + 2], chunk->count);
 
                         /* strict equal test */
                         uc_compiler_emit_insn(compiler, 0, I_EQS);
 
                         /* conditional jump to next match */
                         next_jmp = uc_compiler_emit_jmpz(compiler, 0);
 
                         /* fill local slots */
                         while (cases.entries[i + 0] > 0) {
                                 uc_compiler_emit_insn(compiler, 0, I_LNULL);
                                 cases.entries[i + 0]--;
                         }
 
                         /* jump to target code */
                         uc_compiler_emit_jmp_dest(compiler, 0, cases.entries[i + 2] + 5);
 
                         /* patch next jump */
                         uc_compiler_set_jmpaddr(compiler, next_jmp, chunk->count);
                 }
 
                 /* handle default case (if any) */
                 if (default_off < cases.count) {
                         /* fill local slots */
                         while (cases.entries[default_off + 0] > 0) {
                                 uc_compiler_emit_insn(compiler, 0, I_LNULL);
                                 cases.entries[default_off + 0]--;
                         }
 
                         /* jump to target */
                         uc_compiler_emit_jmp_dest(compiler, 0, cases.entries[default_off + 2]);
 
                         /* do not patch final match failure jump later, we handle it here
                          * in the default case */
                         next_jmp = 0;
                 }
 
                 uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count);
         }
         else {
                 uc_compiler_set_jmpaddr(compiler, test_jmp, test_jmp + 5);
         }
 
         uc_vector_clear(&cases);
 
         uc_compiler_leave_scope(compiler);
 
         /* if no default case exists, patch last case match failure jump */
         if (next_jmp) {
                 /* There's pop instructions for all local variables including the
                  * switch test value itself on the stack. Jump onto the last POP
                  * instruction (-1) to get rid of the on-stack switch test value
                  * but skip the POP instructions for all other scoped local variables
                  * which never have been initialized. */
                 uc_compiler_set_jmpaddr(compiler, next_jmp, chunk->count - 1);
         }
 
         uc_compiler_backpatch(compiler, chunk->count, 0);
 }
 
 static void
 uc_compiler_compile_try(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t try_from = 0, try_to = 0, jmp_off = 0, ehvar_slot = 0;
         uc_ehranges_t *ranges = &chunk->ehranges;
 
         try_from = chunk->count;
         ehvar_slot = compiler->locals.count;
 
         /* Try block ------------------------------------------------------------ */
         uc_compiler_enter_scope(compiler);
 
         /* while compiling the protected block, tail calls are avoided since the
          * current frame must be kept around to catch callee exceptions */
         compiler->try_depth++;
 
         uc_compiler_parse_consume(compiler, TK_LBRACE);
 
         while (!uc_compiler_parse_check(compiler, TK_RBRACE) &&
                !uc_compiler_parse_check(compiler, TK_EOF))
                 uc_compiler_compile_declaration(compiler);
 
         uc_compiler_parse_consume(compiler, TK_RBRACE);
 
         compiler->try_depth--;
 
         uc_compiler_leave_scope(compiler);
 
         /* jump beyond catch branch */
         try_to = chunk->count;
         jmp_off = uc_compiler_emit_jmp(compiler, 0);
 
 
         /* Catch block ---------------------------------------------------------- */
         if (try_to > try_from) {
                 uc_vector_push(ranges, {
                         .from   = try_from,
                         .to     = try_to,
                         .target = chunk->count,
                         .slot   = ehvar_slot
                 });
         }
 
         uc_compiler_enter_scope(compiler);
 
         uc_compiler_parse_consume(compiler, TK_CATCH);
 
         /* have exception variable */
         if (uc_compiler_parse_match(compiler, TK_LPAREN)) {
                 uc_compiler_parse_consume(compiler, TK_LABEL);
 
                 uc_compiler_declare_local(compiler, compiler->parser->prev.uv, false);
                 uc_compiler_initialize_local(compiler);
 
                 uc_compiler_parse_consume(compiler, TK_RPAREN);
         }
         /* ... else pop exception object from stack */
         else {
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 
         uc_compiler_parse_consume(compiler, TK_LBRACE);
 
         while (!uc_compiler_parse_check(compiler, TK_RBRACE) &&
                !uc_compiler_parse_check(compiler, TK_EOF))
                 uc_compiler_compile_declaration(compiler);
 
         uc_compiler_parse_consume(compiler, TK_RBRACE);
 
         uc_compiler_leave_scope(compiler);
 
         uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count);
 }
 
 static void
 uc_compiler_compile_control(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         uc_tokentype_t type = compiler->parser->prev.type;
         uc_patchlist_t *p = compiler->patchlist;
         uc_locals_t *locals = &compiler->locals;
         size_t i, pos = compiler->parser->prev.pos;
 
         /* select applicable patchlist: for continue statements select the
          * first non-switch scope */
         while (p) {
                 if (type != TK_CONTINUE || p->token != TK_SWITCH)
                         break;
 
                 p = p->parent;
         }
 
         if (!p || p->token == TK_EXPORT) {
                 uc_compiler_syntax_error(compiler, pos,
                         (type == TK_BREAK)
                                 ? "break must be inside loop or switch"
                                 : "continue must be inside loop");
 
                 return;
         }
 
         /* pop locals in all scopes covered by the target patchlist */
         for (i = locals->count; i > 0 && (size_t)locals->entries[i - 1].depth > p->depth; i--)
                 uc_compiler_emit_insn(compiler, 0,
                         locals->entries[i - 1].captured ? I_CUPV : I_POP);
 
         uc_vector_push(p,
                 uc_compiler_emit_jmp_dest(compiler, pos, chunk->count + type));
 
         uc_compiler_parse_consume(compiler, TK_SCOL);
 }
 
 static void
 uc_compiler_compile_return(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
 
         if (compiler->function->module) {
                 uc_compiler_syntax_error(compiler, 0, "return must be inside function body");
 
                 return;
         }
 
         /* if we compiled an empty expression statement (`;`), load implicit null */
         if (uc_compiler_compile_expstmt(compiler) == TK_NULL)
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL);
 
         /* otherwise overwrite the final I_POP instruction with I_RETURN */
         else
                 uc_chunk_pop(chunk);
 
         /* invoke a function call in tail position to avoid growing the stack */
         bool tailcall = uc_compiler_tailcall_pending(compiler);
 
         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_RETURN);
 
         if (tailcall)
                 uc_compiler_emit_tailcall_marker(compiler);
 }
 
 /* `throw` is sugar for the standard library's die() function. As a statement
  * it leaves nothing on the stack: the expression's value is handed to die() and
  * die()'s own result is discarded. */
 static void
 uc_compiler_compile_throw(uc_compiler_t *compiler)
 {
         /* a bare `throw` dies without a message, as does die() */
         if (uc_compiler_compile_expstmt(compiler) == TK_NULL)
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL);
 
         /* ... otherwise drop the expression statement's trailing I_POP, so that the
          * thrown value stays on the stack to become die()'s argument */
         else
                 uc_chunk_pop(uc_compiler_current_chunk(compiler));
 
         uc_compiler_emit_stcall(compiler, 0, UC_FN_DIE, 1);
 
         uc_compiler_emit_insn(compiler, 0, I_POP);
 }
 
 static void
 uc_compiler_compile_tplexp(uc_compiler_t *compiler)
 {
         uc_chunk_t *chunk = uc_compiler_current_chunk(compiler);
         size_t off = chunk->count;
 
         uc_compiler_compile_expression(compiler, true);
 
         /* XXX: the lexer currently emits a superfluous trailing semicolon... */
         uc_compiler_parse_match(compiler, TK_SCOL);
 
         uc_compiler_parse_consume(compiler, TK_REXP);
 
         if (chunk->count > off)
                 uc_compiler_emit_insn(compiler, 0, I_PRINT);
 }
 
 static void
 uc_compiler_compile_text(uc_compiler_t *compiler)
 {
         uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv);
         uc_compiler_emit_insn(compiler, 0, I_PRINT);
 }
 
 static uc_tokentype_t
 uc_compiler_compile_block(uc_compiler_t *compiler)
 {
         uc_tokentype_t last_statement_type = TK_NULL;
 
         uc_compiler_enter_scope(compiler);
 
         while (!uc_compiler_parse_check(compiler, TK_RBRACE) &&
                !uc_compiler_parse_check(compiler, TK_EOF))
                 last_statement_type = uc_compiler_compile_declaration(compiler);
 
         uc_compiler_parse_consume(compiler, TK_RBRACE);
 
         uc_compiler_leave_scope(compiler);
 
         return last_statement_type;
 }
 
 static uc_tokentype_t
 uc_compiler_compile_expstmt(uc_compiler_t *compiler)
 {
         /* empty statement */
         if (uc_compiler_parse_match(compiler, TK_SCOL))
                 return TK_NULL;
 
         uc_compiler_compile_expression(compiler, false);
 
         /* allow omitting final semicolon */
         switch (compiler->parser->curr.type) {
         case TK_RBRACE:
         case TK_ELIF:
         case TK_ENDIF:
         case TK_ENDFOR:
         case TK_ENDWHILE:
         case TK_ENDFUNC:
         case TK_EOF:
                 break;
 
         case TK_ELSE:
                 if (!uc_compiler_exprstack_is(compiler, F_ALTBLOCKMODE))
                         uc_compiler_parse_consume(compiler, TK_SCOL);
 
                 break;
 
         default:
                 uc_compiler_parse_consume(compiler, TK_SCOL);
 
                 break;
         }
 
         uc_compiler_emit_insn(compiler, 0, I_POP);
 
         return TK_SCOL;
 }
 
 static uc_tokentype_t
 uc_compiler_compile_statement(uc_compiler_t *compiler)
 {
         uc_tokentype_t last_statement_type = compiler->parser->curr.type;
         uc_exprstack_t expr = {
                 .token = compiler->parser->curr.type,
                 .parent = compiler->exprstack
         };
 
         compiler->exprstack = &expr;
 
         if (uc_compiler_parse_match(compiler, TK_LBRACE)) {
                 last_statement_type = uc_compiler_compile_block(compiler);
         }
         else {
                 uc_compiler_emit_stmt_start(compiler, &compiler->parser->curr);
 
                 if (uc_compiler_parse_match(compiler, TK_IF))
                         uc_compiler_compile_if(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_WHILE))
                         uc_compiler_compile_while(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_FOR))
                         uc_compiler_compile_for(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_SWITCH))
                         uc_compiler_compile_switch(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_TRY))
                         uc_compiler_compile_try(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_FUNC))
                         uc_compiler_compile_funcdecl(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_BREAK))
                         uc_compiler_compile_control(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_CONTINUE))
                         uc_compiler_compile_control(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_RETURN))
                         uc_compiler_compile_return(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_THROW))
                         uc_compiler_compile_throw(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_TEXT))
                         uc_compiler_compile_text(compiler);
                 else if (uc_compiler_parse_match(compiler, TK_LEXP))
                         uc_compiler_compile_tplexp(compiler);
                 else
                         last_statement_type = uc_compiler_compile_expstmt(compiler);
 
                 uc_compiler_emit_stmt_end(compiler);
         }
 
         compiler->exprstack = expr.parent;
 
         return last_statement_type;
 }
 
 static void
 uc_compiler_export_add(uc_compiler_t *compiler, uc_value_t *name, ssize_t slot)
 {
         uc_source_t *source = uc_compiler_current_source(compiler);
 
         uc_compiler_inc_exportnum(compiler);
 
         if (!uc_source_export_add(source, name)) {
                 if (name)
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Duplicate export '%s' for module '%s'", ucv_string_get(name), source->filename);
                 else
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Duplicate default export for module '%s'", source->filename);
         }
         else {
                 uc_vector_push(compiler->patchlist, slot);
         }
 }
 
 static void
 uc_compiler_compile_exportlist(uc_compiler_t *compiler)
 {
         uc_value_t *label, *name;
         bool constant;
         ssize_t slot;
 
         /* parse export symbols */
         do {
                 uc_compiler_parse_consume(compiler, TK_LABEL);
 
                 label = ucv_get(compiler->parser->prev.uv);
                 name = NULL;
 
                 slot = uc_compiler_resolve_local(compiler, label, &constant);
 
                 if (slot == -1) {
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Attempt to export undeclared or non-local variable '%s'",
                                 ucv_string_get(label));
                 }
 
                 if (uc_compiler_keyword_match(compiler, "as")) {
                         if (uc_compiler_parse_match(compiler, TK_LABEL) || uc_compiler_parse_match(compiler, TK_STRING)) {
                                 name = ucv_get(compiler->parser->prev.uv);
                         }
                         else if (!uc_compiler_parse_match(compiler, TK_DEFAULT)) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Unexpected token\nExpecting Label, String or 'default'");
                         }
                 }
                 else {
                         name = ucv_get(label);
                 }
 
                 uc_compiler_export_add(compiler, name, slot);
 
                 ucv_put(label);
                 ucv_put(name);
 
                 if (uc_compiler_parse_match(compiler, TK_RBRACE))
                         break;
         }
         while (uc_compiler_parse_match(compiler, TK_COMMA));
 
         uc_compiler_parse_consume(compiler, TK_SCOL);
 }
 
 static void
 uc_compiler_compile_export(uc_compiler_t *compiler)
 {
         uc_locals_t *locals = &compiler->locals;
         size_t off = locals->count;
         uc_value_t *name;
         ssize_t slot;
 
         if (!compiler->function->module || compiler->scope_depth) {
                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                         "Exports may only appear at top level of a module");
 
                 return;
         }
 
         uc_compiler_emit_stmt_start(compiler, &compiler->parser->prev);
 
         if (uc_compiler_parse_match(compiler, TK_LBRACE)) {
                 uc_compiler_compile_exportlist(compiler);
                 uc_compiler_emit_stmt_end(compiler);
 
                 return;
         }
 
         if (uc_compiler_parse_match(compiler, TK_LOCAL))
                 uc_compiler_compile_declexpr(compiler, false);
         else if (uc_compiler_parse_match(compiler, TK_CONST))
                 uc_compiler_compile_declexpr(compiler, true);
         else if (uc_compiler_parse_match(compiler, TK_FUNC)) {
                 uc_compiler_compile_funcdecl(compiler);
 
                 for (; off < locals->count; off++)
                         uc_compiler_export_add(compiler, locals->entries[off].name, off);
 
                 return;
         }
         else if (uc_compiler_parse_match(compiler, TK_DEFAULT))
                 uc_compiler_compile_expression(compiler, false);
         else
                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                         "Unexpected token\nExpecting 'let', 'const', 'function', 'default' or '{'");
 
         /* skip internal variables of destructuring declarations */
         while (off < locals->count && !strncmp(ucv_string_get(locals->entries[off].name), "(destructure)", 13))
                 off++;
 
         if (off == locals->count) {
                 name = ucv_string_new("(module default export)");
                 slot = uc_compiler_declare_local(compiler, name, true);
                 ucv_put(name);
 
                 if (slot != -1)
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Duplicate default export statement");
                 else
                         uc_compiler_export_add(compiler, NULL, compiler->locals.count - 1);
         }
         else {
                 for (; off < locals->count; off++)
                         if (strncmp(ucv_string_get(locals->entries[off].name), "(destructure)", 13))
                                 uc_compiler_export_add(compiler, locals->entries[off].name, off);
         }
 
         uc_compiler_parse_consume(compiler, TK_SCOL);
 
         uc_compiler_emit_stmt_end(compiler);
 }
 
 static uc_program_t *
 uc_compile_from_source(uc_parse_config_t *config, uc_source_t *source, uc_program_t *prog, char **errp);
 
 static bool
 uc_compiler_compile_dynload(uc_compiler_t *compiler, const char *name, uc_value_t *imports)
 {
         uc_value_t *modname = ucv_string_new(name);
         size_t pos = compiler->parser->prev.pos;
         size_t i, n_imports;
         uc_value_t *import;
 
         for (i = 0, n_imports = 0; i < ucv_array_length(imports); i++) {
                 import = ucv_array_get(imports, i);
 
                 if (ucv_boolean_get(import)) {
                         uc_compiler_emit_constant(compiler, pos, modname);
                         uc_compiler_emit_insn(compiler, pos, I_DYNLOAD);
                         uc_compiler_emit_u32(compiler, 0, 0);
                 }
                 else {
                         n_imports++;
                 }
         }
 
         if (n_imports > 0) {
                 uc_compiler_emit_constant(compiler, pos, modname);
                 uc_compiler_emit_insn(compiler, pos, I_DYNLOAD);
                 uc_compiler_emit_u32(compiler, 0, n_imports | ((compiler->upvals.count - n_imports) << 16));
 
                 for (i = 0; i < ucv_array_length(imports); i++) {
                         import = ucv_get(ucv_array_get(imports, i));
 
                         if (!import)
                                 import = ucv_string_new("default");
 
                         if (!ucv_boolean_get(import))
                                 uc_compiler_emit_constant_index(compiler, 0, import);
 
                         ucv_put(import);
                 }
         }
 
         ucv_put(modname);
 
         return true;
 }
 
 static bool
 uc_compiler_compile_module_source(uc_compiler_t *compiler, const char *modname, uc_source_t *source, uc_value_t *imports, char **errp)
 {
         uc_parse_config_t config = {
                 .raw_mode = true,
                 .strict_declarations = true,
                 .module_search_path = compiler->parser->lex.config->module_search_path
         };
 
         size_t i, load_idx = 0, n_imports = 0, n_exports = 0;
         bool loaded = false, res;
         uc_value_t *import;
         ssize_t slot;
 
         uc_program_function_foreach(compiler->program, fn) {
                 if (uc_program_function_source(fn) == source) {
                         loaded = true;
                         break;
                 }
         }
 
         /* An offset of -1 marks a source whose compilation was entered but not yet
          * completed. Re-entering it is either a circular dependency (its function is
          * still present) or a module whose earlier compilation failed and freed its
          * function. Recompiling in either case recurses without bound across a large
          * import graph, so report the cycle and propagate the failure instead. */
         if (source->exports.offset == (size_t)-1) {
                 if (loaded)
                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                 "Circular dependency");
                 else if (errp)
                         xasprintf(errp, "Module previously failed to compile\n");
 
                 return false;
         }
 
         if (!loaded) {
                 /* We do not yet support linking precompiled modules at compile time,
                    turn static import operation into dynamic load one. */
                 switch (uc_source_begin(source)) {
                 case UC_SOURCE_TYPE_PRECOMPILED:
                         uc_source_reset(source);
 
                         return uc_compiler_compile_dynload(compiler, modname, imports);
 
                 case UC_SOURCE_TYPE_UNAVAILABLE:
                         if (errp)
                                 xasprintf(errp, "Unable to open source file %s: %s\n",
                                         source->filename, strerror(errno));
 
                         return false;
 
                 default:
                         break;
                 }
 
                 load_idx = uc_program_function_id(compiler->program,
                         uc_program_function_last(compiler->program)) + 1;
 
                 source->exports.offset = (size_t)-1;
                 n_exports = uc_compiler_get_exportnum(compiler);
 
                 res = uc_compile_from_source(&config, source, compiler->program, errp);
 
                 uc_source_reset(source);
 
                 if (!res)
                         return false;
 
                 /* The linked module's own exports are the last ones allocated while
                  * compiling it, its offset is the allocation counter minus its count. */
                 source->exports.offset = uc_compiler_get_exportnum(compiler) - source->exports.count;
 
                 /* The importing source's own exports follow everything that got
                  * allocated while compiling the import, i.e. the exports of the linked
                  * module plus those of all modules it pulled in transitively. */
                 uc_compiler_current_source(compiler)->exports.offset +=
                         uc_compiler_get_exportnum(compiler) - n_exports;
 
                 /* emit load, call & pop instructions */
                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_CLFN);
                 uc_compiler_emit_u32(compiler, 0, load_idx);
 
                 uc_compiler_emit_insn(compiler, 0, I_CALL);
                 uc_compiler_emit_u32(compiler, 0, 0);
 
                 uc_compiler_emit_insn(compiler, 0, I_POP);
         }
 
         /* count imports, handle wildcard imports */
         for (i = 0; i < ucv_array_length(imports); i++) {
                 if (ucv_boolean_get(ucv_array_get(imports, i))) {
                         if (source->exports.offset > 0xffff || source->exports.count > 0xffff) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Too many module exports");
                         }
 
                         /* emit import instruction... */
                         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_IMPORT);
                         uc_compiler_emit_u32(compiler, 0, source->exports.count | (0xffffu << 16));
 
                         /* ... followed by first module export offset ... */
                         uc_compiler_emit_u16(compiler, 0, source->exports.offset);
 
                         /* ... and constant indexes for all exported names */
                         for (load_idx = 0; load_idx < source->exports.count; load_idx++) {
                                 if (source->exports.entries[load_idx])
                                         import = ucv_get(source->exports.entries[load_idx]);
                                 else
                                         import = ucv_string_new("default");
 
                                 uc_compiler_emit_constant_index(compiler, 0, import);
                                 ucv_put(import);
                         }
 
                 }
                 else {
                         n_imports++;
                 }
         }
 
         /* 0xffff is reserved for wildcard import */
         if (n_imports > 0xfffe)
                 uc_compiler_syntax_error(compiler, 0, "Too many imports");
 
         /* emit non-wildcard import instructions */
         for (i = 0; i < ucv_array_length(imports); i++) {
                 import = ucv_array_get(imports, i);
 
                 if (!ucv_boolean_get(import)) {
                         slot = uc_source_export_lookup(source, import);
 
                         if (slot == -1) {
                                 if (import)
                                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                                 "Module %s does not export '%s'", source->filename, ucv_string_get(import));
                                 else
                                         uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                                 "Module %s has no default export", source->filename);
                         }
                         else if (slot > 0xffff) {
                                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                                         "Too many module exports");
                         }
                         else {
                                 uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_IMPORT);
                                 uc_compiler_emit_u32(compiler, 0,
                                         (source->exports.offset + slot) | ((compiler->upvals.count - n_imports + i) << 16));
                         }
                 }
         }
 
         return true;
 }
 
 static char *
 uc_compiler_canonicalize_path(const char *path, const char *runpath)
 {
         char *p, *resolved;
         const char *slash;
 
         if (*path == '/')
                 xasprintf(&p, "%s", path);
         else if (runpath && (slash = strrchr(runpath, '/')) != NULL)
                 xasprintf(&p, "%.*s/%s", (int)(slash - runpath), runpath, path);
         else
                 xasprintf(&p, "./%s", path);
 
         resolved = realpath(p, NULL);
 
         free(p);
 
         return resolved;
 }
 
 static char *
 uc_compiler_expand_module_path(const char *name, const char *runpath, const char *template)
 {
         int namelen, prefixlen;
         const char *asterix;
         char *path, *p;
 
         asterix = strchr(template, '*');
 
         if (!asterix)
                 return NULL;
 
         prefixlen = asterix - template;
         namelen = strlen(name);
 
         xasprintf(&path, "%.*s%.*s%s", prefixlen, template, namelen, name, asterix + 1);
 
         for (p = path + prefixlen; namelen > 0; namelen--, p++)
                 if (*p == '.')
                         *p = '/';
 
         p = uc_compiler_canonicalize_path(path, runpath);
 
         free(path);
 
         return p;
 }
 
 static char *
 uc_compiler_resolve_module_path(uc_compiler_t *compiler, const char *name)
 {
         uc_search_path_t *search = &compiler->parser->lex.config->module_search_path;
         uc_source_t *source = uc_compiler_current_source(compiler);
         char *path = NULL;
         size_t i;
 
         if (strchr(name, '/'))
                 return uc_compiler_canonicalize_path(name, source->runpath);
 
         for (i = 0; i < search->count && !path; i++)
                 path = uc_compiler_expand_module_path(name, source->runpath, search->entries[i]);
 
         return path;
 }
 
 static uc_source_t *
 uc_compiler_acquire_source(uc_compiler_t *compiler, const char *path)
 {
         size_t i;
 
         for (i = 0; i < compiler->program->sources.count; i++)
                 if (!strcmp(compiler->program->sources.entries[i]->filename, path))
                         return uc_source_get(compiler->program->sources.entries[i]);
 
         return uc_source_new_file(path);
 }
 
 static bool
 uc_compiler_is_dynlink_module(uc_compiler_t *compiler, const char *name, const char *path)
 {
         uc_search_path_t *dynlink_list = &compiler->parser->config->force_dynlink_list;
         const char *dot;
         size_t i;
 
         for (i = 0; i < dynlink_list->count; i++)
                 if (!strcmp(dynlink_list->entries[i], name))
                         return true;
 
         if (!path)
                 return false;
 
         dot = strrchr(path, '.');
 
         return (dot && !strcmp(dot, ".so"));
 }
 
 static bool
 uc_compiler_compile_module(uc_compiler_t *compiler, const char *name, uc_value_t *imports)
 {
         uc_source_t *source;
         char *path, *err;
         bool res;
 
         if (!name)
                 return false;
 
         path = uc_compiler_resolve_module_path(compiler, name);
 
         if (uc_compiler_is_dynlink_module(compiler, name, path)) {
                 res = uc_compiler_compile_dynload(compiler, name, imports);
         }
         else if (path) {
                 source = uc_compiler_acquire_source(compiler, path);
 
                 if (source) {
                         err = NULL;
                         res = uc_compiler_compile_module_source(compiler, name, source, imports, &err);
 
                         if (!res) {
                                 uc_error_message_indent(&err);
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Unable to compile module '%s':\n\n%s", source->filename, err);
                         }
 
                         free(err);
                 }
                 else {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Unable to open module '%s': %s",
                                 path, strerror(errno));
 
                         res = false;
                 }
 
                 uc_source_put(source);
         }
         else {
                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                         "Unable to resolve path for module '%s'", name);
 
                 return false;
         }
 
         free(path);
 
         return res;
 }
 
 static void
 uc_compiler_import_add(uc_compiler_t *compiler, uc_value_t *name)
 {
         bool constant;
         ssize_t slot;
 
         slot = uc_compiler_resolve_local(compiler, name, &constant);
 
         if (slot != -1) {
                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                         "Import name '%s' is already declared as local variable",
                         ucv_string_get(name));
 
                 return;
         }
 
         slot = uc_compiler_resolve_upval(compiler, name, &constant);
 
         if (slot != -1) {
                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                         "Import name '%s' is already used",
                         ucv_string_get(name));
 
                 return;
         }
 
         uc_compiler_add_upval(compiler, (2 << 14) + compiler->upvals.count, false, name, true);
 }
 
 static void
 uc_compiler_compile_importlist(uc_compiler_t *compiler, uc_value_t *namelist)
 {
         uc_value_t *label, *name;
 
         /* parse export symbols */
         do {
                 name = NULL;
                 label = NULL;
 
                 if (uc_compiler_parse_match(compiler, TK_DEFAULT)) {
                         uc_compiler_keyword_consume(compiler, "as");
                         uc_compiler_parse_consume(compiler, TK_LABEL);
 
                         label = ucv_get(compiler->parser->prev.uv);
                 }
                 else if (uc_compiler_parse_match(compiler, TK_STRING)) {
                         name = ucv_get(compiler->parser->prev.uv);
 
                         uc_compiler_keyword_consume(compiler, "as");
                         uc_compiler_parse_consume(compiler, TK_LABEL);
 
                         label = ucv_get(compiler->parser->prev.uv);
                 }
                 else if (uc_compiler_parse_match(compiler, TK_LABEL)) {
                         name = ucv_get(compiler->parser->prev.uv);
 
                         if (uc_compiler_keyword_match(compiler, "as")) {
                                 uc_compiler_parse_consume(compiler, TK_LABEL);
 
                                 label = ucv_get(compiler->parser->prev.uv);
                         }
                         else {
                                 label = ucv_get(name);
                         }
                 }
                 else {
                         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                 "Unexpected token\nExpecting Label, String or 'default'");
                 }
 
                 uc_compiler_import_add(compiler, label);
                 ucv_array_push(namelist, name);
                 ucv_put(label);
 
                 if (uc_compiler_parse_match(compiler, TK_RBRACE))
                         return;
         }
         while (uc_compiler_parse_match(compiler, TK_COMMA));
 
         uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                 "Unexpected token\nExpecting 'as', ',' or '}'");
 }
 
 static void
 uc_compiler_compile_importcall(uc_compiler_t *compiler)
 {
         uc_compiler_parse_consume(compiler, TK_LPAREN);
         uc_compiler_parse_precedence(compiler, P_ASSIGN);
         uc_compiler_parse_consume(compiler, TK_RPAREN);
 
         uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_DYNLOAD);
         uc_compiler_emit_u32(compiler, 0, 0);
 }
 
 static uc_tokentype_t
 uc_compiler_compile_import(uc_compiler_t *compiler)
 {
         uc_value_t *namelist = ucv_array_new(NULL);
 
         /* import(...) */
         if (uc_compiler_parse_check(compiler, TK_LPAREN)) {
                 uc_compiler_parse_precedence_for_token(compiler, P_UNARY,
                                                        &compiler->parser->prev);
 
                 uc_compiler_emit_insn(compiler, 0, I_POP);
                 ucv_put(namelist);
 
                 return TK_SCOL;
         }
 
         if (compiler->scope_depth) {
                 uc_compiler_syntax_error(compiler, compiler->parser->prev.pos,
                         "Imports may only appear at top level");
 
                 ucv_put(namelist);
 
                 return TK_IMPORT;
         }
 
         uc_compiler_emit_stmt_start(compiler, &compiler->parser->prev);
 
         /* import { ... } from */
         if (uc_compiler_parse_match(compiler, TK_LBRACE)) {
                 uc_compiler_compile_importlist(compiler, namelist);
                 uc_compiler_keyword_consume(compiler, "from");
         }
 
         /* import * as name from */
         else if (uc_compiler_parse_match(compiler, TK_MUL)) {
                 uc_compiler_keyword_consume(compiler, "as");
                 uc_compiler_parse_consume(compiler, TK_LABEL);
 
                 uc_compiler_declare_local(compiler, compiler->parser->prev.uv, true);
                 uc_compiler_initialize_local(compiler);
                 ucv_array_push(namelist, ucv_boolean_new(true));
 
                 uc_compiler_keyword_consume(compiler, "from");
         }
 
         /* import defaultExport [, ... ] from */
         else if (uc_compiler_parse_match(compiler, TK_LABEL)) {
                 uc_compiler_import_add(compiler, compiler->parser->prev.uv);
                 ucv_array_push(namelist, NULL);
 
                 /* import defaultExport, ... from */
                 if (uc_compiler_parse_match(compiler, TK_COMMA)) {
                         /* import defaultExport, { ... } from */
                         if (uc_compiler_parse_match(compiler, TK_LBRACE)) {
                                 uc_compiler_compile_importlist(compiler, namelist);
                         }
 
                         /* import defaultExport, * as name from */
                         else if (uc_compiler_parse_match(compiler, TK_MUL)) {
                                 uc_compiler_keyword_consume(compiler, "as");
                                 uc_compiler_parse_consume(compiler, TK_LABEL);
 
                                 uc_compiler_declare_local(compiler, compiler->parser->prev.uv, true);
                                 uc_compiler_initialize_local(compiler);
                                 ucv_array_push(namelist, ucv_boolean_new(true));
                         }
 
                         /* error */
                         else {
                                 uc_compiler_syntax_error(compiler, compiler->parser->curr.pos,
                                         "Unexpected token\nExpecting '{' or '*'");
                         }
                 }
 
                 uc_compiler_keyword_consume(compiler, "from");
         }
 
         uc_compiler_parse_consume(compiler, TK_STRING);
 
         uc_compiler_compile_module(compiler, ucv_string_get(compiler->parser->prev.uv), namelist);
 
         uc_compiler_parse_consume(compiler, TK_SCOL);
 
         uc_compiler_emit_stmt_end(compiler);
 
         ucv_put(namelist);
 
         return TK_IMPORT;
 }
 
 static uc_tokentype_t
 uc_compiler_compile_declaration(uc_compiler_t *compiler)
 {
         uc_tokentype_t last_statement_type = compiler->parser->curr.type;
 
         if (uc_compiler_parse_match(compiler, TK_LOCAL))
                 uc_compiler_compile_local(compiler);
         else if (uc_compiler_parse_match(compiler, TK_CONST))
                 uc_compiler_compile_const(compiler);
         else if (uc_compiler_parse_match(compiler, TK_EXPORT))
                 uc_compiler_compile_export(compiler);
         else if (uc_compiler_parse_match(compiler, TK_IMPORT))
                 last_statement_type = uc_compiler_compile_import(compiler);
         else
                 last_statement_type = uc_compiler_compile_statement(compiler);
 
         if (compiler->parser->synchronizing)
                 uc_compiler_parse_synchronize(compiler);
 
         return last_statement_type;
 }
 
 #endif /* NO_COMPILE */
 
 
 static uc_program_t *
 uc_compile_from_source(uc_parse_config_t *config, uc_source_t *source, uc_program_t *prog, char **errp)
 {
 #ifdef NO_COMPILE
         if (errp)
                 xasprintf(errp, "Source code compilation not supported\n");
 
         return NULL;
 #else
         bool is_module = (prog != NULL) || (config && config->compile_module);
         uc_patchlist_t exports = { .token = TK_EXPORT };
         uc_exprstack_t expr = { .token = TK_EOF };
         uc_parser_t parser = { .config = config };
         uc_compiler_t compiler = { .parser = &parser, .exprstack = &expr };
         uc_tokentype_t last_statement_type = TK_NULL;
         uc_program_t *progptr;
         uc_function_t *fn;
         const char *name;
 
         if (!prog) {
                 progptr = uc_program_new();
                 name = is_module ? "module" : "main";
         }
         else {
                 progptr = prog;
                 name = "module";
         }
 
         uc_lexer_init(&parser.lex, config, source);
         uc_compiler_init(&compiler, name, source, 0, progptr,
                 config && config->strict_declarations);
 
         if (is_module) {
                 compiler.patchlist = &exports;
                 compiler.function->module = true;
         }
 
         uc_compiler_parse_advance(&compiler);
 
         while (!uc_compiler_parse_match(&compiler, TK_EOF))
                 last_statement_type = uc_compiler_compile_declaration(&compiler);
 
         if (!compiler.function->module && last_statement_type == TK_SCOL) {
                 uc_chunk_pop(uc_compiler_current_chunk(&compiler));
 
                 /* invoke a trailing call statement in tail position */
                 bool tailcall = uc_compiler_tailcall_pending(&compiler);
 
                 uc_compiler_emit_insn(&compiler, 0, I_RETURN);
 
                 if (tailcall)
                         uc_compiler_emit_tailcall_marker(&compiler);
 
                 last_statement_type = TK_RETURN;
         }
 
         fn = uc_compiler_finish(&compiler, last_statement_type);
 
         if (errp) {
                 *errp = parser.error ? parser.error->buf : NULL;
                 free(parser.error);
         }
         else {
                 printbuf_free(parser.error);
         }
 
         uc_lexer_free(&parser.lex);
         free(parser.scanned.entries);
         uc_vector_clear(&exports);
 
         if (!fn) {
                 if (progptr != prog)
                         ucv_put(&progptr->header);
 
                 return NULL;
         }
 
         return progptr;
 #endif
 }
 
 static uc_program_t *
 uc_compile_from_bytecode(uc_parse_config_t *config, uc_source_t *source, char **errp)
 {
         uc_program_t *prog;
 
         prog = uc_program_load(source, errp);
 
         if (prog && !uc_program_entry(prog)) {
                 if (errp)
                         xasprintf(errp, "Program file contains no entry function\n");
 
                 ucv_put(&prog->header);
                 prog = NULL;
         }
 
         return prog;
 }
 
 uc_program_t *
 uc_compile(uc_parse_config_t *config, uc_source_t *source, char **errp)
 {
         uc_program_t *prog = NULL;
 
         if (!config)
                 config = &uc_default_parse_config;
 
         switch (uc_source_begin(source)) {
         case UC_SOURCE_TYPE_PLAIN:
                 prog = uc_compile_from_source(config, source, NULL, errp);
                 break;
 
         case UC_SOURCE_TYPE_PRECOMPILED:
                 prog = uc_compile_from_bytecode(config, source, errp);
                 break;
 
         case UC_SOURCE_TYPE_UNAVAILABLE:
                 if (errp)
                         xasprintf(errp, "Unable to open source file %s: %s\n",
                                 source->filename, strerror(errno));
 
                 break;
 
         default:
                 if (errp)
                         xasprintf(errp, "Unrecognized source type\n");
 
                 break;
         }
 
         uc_source_reset(source);
 
         return prog;
 }