text: /*
   *  Command line execution tool.  Useful for test cases and manual testing.
   *
   *  Optional features:
   *
   *  - To enable print()/alert() bindings, define DUK_CMDLINE_PRINTALERT_SUPPORT
   *    and add extras/print-alert/duk_print_alert.c to compilation.
   *
   *  - To enable console.log() etc, define DUK_CMDLINE_CONSOLE_SUPPORT
   *    and add extras/console/duk_console.c to compilation.
   *
   *  - To enable Duktape.Logger, define DUK_CMDLINE_LOGGING_SUPPORT
   *    and add extras/logging/duk_logging.c to compilation.
   *
   *  - To enable CBOR, define DUK_CMDLINE_CBOR_SUPPORT and add
   *    extras/cbor/duk_cbor.c to compilation.
   *
   *  - To enable Duktape 1.x module loading support (require(),
   *    Duktape.modSearch() etc), define DUK_CMDLINE_MODULE_SUPPORT and add
   *    extras/module-duktape/duk_module_duktape.c to compilation.
   *
   *  - To enable linenoise and other fancy stuff, compile with -DDUK_CMDLINE_FANCY.
   *    It is not the default to maximize portability.  You can also compile in
   *    support for example allocators, grep for DUK_CMDLINE_*.
   */
  
  /* Helper define to enable a feature set; can also use separate defines. */
  #if defined(DUK_CMDLINE_FANCY)
  #define DUK_CMDLINE_LINENOISE
  #define DUK_CMDLINE_LINENOISE_COMPLETION  /* Enables completion and hints. */
  #define DUK_CMDLINE_RLIMIT
  #define DUK_CMDLINE_SIGNAL
  #endif
  
  #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || \
      defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
  /* Suppress warnings about plain fopen() etc. */
  #define _CRT_SECURE_NO_WARNINGS
  #if defined(_MSC_VER) && (_MSC_VER < 1900)
  /* Workaround for snprintf() missing in older MSVC versions.
   * Note that _snprintf() may not NUL terminate the string, but
   * this difference does not matter here as a NUL terminator is
   * always explicitly added.
   */
  #define snprintf _snprintf
  #endif
  #endif
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #if defined(DUK_CMDLINE_SIGNAL)
  #include <signal.h>
  #endif
  #if defined(DUK_CMDLINE_RLIMIT)
  #include <sys/resource.h>
  #endif
  #if defined(DUK_CMDLINE_LINENOISE)
  #include "linenoise.h"
  #include <stdint.h>  /* Assume C99/C++11 with linenoise. */
  #endif
  #if defined(DUK_CMDLINE_PRINTALERT_SUPPORT)
  #include "duk_print_alert.h"
  #endif
  #if defined(DUK_CMDLINE_CONSOLE_SUPPORT)
  #include "duk_console.h"
  #endif
  #if defined(DUK_CMDLINE_LOGGING_SUPPORT)
  #include "duk_logging.h"
  #endif
  #if defined(DUK_CMDLINE_MODULE_SUPPORT)
  #include "duk_module_duktape.h"
  #endif
  #if defined(DUK_CMDLINE_CBOR_SUPPORT)
  #include "duk_cbor.h"
  #endif
  #if defined(DUK_CMDLINE_FILEIO)
  #include <errno.h>
  #endif
  #if defined(EMSCRIPTEN)
  #include <emscripten.h>
  #endif
  #if defined(DUK_CMDLINE_ALLOC_LOGGING)
  #include "duk_alloc_logging.h"
  #endif
  #if defined(DUK_CMDLINE_ALLOC_TORTURE)
  #include "duk_alloc_torture.h"
  #endif
  #if defined(DUK_CMDLINE_ALLOC_HYBRID)
  #include "duk_alloc_hybrid.h"
  #endif
  #include "duktape.h"
  
  #include "duk_cmdline.h"
  
  #if defined(DUK_CMDLINE_LOWMEM)
  #include "duk_alloc_pool.h"
  #endif
  
  #if defined(DUK_CMDLINE_DEBUGGER_SUPPORT)
  #include "duk_trans_socket.h"
  #endif
  
  #define  MEM_LIMIT_NORMAL   (128*1024*1024)   /* 128 MB */
  #define  MEM_LIMIT_HIGH     (2047*1024*1024)  /* ~2 GB */
  #define  LINEBUF_SIZE       65536
  
  static int main_argc = 0;
  static char **main_argv = NULL;
  static int interactive_mode = 0;
  #if defined(DUK_CMDLINE_DEBUGGER_SUPPORT)
  static int debugger_reattach = 0;
  #endif
  
  /*
   *  Misc helpers
   */
  
  static void print_greet_line(void) {
  	printf("((o) Duktape%s %d.%d.%d (%s)\n",
  #if defined(DUK_CMDLINE_LINENOISE)
  	       " [linenoise]",
  #else
  	       "",
  #endif
  	       (int) (DUK_VERSION / 10000),
  	       (int) ((DUK_VERSION / 100) % 100),
  	       (int) (DUK_VERSION % 100),
  	       DUK_GIT_DESCRIBE);
  }
  
  #if defined(DUK_CMDLINE_RLIMIT)
  static void set_resource_limits(rlim_t mem_limit_value) {
  	int rc;
  	struct rlimit lim;
  
  	rc = getrlimit(RLIMIT_AS, &lim);
  	if (rc != 0) {
  		fprintf(stderr, "Warning: cannot read RLIMIT_AS\n");
  		return;
  	}
  
  	if (lim.rlim_max < mem_limit_value) {
  		fprintf(stderr, "Warning: rlim_max < mem_limit_value (%d < %d)\n", (int) lim.rlim_max, (int) mem_limit_value);
  		return;
  	}
  
  	lim.rlim_cur = mem_limit_value;
  	lim.rlim_max = mem_limit_value;
  
  	rc = setrlimit(RLIMIT_AS, &lim);
  	if (rc != 0) {
  		fprintf(stderr, "Warning: setrlimit failed\n");
  		return;
  	}
  
  #if 0
  	fprintf(stderr, "Set RLIMIT_AS to %d\n", (int) mem_limit_value);
  #endif
  }
  #endif  /* DUK_CMDLINE_RLIMIT */
  
  #if defined(DUK_CMDLINE_SIGNAL)
  static void my_sighandler(int x) {
  	fprintf(stderr, "Got signal %d\n", x);
  	fflush(stderr);
  }
  static void set_sigint_handler(void) {
  	(void) signal(SIGINT, my_sighandler);
  	(void) signal(SIGPIPE, SIG_IGN);  /* avoid SIGPIPE killing process */
  }
  #endif  /* DUK_CMDLINE_SIGNAL */
  
  static void cmdline_fatal_handler(void *udata, const char *msg) {
  	(void) udata;
  	fprintf(stderr, "*** FATAL ERROR: %s\n", msg ? msg : "no message");
  	fprintf(stderr, "Causing intentional segfault...\n");
  	fflush(stderr);
  	*((volatile unsigned int *) 0) = (unsigned int) 0xdeadbeefUL;
  	abort();
  }
  
  static duk_ret_t get_stack_raw(duk_context *ctx, void *udata) {
  	(void) udata;
  
  	if (!duk_is_object(ctx, -1)) {
  		return 1;
  	}
  	if (!duk_has_prop_string(ctx, -1, "stack")) {
  		return 1;
  	}
  	if (!duk_is_error(ctx, -1)) {
  		/* Not an Error instance, don't read "stack". */
  		return 1;
  	}
  
  	duk_get_prop_string(ctx, -1, "stack");  /* caller coerces */
  	duk_remove(ctx, -2);
  	return 1;
  }
  
  /* Print error to stderr and pop error. */
  static void print_pop_error(duk_context *ctx, FILE *f) {
  	/* Print error objects with a stack trace specially.
  	 * Note that getting the stack trace may throw an error
  	 * so this also needs to be safe call wrapped.
  	 */
  	(void) duk_safe_call(ctx, get_stack_raw, NULL /*udata*/, 1 /*nargs*/, 1 /*nrets*/);
  	fprintf(f, "%s\n", duk_safe_to_string(ctx, -1));
  	fflush(f);
  	duk_pop(ctx);
  }
  
  static duk_ret_t wrapped_compile_execute(duk_context *ctx, void *udata) {
  	const char *src_data;
  	duk_size_t src_len;
  	duk_uint_t comp_flags;
  
  	(void) udata;
  
  	/* XXX: Here it'd be nice to get some stats for the compilation result
  	 * when a suitable command line is given (e.g. code size, constant
  	 * count, function count.  These are available internally but not through
  	 * the public API.
  	 */
  
  	/* Use duk_compile_lstring_filename() variant which avoids interning
  	 * the source code.  This only really matters for low memory environments.
  	 */
  
  	/* [ ... bytecode_filename src_data src_len filename ] */
  
  	src_data = (const char *) duk_require_pointer(ctx, -3);
  	src_len = (duk_size_t) duk_require_uint(ctx, -2);
  
  	if (src_data != NULL && src_len >= 1 && src_data[0] == (char) 0xbf) {
  		/* Bytecode. */
  		void *buf;
  		buf = duk_push_fixed_buffer(ctx, src_len);
  		memcpy(buf, (const void *) src_data, src_len);
  		duk_load_function(ctx);
  	} else {
  		/* Source code. */
  		comp_flags = DUK_COMPILE_SHEBANG;
  		duk_compile_lstring_filename(ctx, comp_flags, src_data, src_len);
  	}
  
  	/* [ ... bytecode_filename src_data src_len function ] */
  
  	/* Optional bytecode dump. */
  	if (duk_is_string(ctx, -4)) {
  		FILE *f;
  		void *bc_ptr;
  		duk_size_t bc_len;
  		size_t wrote;
  		char fnbuf[256];
  		const char *filename;
  
  		duk_dup_top(ctx);
  		duk_dump_function(ctx);
  		bc_ptr = duk_require_buffer(ctx, -1, &bc_len);
  		filename = duk_require_string(ctx, -5);
  #if defined(EMSCRIPTEN)
  		if (filename[0] == '/') {
  			snprintf(fnbuf, sizeof(fnbuf), "%s", filename);
  		} else {
  			snprintf(fnbuf, sizeof(fnbuf), "/working/%s", filename);
  		}
  #else
  		snprintf(fnbuf, sizeof(fnbuf), "%s", filename);
  #endif
  		fnbuf[sizeof(fnbuf) - 1] = (char) 0;
  
  		f = fopen(fnbuf, "wb");
  		if (!f) {
  			(void) duk_generic_error(ctx, "failed to open bytecode output file");
  		}
  		wrote = fwrite(bc_ptr, 1, (size_t) bc_len, f);  /* XXX: handle partial writes */
  		(void) fclose(f);
  		if (wrote != bc_len) {
  			(void) duk_generic_error(ctx, "failed to write all bytecode");
  		}
  
  		return 0;  /* duk_safe_call() cleans up */
  	}
  
  #if 0
  	/* Manual test for bytecode dump/load cycle: dump and load before
  	 * execution.  Enable manually, then run "make ecmatest" for a
  	 * reasonably good coverage of different functions and programs.
  	 */
  	duk_dump_function(ctx);
  	duk_load_function(ctx);
  #endif
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	lowmem_start_exec_timeout();
  #endif
  
  	duk_push_global_object(ctx);  /* 'this' binding */
  	duk_call_method(ctx, 0);
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	lowmem_clear_exec_timeout();
  #endif
  
  	if (interactive_mode) {
  		/*
  		 *  In interactive mode, write to stdout so output won't
  		 *  interleave as easily.
  		 *
  		 *  NOTE: the ToString() coercion may fail in some cases;
  		 *  for instance, if you evaluate:
  		 *
  		 *    ( {valueOf: function() {return {}},
  		 *       toString: function() {return {}}});
  		 *
  		 *  The error is:
  		 *
  		 *    TypeError: coercion to primitive failed
  		 *            duk_api.c:1420
  		 *
  		 *  These are handled now by the caller which also has stack
  		 *  trace printing support.  User code can print out errors
  		 *  safely using duk_safe_to_string().
  		 */
  
  		duk_push_global_stash(ctx);
  		duk_get_prop_string(ctx, -1, "dukFormat");
  		duk_dup(ctx, -3);
  		duk_call(ctx, 1);  /* -> [ ... res stash formatted ] */
  
  		fprintf(stdout, "= %s\n", duk_to_string(ctx, -1));
  		fflush(stdout);
  	} else {
  		/* In non-interactive mode, success results are not written at all.
  		 * It is important that the result value is not string coerced,
  		 * as the string coercion may cause an error in some cases.
  		 */
  	}
  
  	return 0;  /* duk_safe_call() cleans up */
  }
  
  /*
   *  Minimal Linenoise completion support
   */
  
  #if defined(DUK_CMDLINE_LINENOISE_COMPLETION)
  static duk_context *completion_ctx;
  
  
  static const char *linenoise_completion_script =
  	"(function linenoiseCompletion(input, addCompletion) {\n"
  	"    // Find maximal trailing string which looks like a property\n"
  	"    // access.  Look up all the components (starting from the global\n"
  	"    // object now) except the last; treat the last component as a\n"
  	"    // partial name and use it as a filter for possible properties.\n"
  	"    var match, propseq, obj, i, partial, names, name, sanity;\n"
  	"\n"
  	"    if (!input) { return; }\n"
  	"    match = /^.*?((?:\\w+\\.)*\\w*)$/.exec(input);\n"
  	"    if (!match || !match[1]) { return; }\n"
  	"    var propseq = match[1].split('.');\n"
  	"\n"
  	"    obj = Function('return this')();\n"
  	"    for (i = 0; i < propseq.length - 1; i++) {\n"
  	"        if (obj === void 0 || obj === null) { return; }\n"
  	"        obj = obj[propseq[i]];\n"
  	"    }\n"
  	"    if (obj === void 0 || obj === null) { return; }\n"
  	"\n"
  	"    partial = propseq[propseq.length - 1];\n"
  	"    sanity = 1000;\n"
  	"    while (obj != null) {\n"
  	"        if (--sanity < 0) { throw new Error('sanity'); }\n"
  	"        names = Object.getOwnPropertyNames(Object(obj));\n"
  	"        for (i = 0; i < names.length; i++) {\n"
  	"            if (--sanity < 0) { throw new Error('sanity'); }\n"
  	"            name = names[i];\n"
  	"            if (Number(name) >= 0) { continue; }  // ignore array keys\n"
  	"            if (name.substring(0, partial.length) !== partial) { continue; }\n"
  	"            if (name === partial) { addCompletion(input + '.'); continue; }\n"
  	"            addCompletion(input + name.substring(partial.length));\n"
  	"        }\n"
  	"        obj = Object.getPrototypeOf(Object(obj));\n"
  	"    }\n"
  	"})";
  
  static const char *linenoise_hints_script =
  	"(function linenoiseHints(input) {\n"
  	"    // Similar to completions but different handling for final results.\n"
  	"    var match, propseq, obj, i, partial, names, name, res, found, first, sanity;\n"
  	"\n"
  	"    if (!input) { return; }\n"
  	"    match = /^.*?((?:\\w+\\.)*\\w*)$/.exec(input);\n"
  	"    if (!match || !match[1]) { return; }\n"
  	"    var propseq = match[1].split('.');\n"
  	"\n"
  	"    obj = Function('return this')();\n"
  	"    for (i = 0; i < propseq.length - 1; i++) {\n"
  	"        if (obj === void 0 || obj === null) { return; }\n"
  	"        obj = obj[propseq[i]];\n"
  	"    }\n"
  	"    if (obj === void 0 || obj === null) { return; }\n"
  	"\n"
  	"    partial = propseq[propseq.length - 1];\n"
  	"    res = [];\n"
  	"    found = Object.create(null);  // keys already handled\n"
  	"    sanity = 1000;\n"
  	"    while (obj != null) {\n"
  	"        if (--sanity < 0) { throw new Error('sanity'); }\n"
  	"        names = Object.getOwnPropertyNames(Object(obj));\n"
  	"        first = true;\n"
  	"        for (i = 0; i < names.length; i++) {\n"
  	"            if (--sanity < 0) { throw new Error('sanity'); }\n"
  	"            name = names[i];\n"
  	"            if (Number(name) >= 0) { continue; }  // ignore array keys\n"
  	"            if (name.substring(0, partial.length) !== partial) { continue; }\n"
  	"            if (name === partial) { continue; }\n"
  	"            if (found[name]) { continue; }\n"
  	"            found[name] = true;\n"
  	"            res.push(res.length === 0 ? name.substring(partial.length) : (first ? ' || ' : ' | ') + name);\n"
  	"            first = false;\n"
  	"        }\n"
  	"        obj = Object.getPrototypeOf(Object(obj));\n"
  	"    }\n"
  	"    return { hints: res.join(''), color: 35, bold: 1 };\n"
  	"})";
  
  static duk_ret_t linenoise_add_completion(duk_context *ctx) {
  	linenoiseCompletions *lc;
  
  	duk_push_current_function(ctx);
  	duk_get_prop_string(ctx, -1, "lc");
  	lc = duk_require_pointer(ctx, -1);
  
  	linenoiseAddCompletion(lc, duk_require_string(ctx, 0));
  	return 0;
  }
  
  static char *linenoise_hints(const char *buf, int *color, int *bold) {
  	duk_context *ctx;
  	duk_int_t rc;
  
  	ctx = completion_ctx;
  	if (!ctx) {
  		return NULL;
  	}
  
  	duk_push_global_stash(ctx);
  	duk_get_prop_string(ctx, -1, "linenoiseHints");
  	if (!buf) {
  		duk_push_undefined(ctx);
  	} else {
  		duk_push_string(ctx, buf);
  	}
  
  	rc = duk_pcall(ctx, 1 /*nargs*/);  /* [ stash func ] -> [ stash result ] */
  	if (rc != 0) {
  		const char *res;
  		res = strdup(duk_safe_to_string(ctx, -1));
  		*color = 31;  /* red */
  		*bold = 1;
  		duk_pop_2(ctx);
  		return (char *) (uintptr_t) res;  /* uintptr_t cast to avoid const discard warning. */
  	}
  
  	if (duk_is_object(ctx, -1)) {
  		const char *tmp;
  		const char *res = NULL;
  
  		duk_get_prop_string(ctx, -1, "hints");
  		tmp = duk_get_string(ctx, -1);
  		if (tmp) {
  			res = strdup(tmp);
  		}
  		duk_pop(ctx);
  
  		duk_get_prop_string(ctx, -1, "color");
  		*color = duk_to_int(ctx, -1);
  		duk_pop(ctx);
  
  		duk_get_prop_string(ctx, -1, "bold");
  		*bold = duk_to_int(ctx, -1);
  		duk_pop(ctx);
  
  		duk_pop_2(ctx);
  		return (char *) (uintptr_t) res;  /* uintptr_t cast to avoid const discard warning. */
  	}
  
  	duk_pop_2(ctx);
  	return NULL;
  }
  
  static void linenoise_freehints(void *ptr) {
  #if 0
  	printf("free hint: %p\n", (void *) ptr);
  #endif
  	free(ptr);
  }
  
  static void linenoise_completion(const char *buf, linenoiseCompletions *lc) {
  	duk_context *ctx;
  	duk_int_t rc;
  
  	ctx = completion_ctx;
  	if (!ctx) {
  		return;
  	}
  
  	duk_push_global_stash(ctx);
  	duk_get_prop_string(ctx, -1, "linenoiseCompletion");
  
  	if (!buf) {
  		duk_push_undefined(ctx);
  	} else {
  		duk_push_string(ctx, buf);
  	}
  	duk_push_c_function(ctx, linenoise_add_completion, 2 /*nargs*/);
  	duk_push_pointer(ctx, (void *) lc);
  	duk_put_prop_string(ctx, -2, "lc");
  
  	rc = duk_pcall(ctx, 2 /*nargs*/);  /* [ stash func callback ] -> [ stash result ] */
  	if (rc != 0) {
  		linenoiseAddCompletion(lc, duk_safe_to_string(ctx, -1));
  	}
  	duk_pop_2(ctx);
  }
  #endif  /* DUK_CMDLINE_LINENOISE_COMPLETION */
  
  /*
   *  Execute from file handle etc
   */
  
  static int handle_fh(duk_context *ctx, FILE *f, const char *filename, const char *bytecode_filename) {
  	char *buf = NULL;
  	size_t bufsz;
  	size_t bufoff;
  	size_t got;
  	int rc;
  	int retval = -1;
  
  	buf = (char *) malloc(1024);
  	if (!buf) {
  		goto error;
  	}
  	bufsz = 1024;
  	bufoff = 0;
  
  	/* Read until EOF, avoid fseek/stat because it won't work with stdin. */
  	for (;;) {
  		size_t avail;
  
  		avail = bufsz - bufoff;
  		if (avail < 1024) {
  			size_t newsz;
  			char *buf_new;
  #if 0
  			fprintf(stderr, "resizing read buffer: %ld -> %ld\n", (long) bufsz, (long) (bufsz * 2));
  #endif
  			newsz = bufsz + (bufsz >> 2) + 1024;  /* +25% and some extra */
  			buf_new = (char *) realloc(buf, newsz);
  			if (!buf_new) {
  				goto error;
  			}
  			buf = buf_new;
  			bufsz = newsz;
  		}
  
  		avail = bufsz - bufoff;
  #if 0
  		fprintf(stderr, "reading input: buf=%p bufsz=%ld bufoff=%ld avail=%ld\n",
  		        (void *) buf, (long) bufsz, (long) bufoff, (long) avail);
  #endif
  
  		got = fread((void *) (buf + bufoff), (size_t) 1, avail, f);
  #if 0
  		fprintf(stderr, "got=%ld\n", (long) got);
  #endif
  		if (got == 0) {
  			break;
  		}
  		bufoff += got;
  
  		/* Emscripten specific: stdin EOF doesn't work as expected.
  		 * Instead, when 'emduk' is executed using Node.js, a file
  		 * piped to stdin repeats (!).  Detect that repeat and cut off
  		 * the stdin read.  Ensure the loop repeats enough times to
  		 * avoid detecting spurious loops.
  		 *
  		 * This only seems to work for inputs up to 256 bytes long.
  		 */
  #if defined(EMSCRIPTEN)
  		if (bufoff >= 16384) {
  			size_t i, j, nloops;
  			int looped = 0;
  
  			for (i = 16; i < bufoff / 8; i++) {
  				int ok;
  
  				nloops = bufoff / i;
  				ok = 1;
  				for (j = 1; j < nloops; j++) {
  					if (memcmp((void *) buf, (void *) (buf + i * j), i) != 0) {
  						ok = 0;
  						break;
  					}
  				}
  				if (ok) {
  					fprintf(stderr, "emscripten workaround: detect looping at index %ld, verified with %ld loops\n", (long) i, (long) (nloops - 1));
  					bufoff = i;
  					looped = 1;
  					break;
  				}
  			}
  
  			if (looped) {
  				break;
  			}
  		}
  #endif
  	}
  
  	duk_push_string(ctx, bytecode_filename);
  	duk_push_pointer(ctx, (void *) buf);
  	duk_push_uint(ctx, (duk_uint_t) bufoff);
  	duk_push_string(ctx, filename);
  
  	interactive_mode = 0;  /* global */
  
  	rc = duk_safe_call(ctx, wrapped_compile_execute, NULL /*udata*/, 4 /*nargs*/, 1 /*nret*/);
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	lowmem_clear_exec_timeout();
  #endif
  
  	free(buf);
  	buf = NULL;
  
  	if (rc != DUK_EXEC_SUCCESS) {
  		print_pop_error(ctx, stderr);
  		goto error;
  	} else {
  		duk_pop(ctx);
  		retval = 0;
  	}
  	/* fall thru */
  
   cleanup:
  	if (buf) {
  		free(buf);
  		buf = NULL;
  	}
  	return retval;
  
   error:
  	fprintf(stderr, "error in executing file %s\n", filename);
  	fflush(stderr);
  	goto cleanup;
  }
  
  static int handle_file(duk_context *ctx, const char *filename, const char *bytecode_filename) {
  	FILE *f = NULL;
  	int retval;
  	char fnbuf[256];
  
  	/* Example of sending an application specific debugger notification. */
  	duk_push_string(ctx, "DebuggerHandleFile");
  	duk_push_string(ctx, filename);
  	duk_debugger_notify(ctx, 2);
  
  #if defined(EMSCRIPTEN)
  	if (filename[0] == '/') {
  		snprintf(fnbuf, sizeof(fnbuf), "%s", filename);
  	} else {
  		snprintf(fnbuf, sizeof(fnbuf), "/working/%s", filename);
  	}
  #else
  	snprintf(fnbuf, sizeof(fnbuf), "%s", filename);
  #endif
  	fnbuf[sizeof(fnbuf) - 1] = (char) 0;
  
  	f = fopen(fnbuf, "rb");
  	if (!f) {
  		fprintf(stderr, "failed to open source file: %s\n", filename);
  		fflush(stderr);
  		goto error;
  	}
  
  	retval = handle_fh(ctx, f, filename, bytecode_filename);
  
  	fclose(f);
  	return retval;
  
   error:
  	return -1;
  }
  
  static int handle_eval(duk_context *ctx, char *code) {
  	int rc;
  	int retval = -1;
  
  	duk_push_pointer(ctx, (void *) code);
  	duk_push_uint(ctx, (duk_uint_t) strlen(code));
  	duk_push_string(ctx, "eval");
  
  	interactive_mode = 0;  /* global */
  
  	rc = duk_safe_call(ctx, wrapped_compile_execute, NULL /*udata*/, 3 /*nargs*/, 1 /*nret*/);
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	lowmem_clear_exec_timeout();
  #endif
  
  	if (rc != DUK_EXEC_SUCCESS) {
  		print_pop_error(ctx, stderr);
  	} else {
  		duk_pop(ctx);
  		retval = 0;
  	}
  
  	return retval;
  }
  
  #if defined(DUK_CMDLINE_LINENOISE)
  static int handle_interactive(duk_context *ctx) {
  	const char *prompt = "duk> ";
  	char *buffer = NULL;
  	int retval = 0;
  	int rc;
  
  	linenoiseSetMultiLine(1);
  	linenoiseHistorySetMaxLen(64);
  #if defined(DUK_CMDLINE_LINENOISE_COMPLETION)
  	linenoiseSetCompletionCallback(linenoise_completion);
  	linenoiseSetHintsCallback(linenoise_hints);
  	linenoiseSetFreeHintsCallback(linenoise_freehints);
  	duk_push_global_stash(ctx);
  	duk_eval_string(ctx, linenoise_completion_script);
  	duk_put_prop_string(ctx, -2, "linenoiseCompletion");
  	duk_eval_string(ctx, linenoise_hints_script);
  	duk_put_prop_string(ctx, -2, "linenoiseHints");
  	duk_pop(ctx);
  #endif
  
  	for (;;) {
  		if (buffer) {
  			linenoiseFree(buffer);
  			buffer = NULL;
  		}
  
  #if defined(DUK_CMDLINE_LINENOISE_COMPLETION)
  		completion_ctx = ctx;
  #endif
  		buffer = linenoise(prompt);
  #if defined(DUK_CMDLINE_LINENOISE_COMPLETION)
  		completion_ctx = NULL;
  #endif
  
  		if (!buffer) {
  			break;
  		}
  
  		if (buffer && buffer[0] != (char) 0) {
  			linenoiseHistoryAdd(buffer);
  		}
  
  		duk_push_pointer(ctx, (void *) buffer);
  		duk_push_uint(ctx, (duk_uint_t) strlen(buffer));
  		duk_push_string(ctx, "input");
  
  		interactive_mode = 1;  /* global */
  
  		rc = duk_safe_call(ctx, wrapped_compile_execute, NULL /*udata*/, 3 /*nargs*/, 1 /*nret*/);
  
  #if defined(DUK_CMDLINE_LOWMEM)
  		lowmem_clear_exec_timeout();
  #endif
  
  		if (buffer) {
  			linenoiseFree(buffer);
  			buffer = NULL;
  		}
  
  		if (rc != DUK_EXEC_SUCCESS) {
  			/* in interactive mode, write to stdout */
  			print_pop_error(ctx, stdout);
  			retval = -1;  /* an error 'taints' the execution */
  		} else {
  			duk_pop(ctx);
  		}
  	}
  
  	if (buffer) {
  		linenoiseFree(buffer);
  		buffer = NULL;
  	}
  
  	return retval;
  }
  #else  /* DUK_CMDLINE_LINENOISE */
  static int handle_interactive(duk_context *ctx) {
  	const char *prompt = "duk> ";
  	char *buffer = NULL;
  	int retval = 0;
  	int rc;
  	int got_eof = 0;
  
  	buffer = (char *) malloc(LINEBUF_SIZE);
  	if (!buffer) {
  		fprintf(stderr, "failed to allocated a line buffer\n");
  		fflush(stderr);
  		retval = -1;
  		goto done;
  	}
  
  	while (!got_eof) {
  		size_t idx = 0;
  
  		fwrite(prompt, 1, strlen(prompt), stdout);
  		fflush(stdout);
  
  		for (;;) {
  			int c = fgetc(stdin);
  			if (c == EOF) {
  				got_eof = 1;
  				break;
  			} else if (c == '\n') {
  				break;
  			} else if (idx >= LINEBUF_SIZE) {
  				fprintf(stderr, "line too long\n");
  				fflush(stderr);
  				retval = -1;
  				goto done;
  			} else {
  				buffer[idx++] = (char) c;
  			}
  		}
  
  		duk_push_pointer(ctx, (void *) buffer);
  		duk_push_uint(ctx, (duk_uint_t) idx);
  		duk_push_string(ctx, "input");
  
  		interactive_mode = 1;  /* global */
  
  		rc = duk_safe_call(ctx, wrapped_compile_execute, NULL /*udata*/, 3 /*nargs*/, 1 /*nret*/);
  
  #if defined(DUK_CMDLINE_LOWMEM)
  		lowmem_clear_exec_timeout();
  #endif
  
  		if (rc != DUK_EXEC_SUCCESS) {
  			/* in interactive mode, write to stdout */
  			print_pop_error(ctx, stdout);
  			retval = -1;  /* an error 'taints' the execution */
  		} else {
  			duk_pop(ctx);
  		}
  	}
  
   done:
  	if (buffer) {
  		free(buffer);
  		buffer = NULL;
  	}
  
  	return retval;
  }
  #endif  /* DUK_CMDLINE_LINENOISE */
  
  /*
   *  Simple file read/write bindings
   */
  
  #if defined(DUK_CMDLINE_FILEIO)
  static duk_ret_t fileio_read_file(duk_context *ctx) {
  	const char *fn;
  	char *buf;
  	size_t len;
  	size_t off;
  	int rc;
  	FILE *f;
  
  	fn = duk_require_string(ctx, 0);
  	f = fopen(fn, "rb");
  	if (!f) {
  		(void) duk_type_error(ctx, "cannot open file %s for reading, errno %ld: %s",
  		                      fn, (long) errno, strerror(errno));
  	}
  
  	rc = fseek(f, 0, SEEK_END);
  	if (rc < 0) {
  		(void) fclose(f);
  		(void) duk_type_error(ctx, "fseek() failed for %s, errno %ld: %s",
  		                      fn, (long) errno, strerror(errno));
  	}
  	len = (size_t) ftell(f);
  	rc = fseek(f, 0, SEEK_SET);
  	if (rc < 0) {
  		(void) fclose(f);
  		(void) duk_type_error(ctx, "fseek() failed for %s, errno %ld: %s",
  		                      fn, (long) errno, strerror(errno));
  	}
  
  	buf = (char *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
  	for (off = 0; off < len;) {
  		size_t got;
  		got = fread((void *) (buf + off), 1, len - off, f);
  		if (ferror(f)) {
  			(void) fclose(f);
  			(void) duk_type_error(ctx, "error while reading %s", fn);
  		}
  		if (got == 0) {
  			if (feof(f)) {
  				break;
  			} else {
  				(void) fclose(f);
  				(void) duk_type_error(ctx, "error while reading %s", fn);
  			}
  		}
  		off += got;
  	}
  
  	if (f) {
  		(void) fclose(f);
  	}
  
  	return 1;
  }
  
  static duk_ret_t fileio_write_file(duk_context *ctx) {
  	const char *fn;
  	const char *buf;
  	size_t len;
  	size_t off;
  	FILE *f;
  
  	fn = duk_require_string(ctx, 0);
  	f = fopen(fn, "wb");
  	if (!f) {
  		(void) duk_type_error(ctx, "cannot open file %s for writing, errno %ld: %s",
  		          fn, (long) errno, strerror(errno));
  	}
  
  	len = 0;
  	buf = (char *) duk_to_buffer(ctx, 1, &len);
  	for (off = 0; off < len;) {
  		size_t got;
  		got = fwrite((const void *) (buf + off), 1, len - off, f);
  		if (ferror(f)) {
  			(void) fclose(f);
  			(void) duk_type_error(ctx, "error while writing %s", fn);
  		}
  		if (got == 0) {
  			(void) fclose(f);
  			(void) duk_type_error(ctx, "error while writing %s", fn);
  		}
  		off += got;
  	}
  
  	if (f) {
  		(void) fclose(f);
  	}
  
  	return 0;
  }
  #endif  /* DUK_CMDLINE_FILEIO */
  
  /*
   *  String.fromBufferRaw()
   */
  
  static duk_ret_t string_frombufferraw(duk_context *ctx) {
  	duk_buffer_to_string(ctx, 0);
  	return 1;
  }
  
  /*
   *  Duktape heap lifecycle
   */
  
  #if defined(DUK_CMDLINE_DEBUGGER_SUPPORT)
  static duk_idx_t debugger_request(duk_context *ctx, void *udata, duk_idx_t nvalues) {
  	const char *cmd;
  	int i;
  
  	(void) udata;
  
  	if (nvalues < 1) {
  		duk_push_string(ctx, "missing AppRequest argument(s)");
  		return -1;
  	}
  
  	cmd = duk_get_string(ctx, -nvalues + 0);
  
  	if (cmd && strcmp(cmd, "CommandLine") == 0) {
  		if (!duk_check_stack(ctx, main_argc)) {
  			/* Callback should avoid errors for now, so use
  			 * duk_check_stack() rather than duk_require_stack().
  			 */
  			duk_push_string(ctx, "failed to extend stack");
  			return -1;
  		}
  		for (i = 0; i < main_argc; i++) {
  			duk_push_string(ctx, main_argv[i]);
  		}
  		return main_argc;
  	}
  	duk_push_sprintf(ctx, "command not supported");
  	return -1;
  }
  
  static void debugger_detached(duk_context *ctx, void *udata) {
  	fprintf(stderr, "Debugger detached, udata: %p\n", (void *) udata);
  	fflush(stderr);
  
  	/* Ensure socket is closed even when detach is initiated by Duktape
  	 * rather than debug client.
  	 */
  	duk_trans_socket_finish();
  
  	if (debugger_reattach) {
  		/* For automatic reattach testing. */
  		duk_trans_socket_init();
  		duk_trans_socket_waitconn();
  		fprintf(stderr, "Debugger reconnected, call duk_debugger_attach()\n");
  		fflush(stderr);
  #if 0
  		/* This is not necessary but should be harmless. */
  		duk_debugger_detach(ctx);
  #endif
  		duk_debugger_attach(ctx,
  		                    duk_trans_socket_read_cb,
  		                    duk_trans_socket_write_cb,
  		                    duk_trans_socket_peek_cb,
  		                    duk_trans_socket_read_flush_cb,
  		                    duk_trans_socket_write_flush_cb,
  		                    debugger_request,
  		                    debugger_detached,
  		                    NULL);
  	}
  }
  #endif
  
  #define  ALLOC_DEFAULT  0
  #define  ALLOC_LOGGING  1
  #define  ALLOC_TORTURE  2
  #define  ALLOC_HYBRID   3
  #define  ALLOC_LOWMEM   4
  
  static duk_context *create_duktape_heap(int alloc_provider, int debugger, int lowmem_log) {
  	duk_context *ctx;
  
  	(void) lowmem_log;  /* suppress warning */
  
  	ctx = NULL;
  	if (!ctx && alloc_provider == ALLOC_LOGGING) {
  #if defined(DUK_CMDLINE_ALLOC_LOGGING)
  		ctx = duk_create_heap(duk_alloc_logging,
  		                      duk_realloc_logging,
  		                      duk_free_logging,
  		                      (void *) 0xdeadbeef,
  		                      cmdline_fatal_handler);
  #else
  		fprintf(stderr, "Warning: option --alloc-logging ignored, no logging allocator support\n");
  		fflush(stderr);
  #endif
  	}
  	if (!ctx && alloc_provider == ALLOC_TORTURE) {
  #if defined(DUK_CMDLINE_ALLOC_TORTURE)
  		ctx = duk_create_heap(duk_alloc_torture,
  		                      duk_realloc_torture,
  		                      duk_free_torture,
  		                      (void *) 0xdeadbeef,
  		                      cmdline_fatal_handler);
  #else
  		fprintf(stderr, "Warning: option --alloc-torture ignored, no torture allocator support\n");
  		fflush(stderr);
  #endif
  	}
  	if (!ctx && alloc_provider == ALLOC_HYBRID) {
  #if defined(DUK_CMDLINE_ALLOC_HYBRID)
  		void *udata = duk_alloc_hybrid_init();
  		if (!udata) {
  			fprintf(stderr, "Failed to init hybrid allocator\n");
  			fflush(stderr);
  		} else {
  			ctx = duk_create_heap(duk_alloc_hybrid,
  			                      duk_realloc_hybrid,
  			                      duk_free_hybrid,
  			                      udata,
  			                      cmdline_fatal_handler);
  		}
  #else
  		fprintf(stderr, "Warning: option --alloc-hybrid ignored, no hybrid allocator support\n");
  		fflush(stderr);
  #endif
  	}
  	if (!ctx && alloc_provider == ALLOC_LOWMEM) {
  #if defined(DUK_CMDLINE_LOWMEM)
  		lowmem_init();
  
  		ctx = duk_create_heap(
  			lowmem_log ? lowmem_alloc_wrapped : duk_alloc_pool,
  			lowmem_log ? lowmem_realloc_wrapped : duk_realloc_pool,
  			lowmem_log ? lowmem_free_wrapped : duk_free_pool,
  			(void *) lowmem_pool_ptr,
  			cmdline_fatal_handler);
  #else
  		fprintf(stderr, "Warning: option --alloc-ajsheap ignored, no ajsheap allocator support\n");
  		fflush(stderr);
  #endif
  	}
  	if (!ctx && alloc_provider == ALLOC_DEFAULT) {
  		ctx = duk_create_heap(NULL, NULL, NULL, NULL, cmdline_fatal_handler);
  	}
  
  	if (!ctx) {
  		fprintf(stderr, "Failed to create Duktape heap\n");
  		fflush(stderr);
  		exit(1);
  	}
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	if (alloc_provider == ALLOC_LOWMEM) {
  		fprintf(stderr, "*** pool dump after heap creation ***\n");
  		lowmem_dump();
  	}
  #endif
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	if (alloc_provider == ALLOC_LOWMEM) {
  		lowmem_register(ctx);
  	}
  #endif
  
  	/* Register print() and alert() (removed in Duktape 2.x). */
  #if defined(DUK_CMDLINE_PRINTALERT_SUPPORT)
  	duk_print_alert_init(ctx, 0 /*flags*/);
  #endif
  
  	/* Register String.fromBufferRaw() which does a 1:1 buffer-to-string
  	 * coercion needed by testcases.  String.fromBufferRaw() is -not- a
  	 * default built-in!  For stripped builds the 'String' built-in
  	 * doesn't exist and we create it here; for ROM builds it may be
  	 * present but unwritable (which is ignored).
  	 */
  	duk_eval_string(ctx,
  		"(function(v){"
  		    "if (typeof String === 'undefined') { String = {}; }"
  		    "Object.defineProperty(String, 'fromBufferRaw', {value:v, configurable:true});"
  		"})");
  	duk_push_c_function(ctx, string_frombufferraw, 1 /*nargs*/);
  	(void) duk_pcall(ctx, 1);
  	duk_pop(ctx);
  
  	/* Register console object. */
  #if defined(DUK_CMDLINE_CONSOLE_SUPPORT)
  	duk_console_init(ctx, DUK_CONSOLE_PROXY_WRAPPER | DUK_CONSOLE_FLUSH /*flags*/);
  #endif
  
  	/* Register Duktape.Logger (removed in Duktape 2.x). */
  #if defined(DUK_CMDLINE_LOGGING_SUPPORT)
  	duk_logging_init(ctx, 0 /*flags*/);
  #endif
  
  	/* Register require() (removed in Duktape 2.x). */
  #if defined(DUK_CMDLINE_MODULE_SUPPORT)
  	duk_module_duktape_init(ctx);
  #endif
  
  	/* Register CBOR. */
  #if defined(DUK_CMDLINE_CBOR_SUPPORT)
  	duk_cbor_init(ctx, 0 /*flags*/);
  #endif
  
  	/* Trivial readFile/writeFile bindings for testing. */
  #if defined(DUK_CMDLINE_FILEIO)
  	duk_push_c_function(ctx, fileio_read_file, 1 /*nargs*/);
  	duk_put_global_string(ctx, "readFile");
  	duk_push_c_function(ctx, fileio_write_file, 2 /*nargs*/);
  	duk_put_global_string(ctx, "writeFile");
  #endif
  
  	/* Stash a formatting function for evaluation results. */
  	duk_push_global_stash(ctx);
  	duk_eval_string(ctx,
  		"(function (E) {"
  		    "return function format(v){"
  		        "try{"
  		            "return E('jx',v);"
  		        "}catch(e){"
  		            "return ''+v;"
  		        "}"
  		    "};"
  		"})(Duktape.enc)");
  	duk_put_prop_string(ctx, -2, "dukFormat");
  	duk_pop(ctx);
  
  	if (debugger) {
  #if defined(DUK_CMDLINE_DEBUGGER_SUPPORT)
  		fprintf(stderr, "Debugger enabled, create socket and wait for connection\n");
  		fflush(stderr);
  		duk_trans_socket_init();
  		duk_trans_socket_waitconn();
  		fprintf(stderr, "Debugger connected, call duk_debugger_attach() and then execute requested file(s)/eval\n");
  		fflush(stderr);
  		duk_debugger_attach(ctx,
  		                    duk_trans_socket_read_cb,
  		                    duk_trans_socket_write_cb,
  		                    duk_trans_socket_peek_cb,
  		                    duk_trans_socket_read_flush_cb,
  		                    duk_trans_socket_write_flush_cb,
  		                    debugger_request,
  		                    debugger_detached,
  		                    NULL);
  #else
  		fprintf(stderr, "Warning: option --debugger ignored, no debugger support\n");
  		fflush(stderr);
  #endif
  	}
  
  #if 0
  	/* Manual test for duk_debugger_cooperate() */
  	{
  		for (i = 0; i < 60; i++) {
  			printf("cooperate: %d\n", i);
  			usleep(1000000);
  			duk_debugger_cooperate(ctx);
  		}
  	}
  #endif
  
  	return ctx;
  }
  
  static void destroy_duktape_heap(duk_context *ctx, int alloc_provider) {
  	(void) alloc_provider;
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	if (alloc_provider == ALLOC_LOWMEM) {
  		fprintf(stderr, "*** pool dump before duk_destroy_heap(), before forced gc ***\n");
  		lowmem_dump();
  
  		duk_gc(ctx, 0);
  
  		fprintf(stderr, "*** pool dump before duk_destroy_heap(), after forced gc ***\n");
  		lowmem_dump();
  	}
  #endif
  
  	if (ctx) {
  		duk_destroy_heap(ctx);
  	}
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	if (alloc_provider == ALLOC_LOWMEM) {
  		fprintf(stderr, "*** pool dump after duk_destroy_heap() (should have zero allocs) ***\n");
  		lowmem_dump();
  	}
  	lowmem_free();
  #endif
  }
  
  /*
   *  Main
   */
  
  int main(int argc, char *argv[]) {
  	duk_context *ctx = NULL;
  	int retval = 0;
  	int have_files = 0;
  	int have_eval = 0;
  	int interactive = 0;
  	int memlimit_high = 1;
  	int alloc_provider = ALLOC_DEFAULT;
  	int lowmem_log = 0;
  	int debugger = 0;
  	int recreate_heap = 0;
  	int no_heap_destroy = 0;
  	int verbose = 0;
  	int run_stdin = 0;
  	const char *compile_filename = NULL;
  	int i;
  
  	main_argc = argc;
  	main_argv = (char **) argv;
  
  #if defined(EMSCRIPTEN)
  	/* Try to use NODEFS to provide access to local files.  Mount the
  	 * CWD as /working, and then prepend "/working/" to relative native
  	 * paths in file calls to get something that works reasonably for
  	 * relative paths.  Emscripten doesn't support replacing virtual
  	 * "/" with host "/" (the default MEMFS at "/" can't be unmounted)
  	 * but we can mount "/tmp" as host "/tmp" to allow testcase runs.
  	 *
  	 * https://kripken.github.io/emscripten-site/docs/api_reference/Filesystem-API.html#filesystem-api-nodefs
  	 * https://github.com/kripken/emscripten/blob/master/tests/fs/test_nodefs_rw.c
  	 */
  	EM_ASM(
  		/* At the moment it's not possible to replace the default MEMFS mounted at '/':
  		 * https://github.com/kripken/emscripten/issues/2040
  		 * https://github.com/kripken/emscripten/blob/incoming/src/library_fs.js#L1341-L1358
  		 */
  		/*
  		try {
  			FS.unmount("/");
  		} catch (e) {
  			console.log("Failed to unmount default '/' MEMFS mount: " + e);
  		}
  		*/
  		try {
  			FS.mkdir("/working");
  			FS.mount(NODEFS, { root: "." }, "/working");
  		} catch (e) {
  			console.log("Failed to mount NODEFS /working: " + e);
  		}
  		/* A virtual '/tmp' exists by default:
  		 * https://gist.github.com/evanw/e6be28094f34451bd5bd#file-temp-js-L3806-L3809
  		 */
  		/*
  		try {
  			FS.mkdir("/tmp");
  		} catch (e) {
  			console.log("Failed to create virtual /tmp: " + e);
  		}
  		*/
  		try {
  			FS.mount(NODEFS, { root: "/tmp" }, "/tmp");
  		} catch (e) {
  			console.log("Failed to mount NODEFS /tmp: " + e);
  		}
  	);
  #endif  /* EMSCRIPTEN */
  
  #if defined(DUK_CMDLINE_LOWMEM)
  	alloc_provider = ALLOC_LOWMEM;
  #endif
  	(void) lowmem_log;
  
  	/*
  	 *  Signal handling setup
  	 */
  
  #if defined(DUK_CMDLINE_SIGNAL)
  	set_sigint_handler();
  
  	/* This is useful at the global level; libraries should avoid SIGPIPE though */
  	/*signal(SIGPIPE, SIG_IGN);*/
  #endif
  
  	/*
  	 *  Parse options
  	 */
  
  	for (i = 1; i < argc; i++) {
  		char *arg = argv[i];
  		if (!arg) {
  			goto usage;
  		}
  		if (strcmp(arg, "--restrict-memory") == 0) {
  			memlimit_high = 0;
  		} else if (strcmp(arg, "-i") == 0) {
  			interactive = 1;
  		} else if (strcmp(arg, "-c") == 0) {
  			if (i == argc - 1) {
  				goto usage;
  			}
  			i++;
  			compile_filename = argv[i];
  		} else if (strcmp(arg, "-e") == 0) {
  			have_eval = 1;
  			if (i == argc - 1) {
  				goto usage;
  			}
  			i++;  /* skip code */
  		} else if (strcmp(arg, "--alloc-default") == 0) {
  			alloc_provider = ALLOC_DEFAULT;
  		} else if (strcmp(arg, "--alloc-logging") == 0) {
  			alloc_provider = ALLOC_LOGGING;
  		} else if (strcmp(arg, "--alloc-torture") == 0) {
  			alloc_provider = ALLOC_TORTURE;
  		} else if (strcmp(arg, "--alloc-hybrid") == 0) {
  			alloc_provider = ALLOC_HYBRID;
  		} else if (strcmp(arg, "--alloc-lowmem") == 0) {
  			alloc_provider = ALLOC_LOWMEM;
  		} else if (strcmp(arg, "--lowmem-log") == 0) {
  			lowmem_log = 1;
  		} else if (strcmp(arg, "--debugger") == 0) {
  			debugger = 1;
  #if defined(DUK_CMDLINE_DEBUGGER_SUPPORT)
  		} else if (strcmp(arg, "--reattach") == 0) {
  			debugger_reattach = 1;
  #endif
  		} else if (strcmp(arg, "--recreate-heap") == 0) {
  			recreate_heap = 1;
  		} else if (strcmp(arg, "--no-heap-destroy") == 0) {
  			no_heap_destroy = 1;
  		} else if (strcmp(arg, "--verbose") == 0) {
  			verbose = 1;
  		} else if (strcmp(arg, "--run-stdin") == 0) {
  			run_stdin = 1;
  		} else if (strlen(arg) >= 1 && arg[0] == '-') {
  			goto usage;
  		} else {
  			have_files = 1;
  		}
  	}
  	if (!have_files && !have_eval && !run_stdin) {
  		interactive = 1;
  	}
  
  	/*
  	 *  Memory limit
  	 */
  
  #if defined(DUK_CMDLINE_RLIMIT)
  	set_resource_limits(memlimit_high ? MEM_LIMIT_HIGH : MEM_LIMIT_NORMAL);
  #else
  	if (memlimit_high == 0) {
  		fprintf(stderr, "Warning: option --restrict-memory ignored, no rlimit support\n");
  		fflush(stderr);
  	}
  #endif
  
  	/*
  	 *  Create heap
  	 */
  
  	ctx = create_duktape_heap(alloc_provider, debugger, lowmem_log);
  
  	/*
  	 *  Execute any argument file(s)
  	 */
  
  	for (i = 1; i < argc; i++) {
  		char *arg = argv[i];
  		if (!arg) {
  			continue;
  		} else if (strlen(arg) == 2 && strcmp(arg, "-e") == 0) {
  			/* Here we know the eval arg exists but check anyway */
  			if (i == argc - 1) {
  				retval = 1;
  				goto cleanup;
  			}
  			if (handle_eval(ctx, argv[i + 1]) != 0) {
  				retval = 1;
  				goto cleanup;
  			}
  			i++;  /* skip code */
  			continue;
  		} else if (strlen(arg) == 2 && strcmp(arg, "-c") == 0) {
  			i++;  /* skip filename */
  			continue;
  		} else if (strlen(arg) >= 1 && arg[0] == '-') {
  			continue;
  		}
  
  		if (verbose) {
  			fprintf(stderr, "*** Executing file: %s\n", arg);
  			fflush(stderr);
  		}
  
  		if (handle_file(ctx, arg, compile_filename) != 0) {
  			retval = 1;
  			goto cleanup;
  		}
  
  		if (recreate_heap) {
  			if (verbose) {
  				fprintf(stderr, "*** Recreating heap...\n");
  				fflush(stderr);
  			}
  
  			destroy_duktape_heap(ctx, alloc_provider);
  			ctx = create_duktape_heap(alloc_provider, debugger, lowmem_log);
  		}
  	}
  
  	if (run_stdin) {
  		/* Running stdin like a full file (reading all lines before
  		 * compiling) is useful with emduk:
  		 * cat test.js | ./emduk --run-stdin
  		 */
  		if (handle_fh(ctx, stdin, "stdin", compile_filename) != 0) {
  			retval = 1;
  			goto cleanup;
  		}
  
  		if (recreate_heap) {
  			if (verbose) {
  				fprintf(stderr, "*** Recreating heap...\n");
  				fflush(stderr);
  			}
  
  			destroy_duktape_heap(ctx, alloc_provider);
  			ctx = create_duktape_heap(alloc_provider, debugger, lowmem_log);
  		}
  	}
  
  	/*
  	 *  Enter interactive mode if options indicate it
  	 */
  
  	if (interactive) {
  		print_greet_line();
  		if (handle_interactive(ctx) != 0) {
  			retval = 1;
  			goto cleanup;
  		}
  	}
  
  	/*
  	 *  Cleanup and exit
  	 */
  
   cleanup:
  	if (interactive) {
  		fprintf(stderr, "Cleaning up...\n");
  		fflush(stderr);
  	}
  
  	if (ctx && no_heap_destroy) {
  		duk_gc(ctx, 0);
  	}
  	if (ctx && !no_heap_destroy) {
  		destroy_duktape_heap(ctx, alloc_provider);
  	}
  	ctx = NULL;
  
  	return retval;
  
  	/*
  	 *  Usage
  	 */
  
   usage:
  	fprintf(stderr, "Usage: duk [options] [<filenames>]\n"
  	                "\n"
  	                "   -i                 enter interactive mode after executing argument file(s) / eval code\n"
  	                "   -e CODE            evaluate code\n"
  			"   -c FILE            compile into bytecode (use with only one file argument)\n"
  			"   --run-stdin        treat stdin like a file, i.e. compile full input (not line by line)\n"
  			"   --verbose          verbose messages to stderr\n"
  	                "   --restrict-memory  use lower memory limit (used by test runner)\n"
  	                "   --alloc-default    use Duktape default allocator\n"
  #if defined(DUK_CMDLINE_ALLOC_LOGGING)
  	                "   --alloc-logging    use logging allocator, write alloc log to /tmp/duk-alloc-log.txt\n"
  #endif
  #if defined(DUK_CMDLINE_ALLOC_TORTURE)
  	                "   --alloc-torture    use torture allocator\n"
  #endif
  #if defined(DUK_CMDLINE_ALLOC_HYBRID)
  	                "   --alloc-hybrid     use hybrid allocator\n"
  #endif
  #if defined(DUK_CMDLINE_LOWMEM)
  	                "   --alloc-lowmem     use pooled allocator (enabled by default for duk-low)\n"
  	                "   --lowmem-log       write alloc log to /tmp/lowmem-alloc-log.txt\n"
  #endif
  #if defined(DUK_CMDLINE_DEBUGGER_SUPPORT)
  			"   --debugger         start example debugger\n"
  			"   --reattach         automatically reattach debugger on detach\n"
  #endif
  			"   --recreate-heap    recreate heap after every file\n"
  			"   --no-heap-destroy  force GC, but don't destroy heap at end (leak testing)\n"
  	                "\n"
  	                "If <filename> is omitted, interactive mode is started automatically.\n");
  	fflush(stderr);
  	exit(1);
  }
  