/*
 *  Examples for low memory techniques
 */

#if defined(DUK_CMDLINE_LOWMEM)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "duktape.h"
#include "duk_cmdline.h"
#include "duk_alloc_pool.h"

#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)
/* Pointer compression with ROM strings/objects:
 *
 * For now, use DUK_USE_ROM_OBJECTS to signal the need for compressed ROM
 * pointers.  DUK_USE_ROM_PTRCOMP_FIRST is provided for the ROM pointer
 * compression range minimum to avoid duplication in user code.
 */
#if 0  /* This extern declaration is provided by duktape.h, array provided by duktape.c. */
extern const void * const duk_rom_compressed_pointers[];
#endif
static const void *duk__romptr_low = NULL;
static const void *duk__romptr_high = NULL;
#define DUK__ROMPTR_COMPRESSION
#define DUK__ROMPTR_FIRST ((duk_uint_t) DUK_USE_ROM_PTRCOMP_FIRST)
#endif

#define LOWMEM_NUM_POOLS 28

#define LOWMEM_HEAP_SIZE (255 * 1024)

static const duk_pool_config lowmem_config[LOWMEM_NUM_POOLS] = {
	{ 8,      10 * 8,     0 },
	{ 12,     600 * 12,   0 },
	{ 16,     300 * 16,   0 },
	{ 20,     300 * 20,   0 },
	{ 24,     300 * 24,   0 },
	{ 28,     250 * 28,   0 },
	{ 32,     150 * 32,   0 },
	{ 40,     150 * 40,   0 },
	{ 48,     50 * 48,    0 },
	{ 52,     50 * 52,    0 },
	{ 56,     50 * 56,    0 },
	{ 60,     50 * 60,    0 },
	{ 64,     50 * 64,    0 },
	{ 96,     50 * 96,    0 },
	{ 196,    0,          196 },  /* duk_heap, with heap ptr compression, ROM strings+objects */
	{ 232,    0,          232 },  /* duk_hthread, with heap ptr compression, ROM strings+objects */
	{ 256,    16 * 256,   0 },
	{ 288,    1 * 288,    0 },
	{ 320,    1 * 320,    0 },
	{ 400,    0,          400 },  /* duk_hthread, with heap ptr compression, RAM strings+objects */
	{ 520,    0,          520 },  /* duk_heap, with heap ptr compression, RAM strings+objects */
	{ 512,    16 * 512,   0 },
	{ 768,    0,          768 },  /* initial value stack for packed duk_tval */
	{ 1024,   6 * 1024,   0 },
	{ 2048,   5 * 2048,   0 },
	{ 4096,   3 * 4096,   0 },
	{ 8192,   3 * 8192,   0 },
	{ 16384,  1 * 16384,  0 },
};

static duk_pool_state lowmem_state[LOWMEM_NUM_POOLS];

static duk_pool_global lowmem_global;

void *lowmem_pool_ptr = NULL;

uint8_t *lowmem_ram = NULL;

static void *duk__lose_const(const void *ptr) {
	/* Somewhat portable way of losing a const without warnings.
	 * Another approach is to cast through intptr_t, but that
	 * type is not always available.
	 */
	union {
		const void *p;
		void *q;
	} u;
	u.p = ptr;
	return u.q;
}

static void duk__safe_print_chars(const char *p, duk_size_t len, int until_nul) {
	duk_size_t i;

	fprintf(stderr, "\"");
	for (i = 0; i < len; i++) {
		unsigned char x = (unsigned char) p[i];
		if (until_nul && x == 0U) {
			break;
		}
		if (x < 0x20 || x >= 0x7e || x == '"' || x == '\'' || x == '\\') {
			fprintf(stderr, "\\x%02x", (int) x);
		} else {
			fprintf(stderr, "%c", (char) x);
		}
	}
	fprintf(stderr, "\"");
}


void lowmem_init(void) {
	void *ptr;

	lowmem_ram = (uint8_t *) malloc(LOWMEM_HEAP_SIZE);
	if (lowmem_ram == NULL) {
		fprintf(stderr, "Failed to allocate lowmem heap\n");
		fflush(stderr);
		exit(1);
	}

	ptr = duk_alloc_pool_init((char *) lowmem_ram,
	                          LOWMEM_HEAP_SIZE,
	                          lowmem_config,
	                          lowmem_state,
	                          LOWMEM_NUM_POOLS,
	                          &lowmem_global);
	if (ptr == NULL) {
		free(lowmem_ram);
		lowmem_ram = NULL;
		fprintf(stderr, "Failed to init lowmem pool\n");
		fflush(stderr);
		exit(1);
	}

	lowmem_pool_ptr = ptr;

#if defined(DUK__ROMPTR_COMPRESSION)
	/* Scan ROM pointer range for faster detection of "is 'p' a ROM pointer"
	 * later on.
	 */
	if (1) {
		const void * const * ptrs = (const void * const *) duk_rom_compressed_pointers;
		duk__romptr_low = duk__romptr_high = (const void *) *ptrs;
		while (*ptrs) {
			if (*ptrs > duk__romptr_high) {
				duk__romptr_high = (const void *) *ptrs;
			}
			if (*ptrs < duk__romptr_low) {
				duk__romptr_low = (const void *) *ptrs;
			}
			ptrs++;
		}
		fprintf(stderr, "romptrs: low=%p high=%p\n",
		        (const void *) duk__romptr_low, (const void *) duk__romptr_high);
		fflush(stderr);
	}
#endif
}

void lowmem_free(void) {
	if (lowmem_ram != NULL) {
		free(lowmem_ram);
		lowmem_ram = NULL;
	}
	lowmem_pool_ptr = NULL;
}

static duk_ret_t lowmem__dump_binding(duk_context *ctx) {
	lowmem_dump();
	return 0;
}

void lowmem_dump(void) {
	int i;
	duk_pool_global_stats global_stats;

	for (i = 0; i < LOWMEM_NUM_POOLS; i++) {
		duk_pool_state *s = &lowmem_state[i];
		duk_pool_stats stats;

		duk_alloc_pool_get_pool_stats(s, &stats);

		fprintf(stderr, "  %2ld: %4ld %5ldB | free %4ld %5ldB | used %4ld %5ldB | waste %5ldB | hwm %4ld (%3ld%%)%s\n",
		        (long) i, (long) s->count, (long) s->size,
		        (long) stats.free_count, (long) stats.free_bytes,
		        (long) stats.used_count, (long) stats.used_bytes,
		        (long) stats.waste_bytes, (long) stats.hwm_used_count,
		        (long) ((double) stats.hwm_used_count / (double) s->count * 100.0),
		        (stats.hwm_used_count == s->count ? " !" : ""));
	}

	/* This causes another walk over the individual pools which is a bit
	 * inelegant, but we want the highwater mark stats too.
	 */
	duk_alloc_pool_get_global_stats(&lowmem_global, &global_stats);

	fprintf(stderr, "  TOTAL: %ld bytes used, %ld bytes waste, %ld bytes free, %ld bytes total; highwater %ld used, %ld waste\n",
	        (long) global_stats.used_bytes, (long) global_stats.waste_bytes,
	        (long) global_stats.free_bytes, (long) (global_stats.used_bytes + global_stats.free_bytes),
	        (long) global_stats.hwm_used_bytes, (long) global_stats.hwm_waste_bytes);
	fflush(stderr);
}

void lowmem_register(duk_context *ctx) {
	duk_push_global_object(ctx);
	duk_push_string(ctx, "dumpHeap");
	duk_push_c_function(ctx, lowmem__dump_binding, 0);
	duk_def_prop(ctx, -3, DUK_DEFPROP_SET_WRITABLE |
	                      DUK_DEFPROP_CLEAR_ENUMERABLE |
	                      DUK_DEFPROP_SET_CONFIGURABLE |
	                      DUK_DEFPROP_HAVE_VALUE);
	duk_pop(ctx);
}

/*
 *  Wrapped alloc functions
 *
 *  Used to write an alloc log.
 */

static FILE *lowmem_alloc_log = NULL;

static void lowmem_write_alloc_log(const char *fmt, ...) {
	va_list ap;
	char buf[256];

	va_start(ap, fmt);
	vsnprintf(buf, sizeof(buf), fmt, ap);
	buf[sizeof(buf) - 1] = (char) 0;
	va_end(ap);

	if (lowmem_alloc_log == NULL) {
		lowmem_alloc_log = fopen("/tmp/lowmem-alloc-log.txt", "wb");
		if (lowmem_alloc_log == NULL) {
			fprintf(stderr, "WARNING: failed to write alloc log, ignoring\n");
			fflush(stderr);
			return;
		}
	}

	(void) fwrite((const void *) buf, 1, strlen(buf), lowmem_alloc_log);
	(void) fflush(lowmem_alloc_log);
}

void *lowmem_alloc_wrapped(void *udata, duk_size_t size) {
	void *ret = duk_alloc_pool(udata, size);
	if (size > 0 && ret == NULL) {
		lowmem_write_alloc_log("A FAIL %ld\n", (long) size);
	} else if (ret == NULL) {
		lowmem_write_alloc_log("A NULL %ld\n", (long) size);
	} else {
		lowmem_write_alloc_log("A %p %ld\n", ret, (long) size);
	}
	return ret;
}

void *lowmem_realloc_wrapped(void *udata, void *ptr, duk_size_t size) {
	void *ret = duk_realloc_pool(udata, ptr, size);
	if (size > 0 && ret == NULL) {
		if (ptr == NULL) {
			lowmem_write_alloc_log("R NULL -1 FAIL %ld\n", (long) size);
		} else {
			lowmem_write_alloc_log("R %p -1 FAIL %ld\n", ptr, (long) size);
		}
	} else if (ret == NULL) {
		if (ptr == NULL) {
			lowmem_write_alloc_log("R NULL -1 NULL %ld\n", (long) size);
		} else {
			lowmem_write_alloc_log("R %p -1 NULL %ld\n", ptr, (long) size);
		}
	} else {
		if (ptr == NULL) {
			lowmem_write_alloc_log("R NULL -1 %p %ld\n", ret, (long) size);
		} else {
			lowmem_write_alloc_log("R %p -1 %p %ld\n", ptr, ret, (long) size);
		}
	}
	return ret;
}

void lowmem_free_wrapped(void *udata, void *ptr) {
	duk_free_pool(udata, ptr);
	if (ptr == NULL) {
		/* Ignore. */
	} else {
		lowmem_write_alloc_log("F %p -1\n", ptr);
	}
}

/*
 *  Example pointer compression functions.
 *
 *  'base' is chosen so that no non-NULL pointer results in a zero result
 *  which is reserved for NULL pointers.
 */

duk_uint16_t lowmem_enc16(void *ud, void *p) {
	duk_uint32_t ret;
	char *base = (char *) lowmem_ram - 4;

#if defined(DUK__ROMPTR_COMPRESSION)
	if (p >= duk__romptr_low && p <= duk__romptr_high) {
		/* The if-condition should be the fastest possible check
		 * for "is 'p' in ROM?".  If pointer is in ROM, we'd like
		 * to compress it quickly.  Here we just scan a ~1K array
		 * which is very bad for performance and for illustration
		 * only.
		 */
		const void * const * ptrs = duk_rom_compressed_pointers;
		while (*ptrs) {
			if (*ptrs == p) {
				ret = (duk_uint32_t) DUK__ROMPTR_FIRST + (duk_uint32_t) (ptrs - duk_rom_compressed_pointers);
#if 0
				fprintf(stderr, "lowmem_enc16: rom pointer: %p -> 0x%04lx\n", (void *) p, (long) ret);
				fflush(stderr);
#endif
				return (duk_uint16_t) ret;
			}
			ptrs++;
		}

		/* We should really never be here: Duktape should only be
		 * compressing pointers which are in the ROM compressed
		 * pointers list, which are known at 'make dist' time.
		 * We go on, causing a pointer compression error.
		 */
		fprintf(stderr, "lowmem_enc16: rom pointer: %p could not be compressed, should never happen\n", (void *) p);
		fflush(stderr);
	}
#endif

	/* Userdata is not needed in this case but would be useful if heap
	 * pointer compression were used for multiple heaps.  The userdata
	 * allows the callback to distinguish between heaps and their base
	 * pointers.
	 *
	 * If not needed, the userdata can be left out during compilation
	 * by simply ignoring the userdata argument of the pointer encode
	 * and decode macros.  It is kept here so that any bugs in actually
	 * providing the value inside Duktape are revealed during compilation.
	 */
	(void) ud;
#if 1
	/* Ensure that we always get the heap_udata given in heap creation.
	 * (Useful for Duktape development, not needed for user programs.)
	 */
	if (ud != (void *) lowmem_pool_ptr) {
		fprintf(stderr, "invalid udata for lowmem_enc16: %p\n", ud);
		fflush(stderr);
	}
#endif

	if (p == NULL) {
		ret = 0;
	} else {
		ret = (duk_uint32_t) (((char *) p - base) >> 2);
	}
#if 0
	fprintf(stderr, "lowmem_enc16: %p -> %u\n", p, (unsigned int) ret);
#endif
	if (ret > 0xffffUL) {
		fprintf(stderr, "Failed to compress pointer: %p (ret was %ld)\n", (void *) p, (long) ret);
		fflush(stderr);
		abort();
	}
#if defined(DUK__ROMPTR_COMPRESSION)
	if (ret >= (duk_uint32_t) DUK__ROMPTR_FIRST) {
		fprintf(stderr, "Failed to compress pointer, in 16-bit range but matches romptr range: %p (ret was %ld)\n", (void *) p, (long) ret);
		fflush(stderr);
		abort();
	}
#endif
	return (duk_uint16_t) ret;
}

void *lowmem_dec16(void *ud, duk_uint16_t x) {
	void *ret;
	char *base = (char *) lowmem_ram - 4;

#if defined(DUK__ROMPTR_COMPRESSION)
	if (x >= (duk_uint16_t) DUK__ROMPTR_FIRST) {
		/* This is a blind lookup, could check index validity.
		 * Duktape should never decompress a pointer which would
		 * be out-of-bounds here.
		 */
		ret = (void *) duk__lose_const(duk_rom_compressed_pointers[x - (duk_uint16_t) DUK__ROMPTR_FIRST]);
#if 0
		fprintf(stderr, "lowmem_dec16: rom pointer: 0x%04lx -> %p\n", (long) x, ret);
		fflush(stderr);
#endif
		return ret;
	}
#endif

	/* See userdata discussion in lowmem_enc16(). */
	(void) ud;
#if 1
	/* Ensure that we always get the heap_udata given in heap creation. */
	if (ud != (void *) lowmem_pool_ptr) {
		fprintf(stderr, "invalid udata for lowmem_dec16: %p\n", ud);
		fflush(stderr);
	}
#endif

	if (x == 0) {
		ret = NULL;
	} else {
		ret = (void *) (base + (((duk_uint32_t) x) << 2));
	}
#if 0
	fprintf(stderr, "lowmem_dec16: %u -> %p\n", (unsigned int) x, ret);
#endif
	return ret;
}

/*
 *  Simplified example of an external strings strategy where incoming strings
 *  are written sequentially into a fixed, memory mapped flash area.
 *
 *  The example first scans if the string is already in the flash (which may
 *  happen if the same string is interned multiple times), then adds it to
 *  flash if there is space.
 *
 *  This example is too slow to be used in a real world application: there
 *  should be e.g. a hash table to quickly check for strings that are already
 *  present in the string data (similarly to how string interning works in
 *  Duktape itself).
 */

static uint8_t lowmem_strdata[65536];
static size_t lowmem_strdata_used = 0;

const void *lowmem_extstr_check_1(const void *ptr, duk_size_t len) {
	uint8_t *p, *p_end;
	uint8_t initial;
	uint8_t *ret;
	size_t left;

	(void) duk__safe_print_chars;  /* potentially unused */

	if (len <= 3) {
		/* It's not worth it to make very small strings external, as
		 * they would take the same space anyway.  Also avoids zero
		 * length degenerate case.
		 */
		return NULL;
	}

	/*
	 *  Check if we already have the string.  Be careful to compare for
	 *  NUL terminator too, it is NOT present in 'ptr'.  This algorithm
	 *  is too simplistic and way too slow for actual use.
	 */

	initial = ((const uint8_t *) ptr)[0];
	for (p = lowmem_strdata, p_end = p + lowmem_strdata_used; p != p_end; p++) {
		if (*p != initial) {
			continue;
		}
		left = (size_t) (p_end - p);
		if (left >= len + 1 &&
		    memcmp(p, ptr, len) == 0 &&
		    p[len] == 0) {
			ret = p;
#if 0
			fprintf(stderr, "lowmem_extstr_check_1: ptr=%p, len=%ld ",
			       (void *) ptr, (long) len);
			duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
			fprintf(stderr, " -> existing %p (used=%ld)\n",
			       (void *) ret, (long) lowmem_strdata_used);
#endif
			return ret;
		}
	}

	/*
	 *  Not present yet, check if we have space.  Again, be careful to
	 *  ensure there is space for a NUL following the input data.
	 */

	if (lowmem_strdata_used + len + 1 > sizeof(lowmem_strdata)) {
#if 0
		fprintf(stderr, "lowmem_extstr_check_1: ptr=%p, len=%ld ", (void *) ptr, (long) len);
		duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
		fprintf(stderr, " -> no space (used=%ld)\n", (long) lowmem_strdata_used);
#endif
		return NULL;
	}

	/*
	 *  There is space, add the string to our collection, being careful
	 *  to append the NUL.
	 */

	ret = lowmem_strdata + lowmem_strdata_used;
	memcpy(ret, ptr, len);
	ret[len] = (uint8_t) 0;
	lowmem_strdata_used += len + 1;

#if 0
	fprintf(stderr, "lowmem_extstr_check_1: ptr=%p, len=%ld -> ", (void *) ptr, (long) len);
	duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
	fprintf(stderr, " -> %p (used=%ld)\n", (void *) ret, (long) lowmem_strdata_used);
#endif
	return (const void *) ret;
}

void lowmem_extstr_free_1(const void *ptr) {
	(void) ptr;
#if 0
	fprintf(stderr, "lowmem_extstr_free_1: freeing extstr %p -> ", ptr);
	duk__safe_print_chars((const char *) ptr, DUK_SIZE_MAX, 1 /*until_nul*/);
	fprintf(stderr, "\n");
#endif
}

/*
 *  Simplified example of an external strings strategy where a set of strings
 *  is gathered during application compile time and baked into the application
 *  binary.
 *
 *  Duktape built-in strings are available from duk_source_meta.json in a
 *  prepared source directory, see tools/duk_meta_to_strarray.py.  There
 *  may also be a lot of application specific strings, e.g. those used by
 *  application specific APIs.  These must be gathered through some other
 *  means, see e.g. tools/scan_strings.py.
 */

static const char *strdata_duk_builtin_strings[] = {
	/*
	 *  These strings are from tools/duk_meta_to_strarray.py
	 */

	"Logger",
	"Thread",
	"Pointer",
	"Buffer",
	"DecEnv",
	"ObjEnv",
	"",
	"global",
	"Arguments",
	"JSON",
	"Math",
	"Error",
	"RegExp",
	"Date",
	"Number",
	"Boolean",
	"String",
	"Array",
	"Function",
	"Object",
	"Null",
	"Undefined",
	"{_func:true}",
	"{\x22" "_func\x22" ":true}",
	"{\x22" "_ninf\x22" ":true}",
	"{\x22" "_inf\x22" ":true}",
	"{\x22" "_nan\x22" ":true}",
	"{\x22" "_undef\x22" ":true}",
	"toLogString",
	"clog",
	"l",
	"n",
	"fatal",
	"error",
	"warn",
	"debug",
	"trace",
	"raw",
	"fmt",
	"current",
	"resume",
	"compact",
	"jc",
	"jx",
	"base64",
	"hex",
	"dec",
	"enc",
	"fin",
	"gc",
	"act",
	"info",
	"version",
	"env",
	"modLoaded",
	"modSearch",
	"errThrow",
	"errCreate",
	"compile",
	"\x82" "Regbase",
	"\x82" "Thread",
	"\x82" "Handler",
	"\x82" "Finalizer",
	"\x82" "Callee",
	"\x82" "Map",
	"\x82" "Args",
	"\x82" "This",
	"\x82" "Pc2line",
	"\x82" "Source",
	"\x82" "Varenv",
	"\x82" "Lexenv",
	"\x82" "Varmap",
	"\x82" "Formals",
	"\x82" "Bytecode",
	"\x82" "Next",
	"\x82" "Target",
	"\x82" "Value",
	"pointer",
	"buffer",
	"\x82" "Tracedata",
	"lineNumber",
	"fileName",
	"pc",
	"stack",
	"ThrowTypeError",
	"Duktape",
	"id",
	"require",
	"__proto__",
	"setPrototypeOf",
	"ownKeys",
	"enumerate",
	"deleteProperty",
	"has",
	"Proxy",
	"callee",
	"Invalid Date",
	"[...]",
	"\x0a" "\x09",
	" ",
	",",
	"-0",
	"+0",
	"0",
	"-Infinity",
	"+Infinity",
	"Infinity",
	"object",
	"string",
	"number",
	"boolean",
	"undefined",
	"stringify",
	"tan",
	"sqrt",
	"sin",
	"round",
	"random",
	"pow",
	"min",
	"max",
	"log",
	"floor",
	"exp",
	"cos",
	"ceil",
	"atan2",
	"atan",
	"asin",
	"acos",
	"abs",
	"SQRT2",
	"SQRT1_2",
	"PI",
	"LOG10E",
	"LOG2E",
	"LN2",
	"LN10",
	"E",
	"message",
	"name",
	"input",
	"index",
	"(?:)",
	"lastIndex",
	"multiline",
	"ignoreCase",
	"source",
	"test",
	"exec",
	"toGMTString",
	"setYear",
	"getYear",
	"toJSON",
	"toISOString",
	"toUTCString",
	"setUTCFullYear",
	"setFullYear",
	"setUTCMonth",
	"setMonth",
	"setUTCDate",
	"setDate",
	"setUTCHours",
	"setHours",
	"setUTCMinutes",
	"setMinutes",
	"setUTCSeconds",
	"setSeconds",
	"setUTCMilliseconds",
	"setMilliseconds",
	"setTime",
	"getTimezoneOffset",
	"getUTCMilliseconds",
	"getMilliseconds",
	"getUTCSeconds",
	"getSeconds",
	"getUTCMinutes",
	"getMinutes",
	"getUTCHours",
	"getHours",
	"getUTCDay",
	"getDay",
	"getUTCDate",
	"getDate",
	"getUTCMonth",
	"getMonth",
	"getUTCFullYear",
	"getFullYear",
	"getTime",
	"toLocaleTimeString",
	"toLocaleDateString",
	"toTimeString",
	"toDateString",
	"now",
	"UTC",
	"parse",
	"toPrecision",
	"toExponential",
	"toFixed",
	"POSITIVE_INFINITY",
	"NEGATIVE_INFINITY",
	"NaN",
	"MIN_VALUE",
	"MAX_VALUE",
	"substr",
	"trim",
	"toLocaleUpperCase",
	"toUpperCase",
	"toLocaleLowerCase",
	"toLowerCase",
	"substring",
	"split",
	"search",
	"replace",
	"match",
	"localeCompare",
	"charCodeAt",
	"charAt",
	"fromCharCode",
	"reduceRight",
	"reduce",
	"filter",
	"map",
	"forEach",
	"some",
	"every",
	"lastIndexOf",
	"indexOf",
	"unshift",
	"splice",
	"sort",
	"slice",
	"shift",
	"reverse",
	"push",
	"pop",
	"join",
	"concat",
	"isArray",
	"arguments",
	"caller",
	"bind",
	"call",
	"apply",
	"propertyIsEnumerable",
	"isPrototypeOf",
	"hasOwnProperty",
	"valueOf",
	"toLocaleString",
	"toString",
	"constructor",
	"set",
	"get",
	"enumerable",
	"configurable",
	"writable",
	"value",
	"keys",
	"isExtensible",
	"isFrozen",
	"isSealed",
	"preventExtensions",
	"freeze",
	"seal",
	"defineProperties",
	"defineProperty",
	"create",
	"getOwnPropertyNames",
	"getOwnPropertyDescriptor",
	"getPrototypeOf",
	"prototype",
	"length",
	"alert",
	"print",
	"unescape",
	"escape",
	"encodeURIComponent",
	"encodeURI",
	"decodeURIComponent",
	"decodeURI",
	"isFinite",
	"isNaN",
	"parseFloat",
	"parseInt",
	"eval",
	"URIError",
	"TypeError",
	"SyntaxError",
	"ReferenceError",
	"RangeError",
	"EvalError",
	"break",
	"case",
	"catch",
	"continue",
	"debugger",
	"default",
	"delete",
	"do",
	"else",
	"finally",
	"for",
	"function",
	"if",
	"in",
	"instanceof",
	"new",
	"return",
	"switch",
	"this",
	"throw",
	"try",
	"typeof",
	"var",
	"void",
	"while",
	"with",
	"class",
	"const",
	"enum",
	"export",
	"extends",
	"import",
	"super",
	"null",
	"true",
	"false",
	"implements",
	"interface",
	"let",
	"package",
	"private",
	"protected",
	"public",
	"static",
	"yield",

	/*
	 *  These strings are manually added, and would be gathered in some
	 *  application specific manner.
	 */

	"foo",
	"bar",
	"quux",
	"enableFrob",
	"disableFrob"
	/* ... */
};

const void *lowmem_extstr_check_2(const void *ptr, duk_size_t len) {
	int i, n;

	(void) duk__safe_print_chars;  /* potentially unused */

	/* Linear scan.  An actual implementation would need some acceleration
	 * structure, e.g. select a sublist based on first character.
	 *
	 * NOTE: input string (behind 'ptr' with 'len' bytes) DOES NOT have a
	 * trailing NUL character.  Any strings returned from this function
	 * MUST have a trailing NUL character.
	 */

	n = (int) (sizeof(strdata_duk_builtin_strings) / sizeof(const char *));
	for (i = 0; i < n; i++) {
		const char *str;

		str = strdata_duk_builtin_strings[i];
		if (strlen(str) == len && memcmp(ptr, (const void *) str, len) == 0) {
#if 0
			fprintf(stderr, "lowmem_extstr_check_2: ptr=%p, len=%ld ",
			       (void *) ptr, (long) len);
			duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
			fprintf(stderr, " -> constant string index %ld\n", (long) i);
#endif
			return (void *) duk__lose_const(strdata_duk_builtin_strings[i]);
		}
	}

#if 0
	fprintf(stderr, "lowmem_extstr_check_2: ptr=%p, len=%ld ",
	       (void *) ptr, (long) len);
	duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
	fprintf(stderr, " -> not found\n");
#endif
	return NULL;
}

void lowmem_extstr_free_2(const void *ptr) {
	(void) ptr;
#if 0
	fprintf(stderr, "lowmem_extstr_free_2: freeing extstr %p -> ", ptr);
	duk__safe_print_chars((const char *) ptr, DUK_SIZE_MAX, 1 /*until_nul*/);
	fprintf(stderr, "\n");
#endif
}

/*
 *  External strings strategy intended for valgrind testing: external strings
 *  are allocated using malloc()/free() so that valgrind can be used to ensure
 *  that strings are e.g. freed exactly once.
 */

const void *lowmem_extstr_check_3(const void *ptr, duk_size_t len) {
	duk_uint8_t *ret;

	(void) duk__safe_print_chars;  /* potentially unused */

	ret = malloc((size_t) len + 1);
	if (ret == NULL) {
#if 0
		fprintf(stderr, "lowmem_extstr_check_3: ptr=%p, len=%ld ",
		       (void *) ptr, (long) len);
		duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
		fprintf(stderr, " -> malloc failed, return NULL\n");
#endif
		return (const void *) NULL;
	}

	if (len > 0) {
		memcpy((void *) ret, ptr, (size_t) len);
	}
	ret[len] = (duk_uint8_t) 0;

#if 0
	fprintf(stderr, "lowmem_extstr_check_3: ptr=%p, len=%ld ",
	       (void *) ptr, (long) len);
	duk__safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
	fprintf(stderr, " -> %p\n", (void *) ret);
#endif
	return (const void *) ret;
}

void lowmem_extstr_free_3(const void *ptr) {
	(void) ptr;
#if 0
	fprintf(stderr, "lowmem_extstr_free_3: freeing extstr %p -> ", ptr);
	duk__safe_print_chars((const char *) ptr, DUK_SIZE_MAX, 1 /*until_nul*/);
	fprintf(stderr, "\n");
#endif
	free((void *) duk__lose_const(ptr));
}

/*
 *  Execution timeout example
 */

#define  AJSHEAP_EXEC_TIMEOUT  5  /* seconds */

static time_t curr_pcall_start = 0;
static long exec_timeout_check_counter = 0;

void lowmem_start_exec_timeout(void) {
	curr_pcall_start = time(NULL);
}

void lowmem_clear_exec_timeout(void) {
	curr_pcall_start = 0;
}

duk_bool_t lowmem_exec_timeout_check(void *udata) {
	time_t now = time(NULL);
	time_t diff = now - curr_pcall_start;

	(void) udata;  /* not needed */

	exec_timeout_check_counter++;
#if 0
	fprintf(stderr, "exec timeout check %ld: now=%ld, start=%ld, diff=%ld\n",
	       (long) exec_timeout_check_counter, (long) now, (long) curr_pcall_start, (long) diff);
	fflush(stderr);
#endif

	if (curr_pcall_start == 0) {
		/* protected call not yet running */
		return 0;
	}
	if (diff > AJSHEAP_EXEC_TIMEOUT) {
		return 1;
	}
	return 0;
}

#else  /* DUK_CMDLINE_LOWMEM */

int duk_lowmem_dummy = 0;  /* to avoid empty source file */

#endif  /* DUK_CMDLINE_LOWMEM */