thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/examples/cmdline/duk_cmdline_ajduk.c

/*
 *  'ajduk' specific functionality, examples for low memory techniques
 */

#ifdef DUK_CMDLINE_AJSHEAP

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "ajs.h"
#include "ajs_heap.h"
#include "duktape.h"

extern uint8_t dbgHEAPDUMP;

#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_USE_ROM_PTRCOMP_FIRST
#endif

/*
 *  Helpers
 */

static void *ajduk__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 safe_print_chars(const char *p, duk_size_t len, int until_nul) {
	duk_size_t i;

	printf("\"");
	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 == '\\') {
			printf("\\x%02x", (int) x);
		} else {
			printf("%c", (char) x);
		}
	}
	printf("\"");
}

/*
 *  Heap initialization when using AllJoyn.js pool allocator (without any
 *  other AllJoyn.js integration).  This serves as an example of how to
 *  integrate Duktape with a pool allocator and is useful for low memory
 *  testing.
 *
 *  The pool sizes are not optimized here.  The sizes are chosen so that
 *  you can look at the high water mark (hwm) and use counts (use) and see
 *  how much allocations are needed for each pool size.  To optimize pool
 *  sizes more accurately, you can use --alloc-logging and inspect the memory
 *  allocation log which provides exact byte counts etc.
 *
 *  https://git.allseenalliance.org/cgit/core/alljoyn-js.git
 *  https://git.allseenalliance.org/cgit/core/alljoyn-js.git/tree/ajs.c
 */

static const AJS_HeapConfig ajsheap_config[] = {
	{ 8,      10,   AJS_POOL_BORROW,  0 },
	{ 12,     600,  AJS_POOL_BORROW,  0 },
	{ 16,     300,  AJS_POOL_BORROW,  0 },
	{ 20,     300,  AJS_POOL_BORROW,  0 },
	{ 24,     300,  AJS_POOL_BORROW,  0 },
	{ 28,     150,  AJS_POOL_BORROW,  0 },
	{ 32,     150,  AJS_POOL_BORROW,  0 },
	{ 40,     150,  AJS_POOL_BORROW,  0 },
	{ 48,     50,   AJS_POOL_BORROW,  0 },
	{ 52,     50,   AJS_POOL_BORROW,  0 },
	{ 56,     50,   AJS_POOL_BORROW,  0 },
	{ 60,     50,   AJS_POOL_BORROW,  0 },
	{ 64,     50,   AJS_POOL_BORROW,  0 },
	{ 128,    80,   AJS_POOL_BORROW,  0 },
	{ 256,    16,   AJS_POOL_BORROW,  0 },
	{ 320,    1,    AJS_POOL_BORROW,  0 },
	{ 392,    1,    AJS_POOL_BORROW,  0 },  /* duk_hthread, with heap ptr compression, ROM strings+objects */
	{ 512,    16,   AJS_POOL_BORROW,  0 },
	{ 964,    1,    AJS_POOL_BORROW,  0 },  /* duk_heap, with heap ptr compression, ROM strings+objects */
	{ 1024,   6,    AJS_POOL_BORROW,  0 },
	{ 1344,   1,    AJS_POOL_BORROW,  0 },  /* duk_heap, with heap ptr compression, RAM strings+objects */
	{ 2048,   5,    AJS_POOL_BORROW,  0 },
	{ 4096,   3,    0,                0 },
	{ 8192,   3,    0,                0 },
	{ 16384,  1,    0,                0 },
	{ 32768,  1,    0,                0 }
};

uint8_t *ajsheap_ram = NULL;

void ajsheap_init(void) {
	size_t heap_sz[1];
	uint8_t *heap_array[1];
	uint8_t num_pools, i;
	AJ_Status ret;

	num_pools = (uint8_t) (sizeof(ajsheap_config) / sizeof(AJS_HeapConfig));
	heap_sz[0] = AJS_HeapRequired(ajsheap_config,  /* heapConfig */
	                              num_pools,       /* numPools */
	                              0);              /* heapNum */
	ajsheap_ram = (uint8_t *) malloc(heap_sz[0]);
	if (ajsheap_ram == NULL) {
		fprintf(stderr, "Failed to allocate AJS heap\n");
		fflush(stderr);
		exit(1);
	}
	heap_array[0] = ajsheap_ram;

	fprintf(stderr, "Allocated AJS heap of %ld bytes, pools:", (long) heap_sz[0]);
	for (i = 0; i < num_pools; i++) {
		fprintf(stderr, " (sz:%ld,num:%ld,brw:%ld,idx:%ld)",
		        (long) ajsheap_config[i].size, (long) ajsheap_config[i].entries,
		        (long) ajsheap_config[i].borrow, (long) ajsheap_config[i].heapIndex);
	}
	fprintf(stderr, "\n");
	fflush(stderr);

	ret = AJS_HeapInit((void **) heap_array,   /* heap */
	                   (size_t *) heap_sz,     /* heapSz */
	                   ajsheap_config,         /* heapConfig */
	                   num_pools,              /* numPools */
	                   1);                     /* numHeaps */
	fprintf(stderr, "AJS_HeapInit() -> %ld\n", (long) ret);
	fflush(stderr);

	/* Enable heap dumps */
	dbgHEAPDUMP = 1;

#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 ajsheap_free(void) {
	if (ajsheap_ram != NULL) {
		free(ajsheap_ram);
		ajsheap_ram = NULL;
	}
}

/* AjsHeap.dump(), allows Ecmascript code to dump heap status at suitable
 * points.
 */
duk_ret_t ajsheap_dump_binding(duk_context *ctx) {
	AJS_HeapDump();
	fflush(stdout);
	return 0;
}

void ajsheap_dump(void) {
	AJS_HeapDump();
	fflush(stdout);
}

void ajsheap_register(duk_context *ctx) {
	duk_push_object(ctx);
	duk_push_c_function(ctx, ajsheap_dump_binding, 0);
	duk_put_prop_string(ctx, -2, "dump");
	duk_put_global_string(ctx, "AjsHeap");
}

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

static FILE *ajsheap_alloc_log = NULL;

static void ajsheap_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 (ajsheap_alloc_log == NULL) {
		ajsheap_alloc_log = fopen("/tmp/ajduk-alloc-log.txt", "wb");
		if (ajsheap_alloc_log == NULL) {
			fprintf(stderr, "WARNING: failed to write alloc log, ignoring\n");
			fflush(stderr);
			return;
		}
	}

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

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

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

void ajsheap_free_wrapped(void *udata, void *ptr) {
	AJS_Free(udata, ptr);
	if (ptr == NULL) {
	} else {
		ajsheap_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 ajsheap_enc16(void *ud, void *p) {
	duk_uint32_t ret;
	char *base = (char *) ajsheap_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__ROMPTR_FIRST + (ptrs - duk_rom_compressed_pointers);
#if 0
				fprintf(stderr, "ajsheap_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, "ajsheap_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 *) 0xdeadbeef) {
		fprintf(stderr, "invalid udata for ajsheap_enc16: %p\n", ud);
		fflush(stderr);
	}
#endif

	if (p == NULL) {
		ret = 0;
	} else {
		ret = (duk_uint32_t) (((char *) p - base) >> 2);
	}
#if 0
	printf("ajsheap_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__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 *ajsheap_dec16(void *ud, duk_uint16_t x) {
	void *ret;
	char *base = (char *) ajsheap_ram - 4;

#if defined(DUK__ROMPTR_COMPRESSION)
	if (x >= 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 *) ajduk__lose_const(duk_rom_compressed_pointers[x - DUK__ROMPTR_FIRST]);
#if 0
		fprintf(stderr, "ajsheap_dec16: rom pointer: 0x%04lx -> %p\n", (long) x, ret);
		fflush(stderr);
#endif
		return ret;
	}
#endif

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

	if (x == 0) {
		ret = NULL;
	} else {
		ret = (void *) (base + (((duk_uint32_t) x) << 2));
	}
#if 0
	printf("ajsheap_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 ajsheap_strdata[65536];
static size_t ajsheap_strdata_used = 0;

const void *ajsheap_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) 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 = ajsheap_strdata, p_end = p + ajsheap_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
			printf("ajsheap_extstr_check_1: ptr=%p, len=%ld ",
			       (void *) ptr, (long) len);
			safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
			printf(" -> existing %p (used=%ld)\n",
			       (void *) ret, (long) ajsheap_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 (ajsheap_strdata_used + len + 1 > sizeof(ajsheap_strdata)) {
#if 0
		printf("ajsheap_extstr_check_1: ptr=%p, len=%ld ", (void *) ptr, (long) len);
		safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
		printf(" -> no space (used=%ld)\n", (long) ajsheap_strdata_used);
#endif
		return NULL;
	}

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

	ret = ajsheap_strdata + ajsheap_strdata_used;
	memcpy(ret, ptr, len);
	ret[len] = (uint8_t) 0;
	ajsheap_strdata_used += len + 1;

#if 0
	printf("ajsheap_extstr_check_1: ptr=%p, len=%ld -> ", (void *) ptr, (long) len);
	safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
	printf(" -> %p (used=%ld)\n", (void *) ret, (long) ajsheap_strdata_used);
#endif
	return (const void *) ret;
}

void ajsheap_extstr_free_1(const void *ptr) {
	(void) ptr;
#if 0
	printf("ajsheap_extstr_free_1: freeing extstr %p -> ", ptr);
	safe_print_chars((const char *) ptr, DUK_SIZE_MAX, 1 /*until_nul*/);
	printf("\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_build_meta.json, see
 *  util/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. util/scan_strings.py.
 */

static const char *strdata_duk_builtin_strings[] = {
	/*
	 *  These strings are from util/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",
	"\xff" "Regbase",
	"\xff" "Thread",
	"\xff" "Handler",
	"\xff" "Finalizer",
	"\xff" "Callee",
	"\xff" "Map",
	"\xff" "Args",
	"\xff" "This",
	"\xff" "Pc2line",
	"\xff" "Source",
	"\xff" "Varenv",
	"\xff" "Lexenv",
	"\xff" "Varmap",
	"\xff" "Formals",
	"\xff" "Bytecode",
	"\xff" "Next",
	"\xff" "Target",
	"\xff" "Value",
	"pointer",
	"buffer",
	"\xff" "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 *ajsheap_extstr_check_2(const void *ptr, duk_size_t len) {
	int i, n;

	(void) 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
			printf("ajsheap_extstr_check_2: ptr=%p, len=%ld ",
			       (void *) ptr, (long) len);
			safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
			printf(" -> constant string index %ld\n", (long) i);
#endif
			return (void *) ajduk__lose_const(strdata_duk_builtin_strings[i]);
		}
	}

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

void ajsheap_extstr_free_2(const void *ptr) {
	(void) ptr;
#if 0
	printf("ajsheap_extstr_free_2: freeing extstr %p -> ", ptr);
	safe_print_chars((const char *) ptr, DUK_SIZE_MAX, 1 /*until_nul*/);
	printf("\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 *ajsheap_extstr_check_3(const void *ptr, duk_size_t len) {
	duk_uint8_t *ret;

	(void) safe_print_chars;  /* potentially unused */

	ret = malloc((size_t) len + 1);
	if (ret == NULL) {
#if 0
		printf("ajsheap_extstr_check_3: ptr=%p, len=%ld ",
		       (void *) ptr, (long) len);
		safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
		printf(" -> 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
	printf("ajsheap_extstr_check_3: ptr=%p, len=%ld ",
	       (void *) ptr, (long) len);
	safe_print_chars((const char *) ptr, len, 0 /*until_nul*/);
	printf(" -> %p\n", (void *) ret);
#endif
	return (const void *) ret;
}

void ajsheap_extstr_free_3(const void *ptr) {
	(void) ptr;
#if 0
	printf("ajsheap_extstr_free_3: freeing extstr %p -> ", ptr);
	safe_print_chars((const char *) ptr, DUK_SIZE_MAX, 1 /*until_nul*/);
	printf("\n");
#endif
	free((void *) ajduk__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 ajsheap_start_exec_timeout(void) {
	curr_pcall_start = time(NULL);
}

void ajsheap_clear_exec_timeout(void) {
	curr_pcall_start = 0;
}

duk_bool_t ajsheap_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
	printf("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(stdout);
#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_AJSHEAP */

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

#endif  /* DUK_CMDLINE_AJSHEAP */