duktape-1.5.2/examples/cmdline/duk_cmdline_ajduk.c

Go to the documentation of this file.

/*
 *  '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 */