DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_strptime(duk_context *ctx, const char *str) {
struct tm tm;
time_t t;
char buf[DUK__STRPTIME_BUF_SIZE];
/* copy to buffer with spare to avoid Valgrind gripes from strptime */
DUK_ASSERT(str != NULL);
DUK_MEMZERO(buf, sizeof(buf)); /* valgrind whine without this */
DUK_SNPRINTF(buf, sizeof(buf), "%s", (const char *) str);
buf[sizeof(buf) - 1] = (char) 0;
DUK_DDD(DUK_DDDPRINT("parsing: '%s'", (const char *) buf));
DUK_MEMZERO(&tm, sizeof(tm));
if (strptime((const char *) buf, "%c", &tm) != NULL) {
DUK_DDD(DUK_DDDPRINT("before mktime: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
"wday:%ld,yday:%ld,isdst:%ld}",
(long) tm.tm_sec, (long) tm.tm_min, (long) tm.tm_hour,
(long) tm.tm_mday, (long) tm.tm_mon, (long) tm.tm_year,
(long) tm.tm_wday, (long) tm.tm_yday, (long) tm.tm_isdst));
tm.tm_isdst = -1; /* negative: dst info not available */
t = mktime(&tm);
DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t));
if (t >= 0) {
duk_push_number(ctx, ((duk_double_t) t) * 1000.0);
return 1;
}
}
return 0;
}
DUK_INTERNAL duk_bool_t duk_bi_date_format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags) {
char buf[DUK__STRFTIME_BUF_SIZE];
struct tm tm;
const char *fmt;
DUK_UNREF(tzoffset);
/* If the platform doesn't support the entire Ecmascript range, we need
* to return 0 so that the caller can fall back to the default formatter.
*
* For now, assume that if time_t is 8 bytes or more, the whole Ecmascript
* range is supported. For smaller time_t values (4 bytes in practice),
* assumes that the signed 32-bit range is supported.
*
* XXX: detect this more correctly per platform. The size of time_t is
* probably not an accurate guarantee of strftime() supporting or not
* supporting a large time range (the full Ecmascript range).
*/
if (sizeof(time_t) < 8 &&
(parts[DUK_DATE_IDX_YEAR] < 1970 || parts[DUK_DATE_IDX_YEAR] > 2037)) {
/* be paranoid for 32-bit time values (even avoiding negative ones) */
return 0;
}
DUK_MEMZERO(&tm, sizeof(tm));
tm.tm_sec = parts[DUK_DATE_IDX_SECOND];
tm.tm_min = parts[DUK_DATE_IDX_MINUTE];
tm.tm_hour = parts[DUK_DATE_IDX_HOUR];
tm.tm_mday = parts[DUK_DATE_IDX_DAY]; /* already one-based */
tm.tm_mon = parts[DUK_DATE_IDX_MONTH] - 1; /* one-based -> zero-based */
tm.tm_year = parts[DUK_DATE_IDX_YEAR] - 1900;
tm.tm_wday = parts[DUK_DATE_IDX_WEEKDAY];
tm.tm_isdst = 0;
DUK_MEMZERO(buf, sizeof(buf));
if ((flags & DUK_DATE_FLAG_TOSTRING_DATE) && (flags & DUK_DATE_FLAG_TOSTRING_TIME)) {
fmt = "%c";
} else if (flags & DUK_DATE_FLAG_TOSTRING_DATE) {
fmt = "%x";
} else {
DUK_ASSERT(flags & DUK_DATE_FLAG_TOSTRING_TIME);
fmt = "%X";
}
(void) strftime(buf, sizeof(buf) - 1, fmt, &tm);
DUK_ASSERT(buf[sizeof(buf) - 1] == 0);
duk_push_string(ctx, buf);
return 1;
}
DUK_INTERNAL duk_hcompfunc *duk_hcompfunc_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
duk_hcompfunc *res;
res = (duk_hcompfunc *) DUK_ALLOC(heap, sizeof(duk_hcompfunc));
if (DUK_UNLIKELY(res == NULL)) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hcompfunc));
duk__init_object_parts(heap, &res->obj, hobject_flags);
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
#if defined(DUK_USE_HEAPPTR16)
/* NULL pointer is required to encode to zero, so memset is enough. */
#else
res->data = NULL;
res->funcs = NULL;
res->bytecode = NULL;
#endif
res->lex_env = NULL;
res->var_env = NULL;
#endif
return res;
}
static duk_hstring *duk__alloc_init_hstring(duk_heap *heap,
duk_uint8_t *str,
duk_uint32_t blen,
duk_uint32_t strhash) {
duk_hstring *res = NULL;
duk_uint8_t *data;
duk_size_t alloc_size;
duk_uarridx_t dummy;
/* NUL terminate for convenient C access */
alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1);
res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
if (!res) {
goto error;
}
DUK_MEMZERO(res, sizeof(duk_hstring));
#ifdef DUK_USE_EXPLICIT_NULL_INIT
DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
#endif
DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0);
if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
DUK_HSTRING_SET_ARRIDX(res);
}
/* All strings beginning with 0xff are treated as "internal",
* even strings interned by the user. This allows user code to
* create internal properties too, and makes behavior consistent
* in case user code happens to use a string also used by Duktape
* (such as string has already been interned and has the 'internal'
* flag set).
*/
if (blen > 0 && str[0] == (duk_uint8_t) 0xff) {
DUK_HSTRING_SET_INTERNAL(res);
}
res->hash = strhash;
res->blen = blen;
res->clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen); /* clen <= blen */
data = (duk_uint8_t *) (res + 1);
DUK_MEMCPY(data, str, blen);
data[blen] = (duk_uint8_t) 0;
DUK_DDD(DUK_DDDPRINT("interned string, hash=0x%08lx, blen=%ld, clen=%ld, has_arridx=%ld",
(unsigned long) DUK_HSTRING_GET_HASH(res),
(long) DUK_HSTRING_GET_BYTELEN(res),
(long) DUK_HSTRING_GET_CHARLEN(res),
(long) DUK_HSTRING_HAS_ARRIDX(res) ? 1 : 0));
return res;
error:
DUK_FREE(heap, res);
return NULL;
}
DUK_INTERNAL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size) {
void *res;
DUK_ASSERT(heap != NULL);
DUK_ASSERT_DISABLE(size >= 0);
res = DUK_ALLOC(heap, size);
if (DUK_LIKELY(res != NULL)) {
/* assume memset with zero size is OK */
DUK_MEMZERO(res, size);
}
return res;
}
DUK_INTERNAL duk_harray *duk_harray_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
duk_harray *res;
res = (duk_harray *) DUK_ALLOC(heap, sizeof(duk_harray));
if (DUK_UNLIKELY(res == NULL)) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_harray));
duk__init_object_parts(heap, &res->obj, hobject_flags);
DUK_ASSERT(res->length == 0);
return res;
}
static duk_hstring *duk__alloc_init_hstring(duk_heap *heap,
duk_uint8_t *str,
duk_uint32_t blen,
duk_uint32_t strhash) {
duk_hstring *res = NULL;
duk_uint8_t *data;
duk_uint32_t alloc_size;
duk_uint32_t dummy;
/* NUL terminate for convenient C access */
alloc_size = sizeof(duk_hstring) + blen + 1;
res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
if (!res) {
goto error;
}
DUK_MEMZERO(res, sizeof(duk_hstring));
#ifdef DUK_USE_EXPLICIT_NULL_INIT
DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
#endif
DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0);
if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
DUK_HSTRING_SET_ARRIDX(res);
}
res->hash = strhash;
res->blen = blen;
res->clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen); /* clen <= blen */
data = (duk_uint8_t *) (res + 1);
DUK_MEMCPY(data, str, blen);
data[blen] = (duk_uint8_t) 0;
DUK_DDD(DUK_DDDPRINT("interned string, hash=0x%08x, blen=%d, clen=%d, arridx=%d",
DUK_HSTRING_GET_HASH(res),
DUK_HSTRING_GET_BYTELEN(res),
DUK_HSTRING_GET_CHARLEN(res),
DUK_HSTRING_HAS_ARRIDX(res) ? 1 : 0));
return res;
error:
DUK_FREE(heap, res);
return NULL;
}
DUK_INTERNAL duk_hnatfunc *duk_hnatfunc_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
duk_hnatfunc *res;
res = (duk_hnatfunc *) DUK_ALLOC(heap, sizeof(duk_hnatfunc));
if (DUK_UNLIKELY(res == NULL)) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hnatfunc));
duk__init_object_parts(heap, &res->obj, hobject_flags);
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
res->func = NULL;
#endif
return res;
}
duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, int hobject_flags) {
duk_hnativefunction *res;
res = (duk_hnativefunction *) DUK_ALLOC(heap, sizeof(duk_hnativefunction));
if (!res) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hnativefunction));
duk__init_object_parts(heap, &res->obj, hobject_flags);
#ifdef DUK_USE_EXPLICIT_NULL_INIT
res->func = NULL;
#endif
return res;
}
DUK_INTERNAL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
duk_hthread *res;
res = (duk_hthread *) DUK_ALLOC(heap, sizeof(duk_hthread));
if (DUK_UNLIKELY(res == NULL)) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hthread));
duk__init_object_parts(heap, &res->obj, hobject_flags);
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
res->ptr_curr_pc = NULL;
res->heap = NULL;
res->valstack = NULL;
res->valstack_end = NULL;
res->valstack_bottom = NULL;
res->valstack_top = NULL;
res->callstack = NULL;
res->catchstack = NULL;
res->resumer = NULL;
res->compile_ctx = NULL,
#if defined(DUK_USE_HEAPPTR16)
res->strs16 = NULL;
#else
res->strs = NULL;
#endif
{
int i;
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
res->builtins[i] = NULL;
}
}
#endif
/* when nothing is running, API calls are in non-strict mode */
DUK_ASSERT(res->strict == 0);
res->heap = heap;
res->valstack_max = DUK_VALSTACK_DEFAULT_MAX;
res->callstack_max = DUK_CALLSTACK_DEFAULT_MAX;
res->catchstack_max = DUK_CATCHSTACK_DEFAULT_MAX;
return res;
}
static void duk__sanitize_snippet(char *buf, duk_size_t buf_size, duk_hstring *str) {
duk_size_t i;
duk_size_t nchars;
duk_size_t maxchars;
duk_uint8_t *data;
DUK_MEMZERO(buf, buf_size);
maxchars = (duk_size_t) (buf_size - 1);
data = DUK_HSTRING_GET_DATA(str);
nchars = ((duk_size_t) str->blen < maxchars ? (duk_size_t) str->blen : maxchars);
for (i = 0; i < nchars; i++) {
duk_small_int_t c = (duk_small_int_t) data[i];
if (c < 0x20 || c > 0x7e) {
c = '.';
}
buf[i] = (char) c;
}
}
DUK_INTERNAL duk_hbufobj *duk_hbufobj_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
duk_hbufobj *res;
res = (duk_hbufobj *) DUK_ALLOC(heap, sizeof(duk_hbufobj));
if (DUK_UNLIKELY(res == NULL)) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hbufobj));
duk__init_object_parts(heap, &res->obj, hobject_flags);
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
res->buf = NULL;
res->buf_prop = NULL;
#endif
DUK_ASSERT_HBUFOBJ_VALID(res);
return res;
}
duk_hobject *duk_hobject_alloc(duk_heap *heap, int hobject_flags) {
duk_hobject *res;
DUK_ASSERT(heap != NULL);
/* different memory layout, alloc size, and init */
DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_COMPILEDFUNCTION) == 0);
DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_NATIVEFUNCTION) == 0);
DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_THREAD) == 0);
res = (duk_hobject *) DUK_ALLOC(heap, sizeof(duk_hobject));
if (!res) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hobject));
duk__init_object_parts(heap, res, hobject_flags);
return res;
}
DUK_INTERNAL duk_hobject *duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
duk_hobject *res;
DUK_ASSERT(heap != NULL);
/* different memory layout, alloc size, and init */
DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_COMPFUNC) == 0);
DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_NATFUNC) == 0);
DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_THREAD) == 0);
res = (duk_hobject *) DUK_ALLOC(heap, sizeof(duk_hobject));
if (DUK_UNLIKELY(res == NULL)) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hobject));
duk__init_object_parts(heap, res, hobject_flags);
return res;
}
void *duk_heap_mem_alloc_checked_zeroed(duk_hthread *thr, size_t size, const char *filename, int line) {
#else
void *duk_heap_mem_alloc_checked_zeroed(duk_hthread *thr, size_t size) {
#endif
void *res;
DUK_ASSERT(thr != NULL);
DUK_ASSERT_DISABLE(size >= 0);
res = DUK_ALLOC(thr->heap, size);
if (!res) {
#ifdef DUK_USE_VERBOSE_ERRORS
DUK_ERROR_RAW(filename, line, thr, DUK_ERR_ALLOC_ERROR, "memory alloc failed");
#else
DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "memory alloc failed");
#endif
}
/* assume memset with zero size is OK */
DUK_MEMZERO(res, size);
return res;
}
void duk_hbuffer_remove_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, size_t offset, size_t length) {
char *p;
size_t end_offset;
DUK_UNREF(thr);
DUK_ASSERT(thr != NULL);
DUK_ASSERT(buf != NULL);
DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
DUK_ASSERT_DISABLE(offset >= 0); /* always true */
DUK_ASSERT(offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */
DUK_ASSERT_DISABLE(length >= 0); /* always true */
DUK_ASSERT(offset + length <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */
if (length == 0) {
return;
}
p = (char *) DUK_HBUFFER_DYNAMIC_GET_CURR_DATA_PTR(buf);
end_offset = offset + length;
if (end_offset < DUK_HBUFFER_GET_SIZE(buf)) {
/* not strictly from end of buffer; need to shuffle data */
DUK_MEMMOVE(p + offset,
p + end_offset,
DUK_HBUFFER_GET_SIZE(buf) - end_offset); /* always > 0 */
}
/* Here we want to zero data even with automatic buffer zeroing
* disabled as we depend on this internally too.
*/
DUK_MEMZERO(p + DUK_HBUFFER_GET_SIZE(buf) - length,
length); /* always > 0 */
buf->size -= length;
/* Note: no shrink check, intentional */
}
duk_hthread *duk_hthread_alloc(duk_heap *heap, int hobject_flags) {
duk_hthread *res;
res = (duk_hthread *) DUK_ALLOC(heap, sizeof(duk_hthread));
if (!res) {
return NULL;
}
DUK_MEMZERO(res, sizeof(duk_hthread));
duk__init_object_parts(heap, &res->obj, hobject_flags);
#ifdef DUK_USE_EXPLICIT_NULL_INIT
res->heap = NULL;
res->valstack = NULL;
res->valstack_end = NULL;
res->valstack_bottom = NULL;
res->valstack_top = NULL;
res->callstack = NULL;
res->catchstack = NULL;
res->resumer = NULL;
res->strs = NULL;
{
int i;
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
res->builtins[i] = NULL;
}
}
#endif
/* when nothing is running, API calls are in non-strict mode */
DUK_ASSERT(res->strict == 0);
res->heap = heap;
res->valstack_max = DUK_VALSTACK_DEFAULT_MAX;
res->callstack_max = DUK_CALLSTACK_DEFAULT_MAX;
res->catchstack_max = DUK_CATCHSTACK_DEFAULT_MAX;
return res;
}
DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str) {
struct tm tm;
duk_small_int_t rc;
time_t t;
/* For this to work, DATEMSK must be set, so this is not very
* convenient for an embeddable interpreter.
*/
DUK_MEMZERO(&tm, sizeof(struct tm));
rc = (duk_small_int_t) getdate_r(str, &tm);
DUK_DDD(DUK_DDDPRINT("getdate_r() -> %ld", (long) rc));
if (rc == 0) {
t = mktime(&tm);
DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t));
if (t >= 0) {
duk_push_number(ctx, (duk_double_t) t);
return 1;
}
}
return 0;
}
DUK_INTERNAL
duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
duk_realloc_function realloc_func,
duk_free_function free_func,
void *heap_udata,
duk_fatal_function fatal_func) {
duk_heap *res = NULL;
/* Silence a few global unused warnings here. */
DUK_UNREF(duk_str_unsupported);
DUK_D(DUK_DPRINT("allocate heap"));
/*
* Debug dump type sizes
*/
#ifdef DUK_USE_DEBUG
duk__dump_misc_options();
duk__dump_type_sizes();
duk__dump_type_limits();
#endif
/*
* If selftests enabled, run them as early as possible
*/
#ifdef DUK_USE_SELF_TESTS
DUK_D(DUK_DPRINT("running self tests"));
duk_selftest_run_tests();
DUK_D(DUK_DPRINT("self tests passed"));
#endif
/*
* Computed values (e.g. INFINITY)
*/
#ifdef DUK_USE_COMPUTED_NAN
do {
/* Workaround for some exotic platforms where NAN is missing
* and the expression (0.0 / 0.0) does NOT result in a NaN.
* Such platforms use the global 'duk_computed_nan' which must
* be initialized at runtime. Use 'volatile' to ensure that
* the compiler will actually do the computation and not try
* to do constant folding which might result in the original
* problem.
*/
volatile double dbl1 = 0.0;
volatile double dbl2 = 0.0;
duk_computed_nan = dbl1 / dbl2;
} while (0);
#endif
#ifdef DUK_USE_COMPUTED_INFINITY
do {
/* Similar workaround for INFINITY. */
volatile double dbl1 = 1.0;
volatile double dbl2 = 0.0;
duk_computed_infinity = dbl1 / dbl2;
} while (0);
#endif
/*
* Allocate heap struct
*
* Use a raw call, all macros expect the heap to be initialized
*/
res = (duk_heap *) alloc_func(heap_udata, sizeof(duk_heap));
if (!res) {
goto error;
}
/*
* Zero the struct, and start initializing roughly in order
*/
DUK_MEMZERO(res, sizeof(*res));
/* explicit NULL inits */
#ifdef DUK_USE_EXPLICIT_NULL_INIT
res->heap_udata = NULL;
res->heap_allocated = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
res->refzero_list = NULL;
res->refzero_list_tail = NULL;
#endif
#ifdef DUK_USE_MARK_AND_SWEEP
res->finalize_list = NULL;
#endif
res->heap_thread = NULL;
res->curr_thread = NULL;
res->heap_object = NULL;
#if defined(DUK_USE_STRTAB_CHAIN)
/* nothing to NULL */
#elif defined(DUK_USE_STRTAB_PROBE)
#if defined(DUK_USE_HEAPPTR16)
res->strtable16 = (duk_uint16_t *) NULL;
#else
res->strtable = (duk_hstring **) NULL;
#endif
#endif
#if defined(DUK_USE_HEAPPTR16)
/* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */
#else
{
duk_small_uint_t i;
for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
res->strs[i] = NULL;
}
}
#endif
#if defined(DUK_USE_DEBUGGER_SUPPORT)
res->dbg_read_cb = NULL;
res->dbg_write_cb = NULL;
res->dbg_peek_cb = NULL;
res->dbg_read_flush_cb = NULL;
res->dbg_write_flush_cb = NULL;
res->dbg_udata = NULL;
res->dbg_step_thread = NULL;
#endif
#endif /* DUK_USE_EXPLICIT_NULL_INIT */
res->alloc_func = alloc_func;
res->realloc_func = realloc_func;
res->free_func = free_func;
res->heap_udata = heap_udata;
res->fatal_func = fatal_func;
#if defined(DUK_USE_HEAPPTR16)
/* XXX: zero assumption */
res->heapptr_null16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) NULL);
res->heapptr_deleted16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) DUK_STRTAB_DELETED_MARKER(res));
#endif
/* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */
res->call_recursion_depth = 0;
res->call_recursion_limit = DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT;
/* XXX: use the pointer as a seed for now: mix in time at least */
/* The casts through duk_intr_pt is to avoid the following GCC warning:
*
* warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
*
* This still generates a /Wp64 warning on VS2010 when compiling for x86.
*/
res->hash_seed = (duk_uint32_t) (duk_intptr_t) res;
res->rnd_state = (duk_uint32_t) (duk_intptr_t) res;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
res->lj.jmpbuf_ptr = NULL;
#endif
DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN); /* zero */
DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value1);
DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value2);
#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME)
#error initial heap stringtable size is defined incorrectly
#endif
/*
* Init stringtable: fixed variant
*/
#if defined(DUK_USE_STRTAB_CHAIN)
DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE);
#ifdef DUK_USE_EXPLICIT_NULL_INIT
{
duk_small_uint_t i;
for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
#if defined(DUK_USE_HEAPPTR16)
res->strtable[i].u.str16 = res->heapptr_null16;
#else
res->strtable[i].u.str = NULL;
#endif
}
}
#endif /* DUK_USE_EXPLICIT_NULL_INIT */
#endif /* DUK_USE_STRTAB_CHAIN */
/*
* Init stringtable: probe variant
*/
#if defined(DUK_USE_STRTAB_PROBE)
#if defined(DUK_USE_HEAPPTR16)
res->strtable16 = (duk_uint16_t *) alloc_func(heap_udata, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
if (!res->strtable16) {
goto error;
}
#else /* DUK_USE_HEAPPTR16 */
res->strtable = (duk_hstring **) alloc_func(heap_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
if (!res->strtable) {
goto error;
}
#endif /* DUK_USE_HEAPPTR16 */
res->st_size = DUK_STRTAB_INITIAL_SIZE;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
{
duk_small_uint_t i;
DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE);
for (i = 0; i < DUK_STRTAB_INITIAL_SIZE; i++) {
#if defined(DUK_USE_HEAPPTR16)
res->strtable16[i] = res->heapptr_null16;
#else
res->strtable[i] = NULL;
#endif
}
}
#else /* DUK_USE_EXPLICIT_NULL_INIT */
#if defined(DUK_USE_HEAPPTR16)
DUK_MEMZERO(res->strtable16, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
#else
DUK_MEMZERO(res->strtable, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
#endif
#endif /* DUK_USE_EXPLICIT_NULL_INIT */
#endif /* DUK_USE_STRTAB_PROBE */
/*
* Init stringcache
*/
#ifdef DUK_USE_EXPLICIT_NULL_INIT
{
duk_small_uint_t i;
for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
res->strcache[i].h = NULL;
}
}
#endif
/* XXX: error handling is incomplete. It would be cleanest if
* there was a setjmp catchpoint, so that all init code could
* freely throw errors. If that were the case, the return code
* passing here could be removed.
*/
/*
* Init built-in strings
*/
DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS"));
if (!duk__init_heap_strings(res)) {
goto error;
}
/*
* Init the heap thread
*/
DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD"));
if (!duk__init_heap_thread(res)) {
goto error;
}
/*
* Init the heap object
*/
DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT"));
DUK_ASSERT(res->heap_thread != NULL);
res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT));
if (!res->heap_object) {
goto error;
}
DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object);
/*
* All done
*/
DUK_D(DUK_DPRINT("allocated heap: %p", (void *) res));
return res;
error:
DUK_D(DUK_DPRINT("heap allocation failed"));
if (res) {
/* assumes that allocated pointers and alloc funcs are valid
* if res exists
*/
DUK_ASSERT(res->alloc_func != NULL);
DUK_ASSERT(res->realloc_func != NULL);
DUK_ASSERT(res->free_func != NULL);
duk_heap_free(res);
}
return NULL;
}
DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_hstring *h) {
#else
DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) {
#endif
duk_uint32_t i;
duk_uint32_t step;
duk_uint32_t hash;
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t null16 = heap->heapptr_null16;
duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
#endif
DUK_ASSERT(size > 0);
hash = DUK_HSTRING_GET_HASH(h);
i = DUK__HASH_INITIAL(hash, size);
step = DUK__HASH_PROBE_STEP(hash);
for (;;) {
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t e16 = entries16[i];
#else
duk_hstring *e = entries[i];
#endif
#if defined(DUK_USE_HEAPPTR16)
if (e16 == null16) {
#else
if (!e) {
#endif
DUK_UNREACHABLE();
break;
}
#if defined(DUK_USE_HEAPPTR16)
if (e16 == h16) {
#else
if (e == h) {
#endif
/* st_used remains the same, DELETED is counted as used */
DUK_DDD(DUK_DDDPRINT("free matching hit: %ld", (long) i));
#if defined(DUK_USE_HEAPPTR16)
entries16[i] = heap->heapptr_deleted16;
#else
entries[i] = DUK__DELETED_MARKER(heap);
#endif
break;
}
DUK_DDD(DUK_DDDPRINT("free matching miss: %ld", (long) i));
i = (i + step) % size;
/* looping should never happen */
DUK_ASSERT(i != DUK__HASH_INITIAL(hash, size));
}
}
DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size) {
#ifdef DUK_USE_MARK_AND_SWEEP
duk_small_uint_t prev_mark_and_sweep_base_flags;
#endif
#ifdef DUK_USE_DEBUG
duk_uint32_t old_used = heap->st_used;
#endif
duk_uint32_t old_size = heap->st_size;
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t *old_entries = heap->strtable16;
duk_uint16_t *new_entries = NULL;
#else
duk_hstring **old_entries = heap->strtable;
duk_hstring **new_entries = NULL;
#endif
duk_uint32_t new_used = 0;
duk_uint32_t i;
#ifdef DUK_USE_DEBUG
DUK_UNREF(old_used); /* unused with some debug level combinations */
#endif
#ifdef DUK_USE_DDDPRINT
DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
(long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
(long) (((double) old_used) / ((double) old_size) * 100.0),
(long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) duk__count_used_probe(heap),
(long) (((double) duk__count_used_probe(heap)) / ((double) new_size) * 100.0)));
#endif
DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used_probe(heap)); /* required for rehash to succeed, equality not that useful */
DUK_ASSERT(old_entries);
#ifdef DUK_USE_MARK_AND_SWEEP
DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0);
#endif
/*
* The attempt to allocate may cause a GC. Such a GC must not attempt to resize
* the stringtable (though it can be swept); finalizer execution and object
* compaction must also be postponed to avoid the pressure to add strings to the
* string table.
*/
#ifdef DUK_USE_MARK_AND_SWEEP
prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
heap->mark_and_sweep_base_flags |= \
DUK_MS_FLAG_NO_STRINGTABLE_RESIZE | /* avoid recursive call here */
DUK_MS_FLAG_NO_FINALIZERS | /* avoid pressure to add/remove strings */
DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid array abandoning which interns strings */
#endif
#if defined(DUK_USE_HEAPPTR16)
new_entries = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * new_size);
#else
new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size);
#endif
#ifdef DUK_USE_MARK_AND_SWEEP
heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
#endif
if (!new_entries) {
goto resize_error;
}
#ifdef DUK_USE_EXPLICIT_NULL_INIT
for (i = 0; i < new_size; i++) {
#if defined(DUK_USE_HEAPPTR16)
new_entries[i] = heap->heapptr_null16;
#else
new_entries[i] = NULL;
#endif
}
#else
#if defined(DUK_USE_HEAPPTR16)
/* Relies on NULL encoding to zero. */
DUK_MEMZERO(new_entries, sizeof(duk_uint16_t) * new_size);
#else
DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size);
#endif
#endif
/* Because new_size > duk__count_used_probe(heap), guaranteed to work */
for (i = 0; i < old_size; i++) {
duk_hstring *e;
#if defined(DUK_USE_HEAPPTR16)
e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, old_entries[i]);
#else
e = old_entries[i];
#endif
if (e == NULL || e == DUK__DELETED_MARKER(heap)) {
continue;
}
/* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */
duk__insert_hstring_probe(heap, new_entries, new_size, &new_used, e);
}
#ifdef DUK_USE_DDPRINT
DUK_DD(DUK_DDPRINT("resized stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
(long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
(long) (((double) old_used) / ((double) old_size) * 100.0),
(long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) new_used,
(long) (((double) new_used) / ((double) new_size) * 100.0)));
#endif
#if defined(DUK_USE_HEAPPTR16)
DUK_FREE(heap, heap->strtable16);
heap->strtable16 = new_entries;
#else
DUK_FREE(heap, heap->strtable);
heap->strtable = new_entries;
#endif
heap->st_size = new_size;
heap->st_used = new_used; /* may be less, since DELETED entries are NULLed by rehash */
return 0; /* OK */
resize_error:
DUK_FREE(heap, new_entries);
return 1; /* FAIL */
}
DUK_LOCAL duk_bool_t duk__resize_strtab_probe(duk_heap *heap) {
duk_uint32_t new_size;
duk_bool_t ret;
new_size = (duk_uint32_t) duk__count_used_probe(heap);
if (new_size >= 0x80000000UL) {
new_size = DUK_STRTAB_HIGHEST_32BIT_PRIME;
} else {
new_size = duk_util_get_hash_prime(DUK_STRTAB_GROW_ST_SIZE(new_size));
new_size = duk_util_get_hash_prime(new_size);
}
DUK_ASSERT(new_size > 0);
/* rehash even if old and new sizes are the same to get rid of
* DELETED entries.
*/
ret = duk__resize_strtab_raw_probe(heap, new_size);
return ret;
}
DUK_LOCAL
duk_hstring *duk__alloc_init_hstring(duk_heap *heap,
const duk_uint8_t *str,
duk_uint32_t blen,
duk_uint32_t strhash,
const duk_uint8_t *extdata) {
duk_hstring *res = NULL;
duk_uint8_t *data;
duk_size_t alloc_size;
duk_uarridx_t dummy;
duk_uint32_t clen;
#if defined(DUK_USE_STRLEN16)
/* If blen <= 0xffffUL, clen is also guaranteed to be <= 0xffffUL. */
if (blen > 0xffffUL) {
DUK_D(DUK_DPRINT("16-bit string blen/clen active and blen over 16 bits, reject intern"));
return NULL;
}
#endif
if (extdata) {
alloc_size = (duk_size_t) sizeof(duk_hstring_external);
res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
if (!res) {
goto alloc_error;
}
DUK_MEMZERO(res, sizeof(duk_hstring_external));
#ifdef DUK_USE_EXPLICIT_NULL_INIT
DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
#endif
DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, DUK_HSTRING_FLAG_EXTDATA);
((duk_hstring_external *) res)->extdata = extdata;
} else {
/* NUL terminate for convenient C access */
alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1);
res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
if (!res) {
goto alloc_error;
}
DUK_MEMZERO(res, sizeof(duk_hstring));
#ifdef DUK_USE_EXPLICIT_NULL_INIT
DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
#endif
DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0);
data = (duk_uint8_t *) (res + 1);
DUK_MEMCPY(data, str, blen);
data[blen] = (duk_uint8_t) 0;
}
if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
DUK_HSTRING_SET_ARRIDX(res);
}
/* All strings beginning with 0xff are treated as "internal",
* even strings interned by the user. This allows user code to
* create internal properties too, and makes behavior consistent
* in case user code happens to use a string also used by Duktape
* (such as string has already been interned and has the 'internal'
* flag set).
*/
if (blen > 0 && str[0] == (duk_uint8_t) 0xff) {
DUK_HSTRING_SET_INTERNAL(res);
}
DUK_HSTRING_SET_HASH(res, strhash);
DUK_HSTRING_SET_BYTELEN(res, blen);
clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen);
DUK_ASSERT(clen <= blen);
DUK_HSTRING_SET_CHARLEN(res, clen);
DUK_DDD(DUK_DDDPRINT("interned string, hash=0x%08lx, blen=%ld, clen=%ld, has_arridx=%ld, has_extdata=%ld",
(unsigned long) DUK_HSTRING_GET_HASH(res),
(long) DUK_HSTRING_GET_BYTELEN(res),
(long) DUK_HSTRING_GET_CHARLEN(res),
(long) (DUK_HSTRING_HAS_ARRIDX(res) ? 1 : 0),
(long) (DUK_HSTRING_HAS_EXTDATA(res) ? 1 : 0)));
return res;
alloc_error:
DUK_FREE(heap, res);
return NULL;
}
DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) {
duk_context *ctx = (duk_context *) thr;
duk_re_compiler_ctx re_ctx;
duk_lexer_point lex_point;
duk_hstring *h_pattern;
duk_hstring *h_flags;
duk__re_disjunction_info ign_disj;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(ctx != NULL);
/*
* Args validation
*/
/* TypeError if fails */
h_pattern = duk_require_hstring(ctx, -2);
h_flags = duk_require_hstring(ctx, -1);
/*
* Create normalized 'source' property (E5 Section 15.10.3).
*/
/* [ ... pattern flags ] */
duk__create_escaped_source(thr, -2);
/* [ ... pattern flags escaped_source ] */
/*
* Init compilation context
*/
/* [ ... pattern flags escaped_source buffer ] */
DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
DUK_LEXER_INITCTX(&re_ctx.lex); /* duplicate zeroing, expect for (possible) NULL inits */
re_ctx.thr = thr;
re_ctx.lex.thr = thr;
re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern);
re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern);
re_ctx.lex.token_limit = DUK_RE_COMPILE_TOKEN_LIMIT;
re_ctx.recursion_limit = DUK_USE_REGEXP_COMPILER_RECLIMIT;
re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags);
DUK_BW_INIT_PUSHBUF(thr, &re_ctx.bw, DUK__RE_INITIAL_BUFSIZE);
DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld",
(unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit));
/*
* Init lexer
*/
lex_point.offset = 0; /* expensive init, just want to fill window */
lex_point.line = 1;
DUK_LEXER_SETPOINT(&re_ctx.lex, &lex_point);
/*
* Compilation
*/
DUK_DD(DUK_DDPRINT("starting regexp compilation"));
duk__append_u32(&re_ctx, DUK_REOP_SAVE);
duk__append_u32(&re_ctx, 0);
duk__parse_disjunction(&re_ctx, 1 /*expect_eof*/, &ign_disj);
duk__append_u32(&re_ctx, DUK_REOP_SAVE);
duk__append_u32(&re_ctx, 1);
duk__append_u32(&re_ctx, DUK_REOP_MATCH);
/*
* Check for invalid backreferences; note that it is NOT an error
* to back-reference a capture group which has not yet been introduced
* in the pattern (as in /\1(foo)/); in fact, the backreference will
* always match! It IS an error to back-reference a capture group
* which will never be introduced in the pattern. Thus, we can check
* for such references only after parsing is complete.
*/
if (re_ctx.highest_backref > re_ctx.captures) {
DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_BACKREFS);
}
/*
* Emit compiled regexp header: flags, ncaptures
* (insertion order inverted on purpose)
*/
duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2);
duk__insert_u32(&re_ctx, 0, re_ctx.re_flags);
/* [ ... pattern flags escaped_source buffer ] */
DUK_BW_COMPACT(thr, &re_ctx.bw);
duk_to_string(ctx, -1); /* coerce to string */
/* [ ... pattern flags escaped_source bytecode ] */
/*
* Finalize stack
*/
duk_remove(ctx, -4); /* -> [ ... flags escaped_source bytecode ] */
duk_remove(ctx, -3); /* -> [ ... escaped_source bytecode ] */
DUK_DD(DUK_DDPRINT("regexp compilation successful, bytecode: %!T, escaped source: %!T",
(duk_tval *) duk_get_tval(ctx, -1), (duk_tval *) duk_get_tval(ctx, -2)));
}
duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
duk_realloc_function realloc_func,
duk_free_function free_func,
void *alloc_udata,
duk_fatal_function fatal_func) {
duk_heap *res = NULL;
DUK_D(DUK_DPRINT("allocate heap"));
/* Debug dump type sizes */
#ifdef DUK_USE_DEBUG
duk__dump_type_sizes();
#endif
/* If selftests enabled, run them as early as possible. */
#ifdef DUK_USE_SELF_TESTS
DUK_D(DUK_DPRINT("running self tests"));
duk_selftest_run_tests();
DUK_D(DUK_DPRINT("self tests passed"));
#endif
#ifdef DUK_USE_COMPUTED_NAN
do {
/* Workaround for some exotic platforms where NAN is missing
* and the expression (0.0 / 0.0) does NOT result in a NaN.
* Such platforms use the global 'duk_computed_nan' which must
* be initialized at runtime. Use 'volatile' to ensure that
* the compiler will actually do the computation and not try
* to do constant folding which might result in the original
* problem.
*/
volatile double dbl1 = 0.0;
volatile double dbl2 = 0.0;
duk_computed_nan = dbl1 / dbl2;
} while (0);
#endif
#ifdef DUK_USE_COMPUTED_INFINITY
do {
/* Similar workaround for INFINITY. */
volatile double dbl1 = 1.0;
volatile double dbl2 = 0.0;
duk_computed_infinity = dbl1 / dbl2;
} while (0);
#endif
/* use a raw call, all macros expect the heap to be initialized */
res = (duk_heap *) alloc_func(alloc_udata, sizeof(duk_heap));
if (!res) {
goto error;
}
/* zero everything */
DUK_MEMZERO(res, sizeof(*res));
/* explicit NULL inits */
#ifdef DUK_USE_EXPLICIT_NULL_INIT
res->alloc_udata = NULL;
res->heap_allocated = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
res->refzero_list = NULL;
res->refzero_list_tail = NULL;
#endif
#ifdef DUK_USE_MARK_AND_SWEEP
res->finalize_list = NULL;
#endif
res->heap_thread = NULL;
res->curr_thread = NULL;
res->heap_object = NULL;
res->log_buffer = NULL;
res->st = NULL;
{
int i;
for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
res->strs[i] = NULL;
}
}
#endif
/* initialize the structure, roughly in order */
res->alloc_func = alloc_func;
res->realloc_func = realloc_func;
res->free_func = free_func;
res->alloc_udata = alloc_udata;
res->fatal_func = fatal_func;
/* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */
res->call_recursion_depth = 0;
res->call_recursion_limit = DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT;
/* FIXME: use the pointer as a seed for now: mix in time at least */
/* cast through C99 intptr_t to avoid GCC warning:
*
* warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
*/
res->hash_seed = (duk_uint32_t) (duk_intptr_t) res;
res->rnd_state = (duk_uint32_t) (duk_intptr_t) res;
#ifdef DUK_USE_INTERRUPT_COUNTER
/* zero value causes an interrupt before executing first instruction */
DUK_ASSERT(res->interrupt_counter == 0);
DUK_ASSERT(res->interrupt_init == 0);
#endif
#ifdef DUK_USE_EXPLICIT_NULL_INIT
res->lj.jmpbuf_ptr = NULL;
#endif
DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN); /* zero */
DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value1);
DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value2);
#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME)
#error initial heap stringtable size is defined incorrectly
#endif
res->st = (duk_hstring **) alloc_func(alloc_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
if (!res->st) {
goto error;
}
res->st_size = DUK_STRTAB_INITIAL_SIZE;
#ifdef DUK_USE_EXPLICIT_NULL_INIT
{
duk_uint_fast32_t i;
for (i = 0; i < res->st_size; i++) {
res->st[i] = NULL;
}
}
#else
DUK_MEMZERO(res->st, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
#endif
/* strcache init */
#ifdef DUK_USE_EXPLICIT_NULL_INIT
{
int i;
for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
res->strcache[i].h = NULL;
}
}
#endif
/* FIXME: error handling is incomplete. It would be cleanest if
* there was a setjmp catchpoint, so that all init code could
* freely throw errors. If that were the case, the return code
* passing here could be removed.
*/
/* built-in strings */
DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS"));
if (!duk__init_heap_strings(res)) {
goto error;
}
/* heap thread */
DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD"));
if (!duk__init_heap_thread(res)) {
goto error;
}
/* heap object */
DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT"));
DUK_ASSERT(res->heap_thread != NULL);
res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT));
if (!res->heap_object) {
goto error;
}
DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object);
/* log buffer */
DUK_DD(DUK_DDPRINT("HEAP: INIT LOG BUFFER"));
res->log_buffer = (duk_hbuffer_dynamic *) duk_hbuffer_alloc(res,
DUK_BI_LOGGER_SHORT_MSG_LIMIT,
1 /*dynamic*/);
if (!res->log_buffer) {
goto error;
}
DUK_HBUFFER_INCREF(res->heap_thread, res->log_buffer);
DUK_D(DUK_DPRINT("allocated heap: %p", res));
return res;
error:
DUK_D(DUK_DPRINT("heap allocation failed"));
if (res) {
/* assumes that allocated pointers and alloc funcs are valid
* if res exists
*/
DUK_ASSERT(res->alloc_func != NULL);
DUK_ASSERT(res->realloc_func != NULL);
DUK_ASSERT(res->free_func != NULL);
duk_heap_free(res);
}
return NULL;
}
/* intern built-in strings from precooked data (genstrings.py) */
static int duk__init_heap_strings(duk_heap *heap) {
duk_bitdecoder_ctx bd_ctx;
duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
int i, j;
DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
bd->data = (const duk_uint8_t *) duk_strings_data;
bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH;
for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN];
duk_hstring *h;
int len;
int mode;
int t;
len = duk_bd_decode(bd, 5);
mode = 32; /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */
for (j = 0; j < len; j++) {
t = duk_bd_decode(bd, 5);
if (t < DUK__BITPACK_LETTER_LIMIT) {
t = t + 'A' + mode;
} else if (t == DUK__BITPACK_UNDERSCORE) {
t = (int) '_';
} else if (t == DUK__BITPACK_FF) {
/* Internal keys are prefixed with 0xFF in the stringtable
* (which makes them invalid UTF-8 on purpose).
*/
t = (int) 0xff;
} else if (t == DUK__BITPACK_SWITCH1) {
t = duk_bd_decode(bd, 5);
DUK_ASSERT(t >= 0 && t <= 25);
t = t + 'A' + (mode ^ 32);
} else if (t == DUK__BITPACK_SWITCH) {
mode = mode ^ 32;
t = duk_bd_decode(bd, 5);
DUK_ASSERT(t >= 0 && t <= 25);
t = t + 'A' + mode;
} else if (t == DUK__BITPACK_SEVENBIT) {
t = duk_bd_decode(bd, 7);
}
tmp[j] = (duk_uint8_t) t;
}
DUK_DDD(DUK_DDDPRINT("intern built-in string %d", i));
h = duk_heap_string_intern(heap, tmp, len);
if (!h) {
goto error;
}
/* special flags */
if (len > 0 && tmp[0] == 0xff) {
DUK_HSTRING_SET_INTERNAL(h);
}
if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) {
DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h);
}
if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) {
DUK_HSTRING_SET_RESERVED_WORD(h);
if (i >= DUK_STRIDX_START_STRICT_RESERVED) {
DUK_HSTRING_SET_STRICT_RESERVED_WORD(h);
}
}
DUK_DDD(DUK_DDDPRINT("interned: %!O", h));
/* The incref macro takes a thread pointer but doesn't use it
* right now.
*/
DUK_HSTRING_INCREF(_never_referenced_, h);
heap->strs[i] = h;
}
return 1;
error:
return 0;
}
/* Allocate a new duk_hbuffer of a certain type and return a pointer to it
* (NULL on error). Write buffer data pointer to 'out_bufdata' (only if
* allocation successful).
*/
DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata) {
duk_hbuffer *res = NULL;
duk_size_t header_size;
duk_size_t alloc_size;
DUK_ASSERT(heap != NULL);
DUK_ASSERT(out_bufdata != NULL);
DUK_DDD(DUK_DDDPRINT("allocate hbuffer"));
/* Size sanity check. Should not be necessary because caller is
* required to check this, but we don't want to cause a segfault
* if the size wraps either in duk_size_t computation or when
* storing the size in a 16-bit field.
*/
if (size > DUK_HBUFFER_MAX_BYTELEN) {
DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size));
return NULL; /* no need to write 'out_bufdata' */
}
if (flags & DUK_BUF_FLAG_EXTERNAL) {
header_size = sizeof(duk_hbuffer_external);
alloc_size = sizeof(duk_hbuffer_external);
} else if (flags & DUK_BUF_FLAG_DYNAMIC) {
header_size = sizeof(duk_hbuffer_dynamic);
alloc_size = sizeof(duk_hbuffer_dynamic);
} else {
header_size = sizeof(duk_hbuffer_fixed);
alloc_size = sizeof(duk_hbuffer_fixed) + size;
DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed)); /* no wrapping */
}
res = (duk_hbuffer *) DUK_ALLOC(heap, alloc_size);
if (DUK_UNLIKELY(res == NULL)) {
goto alloc_error;
}
/* zero everything unless requested not to do so */
#if defined(DUK_USE_ZERO_BUFFER_DATA)
DUK_MEMZERO((void *) res,
(flags & DUK_BUF_FLAG_NOZERO) ? header_size : alloc_size);
#else
DUK_MEMZERO((void *) res, header_size);
#endif
if (flags & DUK_BUF_FLAG_EXTERNAL) {
duk_hbuffer_external *h;
h = (duk_hbuffer_external *) res;
DUK_UNREF(h);
*out_bufdata = NULL;
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
#if defined(DUK_USE_HEAPPTR16)
/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
#else
DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, h, NULL);
#endif
#endif
DUK_ASSERT(DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, h) == NULL);
} else if (flags & DUK_BUF_FLAG_DYNAMIC) {
duk_hbuffer_dynamic *h = (duk_hbuffer_dynamic *) res;
void *ptr;
if (size > 0) {
DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); /* alloc external with size zero */
DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer"));
#if defined(DUK_USE_ZERO_BUFFER_DATA)
ptr = DUK_ALLOC_ZEROED(heap, size);
#else
ptr = DUK_ALLOC(heap, size);
#endif
if (DUK_UNLIKELY(ptr == NULL)) {
/* Because size > 0, NULL check is correct */
goto alloc_error;
}
*out_bufdata = ptr;
DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, ptr);
} else {
*out_bufdata = NULL;
#if defined(DUK_USE_EXPLICIT_NULL_INIT)
#if defined(DUK_USE_HEAPPTR16)
/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
#else
DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, NULL);
#endif
#endif
DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, h) == NULL);
}
} else {
*out_bufdata = (void *) ((duk_hbuffer_fixed *) res + 1);
}
DUK_HBUFFER_SET_SIZE(res, size);
DUK_HEAPHDR_SET_TYPE(&res->hdr, DUK_HTYPE_BUFFER);
if (flags & DUK_BUF_FLAG_DYNAMIC) {
DUK_HBUFFER_SET_DYNAMIC(res);
if (flags & DUK_BUF_FLAG_EXTERNAL) {
DUK_HBUFFER_SET_EXTERNAL(res);
}
} else {
DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL));
}
DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr);
DUK_DDD(DUK_DDDPRINT("allocated hbuffer: %p", (void *) res));
return res;
alloc_error:
DUK_DD(DUK_DDPRINT("hbuffer allocation failed"));
DUK_FREE(heap, res);
return NULL; /* no need to write 'out_bufdata' */
}
/* intern built-in strings from precooked data (genstrings.py) */
DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) {
duk_bitdecoder_ctx bd_ctx;
duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
duk_small_uint_t i, j;
DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
bd->data = (const duk_uint8_t *) duk_strings_data;
bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH;
for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN];
duk_hstring *h;
duk_small_uint_t len;
duk_small_uint_t mode;
duk_small_uint_t t;
len = duk_bd_decode(bd, 5);
mode = 32; /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */
for (j = 0; j < len; j++) {
t = duk_bd_decode(bd, 5);
if (t < DUK__BITPACK_LETTER_LIMIT) {
t = t + DUK_ASC_UC_A + mode;
} else if (t == DUK__BITPACK_UNDERSCORE) {
t = DUK_ASC_UNDERSCORE;
} else if (t == DUK__BITPACK_FF) {
/* Internal keys are prefixed with 0xFF in the stringtable
* (which makes them invalid UTF-8 on purpose).
*/
t = 0xff;
} else if (t == DUK__BITPACK_SWITCH1) {
t = duk_bd_decode(bd, 5);
DUK_ASSERT_DISABLE(t >= 0); /* unsigned */
DUK_ASSERT(t <= 25);
t = t + DUK_ASC_UC_A + (mode ^ 32);
} else if (t == DUK__BITPACK_SWITCH) {
mode = mode ^ 32;
t = duk_bd_decode(bd, 5);
DUK_ASSERT_DISABLE(t >= 0);
DUK_ASSERT(t <= 25);
t = t + DUK_ASC_UC_A + mode;
} else if (t == DUK__BITPACK_SEVENBIT) {
t = duk_bd_decode(bd, 7);
}
tmp[j] = (duk_uint8_t) t;
}
/* No need to length check string: it will never exceed even
* the 16-bit length maximum.
*/
DUK_ASSERT(len <= 0xffffUL);
DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i));
h = duk_heap_string_intern(heap, tmp, len);
if (!h) {
goto error;
}
/* Special flags checks. Since these strings are always
* reachable and a string cannot appear twice in the string
* table, there's no need to check/set these flags elsewhere.
* The 'internal' flag is set by string intern code.
*/
if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) {
DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h);
}
if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) {
DUK_HSTRING_SET_RESERVED_WORD(h);
if (i >= DUK_STRIDX_START_STRICT_RESERVED) {
DUK_HSTRING_SET_STRICT_RESERVED_WORD(h);
}
}
DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h));
/* XXX: The incref macro takes a thread pointer but doesn't
* use it right now.
*/
DUK_HSTRING_INCREF(_never_referenced_, h);
#if defined(DUK_USE_HEAPPTR16)
heap->strs16[i] = DUK_USE_HEAPPTR_ENC16((void *) h);
#else
heap->strs[i] = h;
#endif
}
return 1;
error:
return 0;
}
static int duk__resize_strtab_raw(duk_heap *heap, duk_uint32_t new_size) {
#ifdef DUK_USE_MARK_AND_SWEEP
int prev_mark_and_sweep_base_flags;
#endif
#ifdef DUK_USE_DEBUG
duk_uint32_t old_used = heap->st_used;
#endif
duk_uint32_t old_size = heap->st_size;
duk_hstring **old_entries = heap->st;
duk_hstring **new_entries = NULL;
duk_uint32_t new_used = 0;
duk_uint32_t i;
#ifdef DUK_USE_DEBUG
DUK_UNREF(old_used); /* unused with some debug level combinations */
#endif
#ifdef DUK_USE_DDDPRINT
DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %d entries, %d bytes, %d used, %d%% load -> %d entries, %d bytes, %d used, %d%% load",
(int) old_size, (int) (sizeof(duk_hstring *) * old_size), (int) old_used,
(int) (((double) old_used) / ((double) old_size) * 100.0),
(int) new_size, (int) (sizeof(duk_hstring *) * new_size), (int) duk__count_used(heap),
(int) (((double) duk__count_used(heap)) / ((double) new_size) * 100.0)));
#endif
DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used(heap)); /* required for rehash to succeed, equality not that useful */
DUK_ASSERT(old_entries);
#ifdef DUK_USE_MARK_AND_SWEEP
DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0);
#endif
/*
* The attempt to allocate may cause a GC. Such a GC must not attempt to resize
* the stringtable (though it can be swept); finalizer execution and object
* compaction must also be postponed to avoid the pressure to add strings to the
* string table.
*/
#ifdef DUK_USE_MARK_AND_SWEEP
prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
heap->mark_and_sweep_base_flags |= \
DUK_MS_FLAG_NO_STRINGTABLE_RESIZE | /* avoid recursive call here */
DUK_MS_FLAG_NO_FINALIZERS | /* avoid pressure to add/remove strings */
DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid array abandoning which interns strings */
#endif
new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size);
#ifdef DUK_USE_MARK_AND_SWEEP
heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
#endif
if (!new_entries) {
goto error;
}
#ifdef DUK_USE_EXPLICIT_NULL_INIT
for (i = 0; i < new_size; i++) {
new_entries[i] = NULL;
}
#else
DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size);
#endif
/* Because new_size > duk__count_used(heap), guaranteed to work */
for (i = 0; i < old_size; i++) {
duk_hstring *e;
e = old_entries[i];
if (e == NULL || e == DUK__DELETED_MARKER(heap)) {
continue;
}
/* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */
duk__insert_hstring(heap, new_entries, new_size, &new_used, e);
}
#ifdef DUK_USE_DDPRINT
DUK_DD(DUK_DDPRINT("resized stringtable: %d entries, %d bytes, %d used, %d%% load -> %d entries, %d bytes, %d used, %d%% load",
(int) old_size, (int) (sizeof(duk_hstring *) * old_size), (int) old_used,
(int) (((double) old_used) / ((double) old_size) * 100.0),
(int) new_size, (int) (sizeof(duk_hstring *) * new_size), (int) new_used,
(int) (((double) new_used) / ((double) new_size) * 100.0)));
#endif
DUK_FREE(heap, heap->st);
heap->st = new_entries;
heap->st_size = new_size;
heap->st_used = new_used; /* may be less, since DELETED entries are NULLed by rehash */
return 0; /* OK */
error:
DUK_FREE(heap, new_entries);
return 1; /* FAIL */
}
void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, size_t new_size, size_t new_usable_size) {
size_t new_alloc_size;
void *res;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(buf != NULL);
DUK_ASSERT(new_usable_size >= new_size);
DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
/*
* Maximum size check
*
* XXX: check against usable size?
*/
if (new_size > DUK_HBUFFER_MAX_BYTELEN) {
DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "buffer too long");
}
/*
* Note: use indirect realloc variant just in case mark-and-sweep
* (finalizers) might resize this same buffer during garbage
* collection.
*/
/* FIXME: maybe remove safety NUL term for buffers? */
new_alloc_size = new_usable_size + 1; /* +1 for safety nul term */
res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_alloc_size);
if (res) {
DUK_DDDPRINT("resized dynamic buffer %p:%d:%d -> %p:%d:%d",
buf->curr_alloc, buf->size, buf->usable_size,
res, new_size, new_usable_size);
/*
* The entire allocated buffer area, regardless of actual used size,
* is kept zeroed in resizes for simplicity. If the buffer is grown,
* zero the new part (the safety NUL byte is re-zeroed every time).
* Another policy would be to ensure data is zeroed as the used part
* is extended (with one safety NUL byte) this is much more simple,
* and not a big deal because the spart part is relatively small.
*/
if (new_alloc_size > buf->usable_size) {
/* When new_usable_size == old_usable_size, one byte will
* be rezeroed (the safety NUL byte).
*/
DUK_ASSERT(new_alloc_size - buf->usable_size > 0);
#ifdef DUK_USE_ZERO_BUFFER_DATA
DUK_MEMZERO((void *) ((char *) res + buf->usable_size),
new_alloc_size - buf->usable_size);
#endif
}
buf->size = new_size;
buf->usable_size = new_usable_size;
buf->curr_alloc = res;
} else {
DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to resize buffer from %d:%d to %d:%d",
buf->size, buf->usable_size, new_size, new_usable_size);
}
DUK_ASSERT(res != NULL);
}
void duk_hthread_create_builtin_objects(duk_hthread *thr) {
duk_context *ctx = (duk_context *) thr;
duk_bitdecoder_ctx bd_ctx;
duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
duk_hobject *h;
int i, j;
DUK_DPRINT("INITBUILTINS BEGIN");
DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
bd->data = (const duk_uint8_t *) duk_builtins_data;
bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
/*
* First create all built-in bare objects on the empty valstack.
* During init, their indices will correspond to built-in indices.
*
* Built-ins will be reachable from both valstack and thr->builtins.
*/
/* XXX: there is no need to resize valstack because builtin count
* is much less than the default space; assert for it.
*/
DUK_DDPRINT("create empty built-ins");
DUK_ASSERT_TOP(ctx, 0);
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
int class_num;
int len = -1;
class_num = duk_bd_decode(bd, DUK__CLASS_BITS);
len = duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
int natidx;
int stridx;
int c_nargs;
duk_c_function c_func;
duk_int16_t magic;
DUK_DDDPRINT("len=%d", len);
DUK_ASSERT(len >= 0);
natidx = duk_bd_decode(bd, DUK__NATIDX_BITS);
stridx = duk_bd_decode(bd, DUK__STRIDX_BITS);
c_func = duk_bi_native_functions[natidx];
c_nargs = duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
c_nargs = DUK_VARARGS;
}
/* FIXME: set magic directly here? (it could share the c_nargs arg) */
duk_push_c_function_nospecial(ctx, c_func, c_nargs);
h = duk_require_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
/* Currently all built-in native functions are strict.
* duk_push_c_function() now sets strict flag, so
* assert for it.
*/
DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h));
/* FIXME: function properties */
duk_push_hstring_stridx(ctx, stridx);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
/* Almost all global level Function objects are constructable
* but not all: Function.prototype is a non-constructable,
* callable Function.
*/
if (duk_bd_decode_flag(bd)) {
DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h));
} else {
DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h);
}
/* Cast converts magic to 16-bit signed value */
magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
((duk_hnativefunction *) h)->magic = magic;
} else {
/* FIXME: ARRAY_PART for Array prototype? */
duk_push_object_helper(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE,
-1); /* no prototype or class yet */
h = duk_require_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
}
DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
thr->builtins[i] = h;
DUK_HOBJECT_INCREF(thr, &h->hdr);
if (len >= 0) {
/*
* For top-level objects, 'length' property has the following
* default attributes: non-writable, non-enumerable, non-configurable
* (E5 Section 15).
*
* However, 'length' property for Array.prototype has attributes
* expected of an Array instance which are different: writable,
* non-enumerable, non-configurable (E5 Section 15.4.5.2).
*
* This is currently determined implicitly based on class; there are
* no attribute flags in the init data.
*/
duk_push_int(ctx, len);
duk_def_prop_stridx(ctx,
-2,
DUK_STRIDX_LENGTH,
(class_num == DUK_HOBJECT_CLASS_ARRAY ? /* only Array.prototype matches */
DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE));
}
/* enable special behaviors last */
if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
DUK_HOBJECT_SET_SPECIAL_ARRAY(h);
}
if (class_num == DUK_HOBJECT_CLASS_STRING) {
DUK_HOBJECT_SET_SPECIAL_STRINGOBJ(h);
}
/* some assertions */
DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h));
/* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h));
/* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h)); /* currently, even for Array.prototype */
/* DUK_HOBJECT_FLAG_STRICT varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) || /* all native functions have NEWENV */
DUK_HOBJECT_HAS_NEWENV(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h));
/* DUK_HOBJECT_FLAG_SPECIAL_ARRAY varies */
/* DUK_HOBJECT_FLAG_SPECIAL_STRINGOBJ varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_SPECIAL_ARGUMENTS(h));
DUK_DDDPRINT("created built-in %d, class=%d, length=%d", i, class_num, len);
}
/*
* Then decode the builtins init data (see genbuiltins.py) to
* init objects
*/
DUK_DDPRINT("initialize built-in object properties");
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
unsigned char t;
int num;
DUK_DDDPRINT("initializing built-in object at index %d", i);
h = thr->builtins[i];
t = duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
DUK_DDDPRINT("set internal prototype: built-in %d", (int) t);
DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[t]);
}
t = duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
/* 'prototype' property for all built-in objects (which have it) has attributes:
* [[Writable]] = false,
* [[Enumerable]] = false,
* [[Configurable]] = false
*/
DUK_DDDPRINT("set external prototype: built-in %d", (int) t);
duk_def_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE);
}
t = duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
/* 'constructor' property for all built-in objects (which have it) has attributes:
* [[Writable]] = true,
* [[Enumerable]] = false,
* [[Configurable]] = true
*/
DUK_DDDPRINT("set external constructor: built-in %d", (int) t);
duk_def_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC);
}
/* normal valued properties */
num = duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS);
DUK_DDDPRINT("built-in object %d, %d normal valued properties", i, num);
for (j = 0; j < num; j++) {
int stridx;
int prop_flags;
stridx = duk_bd_decode(bd, DUK__STRIDX_BITS);
/*
* Property attribute defaults are defined in E5 Section 15 (first
* few pages); there is a default for all properties and a special
* default for 'length' properties. Variation from the defaults is
* signaled using a single flag bit in the bitstream.
*/
if (duk_bd_decode_flag(bd)) {
prop_flags = duk_bd_decode(bd, DUK__PROP_FLAGS_BITS);
} else {
if (stridx == DUK_STRIDX_LENGTH) {
prop_flags = DUK_PROPDESC_FLAGS_NONE;
} else {
prop_flags = DUK_PROPDESC_FLAGS_WC;
}
}
t = duk_bd_decode(bd, DUK__PROP_TYPE_BITS);
DUK_DDDPRINT("built-in %d, normal-valued property %d, stridx %d, flags 0x%02x, type %d",
i, j, stridx, prop_flags, (int) t);
switch (t) {
case DUK__PROP_TYPE_DOUBLE: {
duk_double_union du;
int k;
for (k = 0; k < 8; k++) {
/* Encoding endianness must match target memory layout,
* build scripts and genbuiltins.py must ensure this.
*/
du.uc[k] = (duk_uint8_t) duk_bd_decode(bd, 8);
}
duk_push_number(ctx, du.d); /* push operation normalizes NaNs */
break;
}
case DUK__PROP_TYPE_STRING: {
int n;
int k;
char *p;
n = duk_bd_decode(bd, DUK__STRING_LENGTH_BITS);
p = (char *) duk_push_fixed_buffer(ctx, n);
for (k = 0; k < n; k++) {
*p++ = duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
}
duk_to_string(ctx, -1);
break;
}
case DUK__PROP_TYPE_STRIDX: {
int n;
n = duk_bd_decode(bd, DUK__STRIDX_BITS);
DUK_ASSERT(n >= 0 && n < DUK_HEAP_NUM_STRINGS);
duk_push_hstring_stridx(ctx, n);
break;
}
case DUK__PROP_TYPE_BUILTIN: {
int bidx;
bidx = duk_bd_decode(bd, DUK__BIDX_BITS);
DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER);
duk_dup(ctx, bidx);
break;
}
case DUK__PROP_TYPE_UNDEFINED: {
duk_push_undefined(ctx);
break;
}
case DUK__PROP_TYPE_BOOLEAN_TRUE: {
duk_push_true(ctx);
break;
}
case DUK__PROP_TYPE_BOOLEAN_FALSE: {
duk_push_false(ctx);
break;
}
case DUK__PROP_TYPE_ACCESSOR: {
int natidx_getter = duk_bd_decode(bd, DUK__NATIDX_BITS);
int natidx_setter = duk_bd_decode(bd, DUK__NATIDX_BITS);
duk_c_function c_func_getter;
duk_c_function c_func_setter;
/* XXX: this is a bit awkward because there is no exposed helper
* in the API style, only this internal helper.
*/
DUK_DDDPRINT("built-in accessor property: objidx=%d, stridx=%d, getteridx=%d, setteridx=%d, flags=0x%04x",
i, stridx, natidx_getter, natidx_setter, prop_flags);
c_func_getter = duk_bi_native_functions[natidx_getter];
c_func_setter = duk_bi_native_functions[natidx_setter];
duk_push_c_function_noconstruct_nospecial(ctx, c_func_getter, 0); /* always 0 args */
duk_push_c_function_noconstruct_nospecial(ctx, c_func_setter, 1); /* always 1 arg */
/* FIXME: magic for getter/setter? */
prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */
duk_hobject_define_accessor_internal(thr,
duk_require_hobject(ctx, i),
DUK_HTHREAD_GET_STRING(thr, stridx),
duk_require_hobject(ctx, -2),
duk_require_hobject(ctx, -1),
prop_flags);
duk_pop_2(ctx); /* getter and setter, now reachable through object */
goto skip_value;
}
default: {
/* exhaustive */
DUK_UNREACHABLE();
}
}
DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
duk_def_prop_stridx(ctx, i, stridx, prop_flags);
skip_value:
continue; /* avoid empty label at the end of a compound statement */
}
/* native function properties */
num = duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS);
DUK_DDDPRINT("built-in object %d, %d function valued properties", i, num);
for (j = 0; j < num; j++) {
int stridx;
int natidx;
int c_nargs;
int c_length;
duk_int16_t magic;
duk_c_function c_func;
duk_hnativefunction *h_func;
stridx = duk_bd_decode(bd, DUK__STRIDX_BITS);
natidx = duk_bd_decode(bd, DUK__NATIDX_BITS);
c_length = duk_bd_decode(bd, DUK__LENGTH_PROP_BITS);
c_nargs = duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
c_nargs = DUK_VARARGS;
}
c_func = duk_bi_native_functions[natidx];
DUK_DDDPRINT("built-in %d, function-valued property %d, stridx %d, natidx %d, length %d, nargs %d",
i, j, stridx, natidx, c_length, (c_nargs == DUK_VARARGS ? -1 : c_nargs));
/* [ (builtin objects) ] */
duk_push_c_function_noconstruct_nospecial(ctx, c_func, c_nargs);
h_func = duk_require_hnativefunction(ctx, -1);
DUK_UNREF(h_func);
/* Currently all built-in native functions are strict.
* This doesn't matter for many functions, but e.g.
* String.prototype.charAt (and other string functions)
* rely on being strict so that their 'this' binding is
* not automatically coerced.
*/
DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func);
/* No built-in functions are constructable except the top
* level ones (Number, etc).
*/
DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func));
/* FIXME: any way to avoid decoding magic bit; there are quite
* many function properties and relatively few with magic values.
*/
/* Cast converts magic to 16-bit signed value */
magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
h_func->magic = magic;
/* [ (builtin objects) func ] */
duk_push_int(ctx, c_length);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
duk_push_hstring_stridx(ctx, stridx);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
/* FIXME: other properties of function instances; 'arguments', 'caller'. */
DUK_DDPRINT("built-in object %d, function property %d -> %!T", i, j, duk_get_tval(ctx, -1));
/* [ (builtin objects) func ] */
/*
* The default property attributes are correct for all
* function valued properties of built-in objects now.
*/
duk_def_prop_stridx(ctx, i, stridx, DUK_PROPDESC_FLAGS_WC);
/* [ (builtin objects) ] */
}
}
/*
* Special post-tweaks, for cases not covered by the init data format.
*
* - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
* toGMTString is required to have the same Function object as
* toUTCString in E5 Section B.2.6. Note that while Smjs respects
* this, V8 does not (the Function objects are distinct).
*
* - Make DoubleError non-extensible.
*
* - Add info about most important effective compile options to Duktape.
*/
duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING);
duk_def_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC);
h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR);
DUK_ASSERT(h != NULL);
DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
duk_push_string(ctx,
#if defined(DUK_USE_INTEGER_LE)
"l"
#elif defined(DUK_USE_INTEGER_BE)
"b"
#elif defined(DUK_USE_INTEGER_ME) /* integer mixed endian not really used now */
"m"
#else
"?"
#endif
#if defined(DUK_USE_DOUBLE_LE)
"l"
#elif defined(DUK_USE_DOUBLE_BE)
"b"
#elif defined(DUK_USE_DOUBLE_ME)
"m"
#else
"?"
#endif
#if defined(DUK_USE_BYTEORDER_FORCED)
"f"
#endif
" "
#if defined(DUK_USE_PACKED_TVAL)
"p"
#else
"u"
#endif
" "
#if defined(DUK_USE_HOBJECT_LAYOUT_1)
"p1"
#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
"p2"
#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
"p3"
#else
"p?"
#endif
" "
#if defined(DUK_USE_ALIGN_4)
"a4"
#elif defined(DUK_USE_ALIGN_8)
"a8"
#else
"a1"
#endif
" "
DUK_USE_ARCH_STRING);
duk_def_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC);
/*
* InitJS code - Ecmascript code evaluated from a built-in source
* which provides e.g. backward compatibility. User can also provide
* JS code to be evaluated at startup.
*/
#ifdef DUK_USE_INITJS
/* FIXME: compression */
duk_eval_string(ctx, (const char *) duk_initjs_data); /* initjs data is NUL terminated */
duk_pop(ctx);
#endif /* DUK_USE_INITJS */
#ifdef DUK_USE_USER_INITJS
/* FIXME: compression, at least as an option? */
/* FIXME: unused now */
duk_eval_string(ctx, (const char *) DUK_USE_USER_INITJS);
duk_pop(ctx);
#endif /* DUK_USE_USER_INITJS */
/*
* Since built-ins are not often extended, compact them.
*/
DUK_DDPRINT("compact built-ins");
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_hobject_compact_props(thr, thr->builtins[i]);
}
DUK_DPRINT("INITBUILTINS END");
#ifdef DUK_USE_DDEBUG
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
DUK_DDPRINT("built-in object %d after initialization and compacting: %!@iO", i, thr->builtins[i]);
}
#endif
#ifdef DUK_USE_DDDEBUG
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
DUK_DDDPRINT("built-in object %d after initialization and compacting", i);
DUK_DEBUG_DUMP_HOBJECT(thr->builtins[i]);
}
#endif
/*
* Pop built-ins from stack: they are now INCREF'd and
* reachable from the builtins[] array.
*/
duk_pop_n(ctx, DUK_NUM_BUILTINS);
DUK_ASSERT_TOP(ctx, 0);
}
DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) {
duk_context *ctx = (duk_context *) thr;
duk_bitdecoder_ctx bd_ctx;
duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
duk_hobject *h;
duk_small_uint_t i, j;
DUK_D(DUK_DPRINT("INITBUILTINS BEGIN"));
DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
bd->data = (const duk_uint8_t *) duk_builtins_data;
bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
/*
* First create all built-in bare objects on the empty valstack.
* During init, their indices will correspond to built-in indices.
*
* Built-ins will be reachable from both valstack and thr->builtins.
*/
/* XXX: there is no need to resize valstack because builtin count
* is much less than the default space; assert for it.
*/
DUK_DD(DUK_DDPRINT("create empty built-ins"));
DUK_ASSERT_TOP(ctx, 0);
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_small_uint_t class_num;
duk_small_int_t len = -1; /* must be signed */
class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS);
len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
duk_small_uint_t natidx;
duk_small_uint_t stridx;
duk_int_t c_nargs; /* must hold DUK_VARARGS */
duk_c_function c_func;
duk_int16_t magic;
DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len));
DUK_ASSERT(len >= 0);
natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
c_func = duk_bi_native_functions[natidx];
c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
c_nargs = DUK_VARARGS;
}
/* XXX: set magic directly here? (it could share the c_nargs arg) */
duk_push_c_function_noexotic(ctx, c_func, c_nargs);
h = duk_require_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
/* Currently all built-in native functions are strict.
* duk_push_c_function() now sets strict flag, so
* assert for it.
*/
DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h));
/* XXX: function properties */
duk_push_hstring_stridx(ctx, stridx);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
/* Almost all global level Function objects are constructable
* but not all: Function.prototype is a non-constructable,
* callable Function.
*/
if (duk_bd_decode_flag(bd)) {
DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h));
} else {
DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h);
}
/* Cast converts magic to 16-bit signed value */
magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
((duk_hnativefunction *) h)->magic = magic;
} else {
/* XXX: ARRAY_PART for Array prototype? */
duk_push_object_helper(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE,
-1); /* no prototype or class yet */
h = duk_require_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
}
DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
thr->builtins[i] = h;
DUK_HOBJECT_INCREF(thr, &h->hdr);
if (len >= 0) {
/*
* For top-level objects, 'length' property has the following
* default attributes: non-writable, non-enumerable, non-configurable
* (E5 Section 15).
*
* However, 'length' property for Array.prototype has attributes
* expected of an Array instance which are different: writable,
* non-enumerable, non-configurable (E5 Section 15.4.5.2).
*
* This is currently determined implicitly based on class; there are
* no attribute flags in the init data.
*/
duk_push_int(ctx, len);
duk_xdef_prop_stridx(ctx,
-2,
DUK_STRIDX_LENGTH,
(class_num == DUK_HOBJECT_CLASS_ARRAY ? /* only Array.prototype matches */
DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE));
}
/* enable exotic behaviors last */
if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
DUK_HOBJECT_SET_EXOTIC_ARRAY(h);
}
if (class_num == DUK_HOBJECT_CLASS_STRING) {
DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h);
}
/* some assertions */
DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h));
/* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h));
/* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h)); /* currently, even for Array.prototype */
/* DUK_HOBJECT_FLAG_STRICT varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) || /* all native functions have NEWENV */
DUK_HOBJECT_HAS_NEWENV(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h));
/* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */
/* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h));
DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len));
}
/*
* Then decode the builtins init data (see genbuiltins.py) to
* init objects
*/
DUK_DD(DUK_DDPRINT("initialize built-in object properties"));
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_small_uint_t t;
duk_small_uint_t num;
DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i));
h = thr->builtins[i];
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t));
DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[t]);
}
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
/* 'prototype' property for all built-in objects (which have it) has attributes:
* [[Writable]] = false,
* [[Enumerable]] = false,
* [[Configurable]] = false
*/
DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t));
duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE);
}
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
/* 'constructor' property for all built-in objects (which have it) has attributes:
* [[Writable]] = true,
* [[Enumerable]] = false,
* [[Configurable]] = true
*/
DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t));
duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC);
}
/* normal valued properties */
num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS);
DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num));
for (j = 0; j < num; j++) {
duk_small_uint_t stridx;
duk_small_uint_t prop_flags;
stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
/*
* Property attribute defaults are defined in E5 Section 15 (first
* few pages); there is a default for all properties and a special
* default for 'length' properties. Variation from the defaults is
* signaled using a single flag bit in the bitstream.
*/
if (duk_bd_decode_flag(bd)) {
prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS);
} else {
if (stridx == DUK_STRIDX_LENGTH) {
prop_flags = DUK_PROPDESC_FLAGS_NONE;
} else {
prop_flags = DUK_PROPDESC_FLAGS_WC;
}
}
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS);
DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, stridx %ld, flags 0x%02lx, type %ld",
(long) i, (long) j, (long) stridx, (unsigned long) prop_flags, (long) t));
switch (t) {
case DUK__PROP_TYPE_DOUBLE: {
duk_double_union du;
duk_small_uint_t k;
for (k = 0; k < 8; k++) {
/* Encoding endianness must match target memory layout,
* build scripts and genbuiltins.py must ensure this.
*/
du.uc[k] = (duk_uint8_t) duk_bd_decode(bd, 8);
}
duk_push_number(ctx, du.d); /* push operation normalizes NaNs */
break;
}
case DUK__PROP_TYPE_STRING: {
duk_small_uint_t n;
duk_small_uint_t k;
duk_uint8_t *p;
n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRING_LENGTH_BITS);
p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, n);
for (k = 0; k < n; k++) {
*p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
}
duk_to_string(ctx, -1);
break;
}
case DUK__PROP_TYPE_STRIDX: {
duk_small_uint_t n;
n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
DUK_ASSERT_DISABLE(n >= 0); /* unsigned */
DUK_ASSERT(n < DUK_HEAP_NUM_STRINGS);
duk_push_hstring_stridx(ctx, n);
break;
}
case DUK__PROP_TYPE_BUILTIN: {
duk_small_uint_t bidx;
bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER);
duk_dup(ctx, (duk_idx_t) bidx);
break;
}
case DUK__PROP_TYPE_UNDEFINED: {
duk_push_undefined(ctx);
break;
}
case DUK__PROP_TYPE_BOOLEAN_TRUE: {
duk_push_true(ctx);
break;
}
case DUK__PROP_TYPE_BOOLEAN_FALSE: {
duk_push_false(ctx);
break;
}
case DUK__PROP_TYPE_ACCESSOR: {
duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
duk_c_function c_func_getter;
duk_c_function c_func_setter;
/* XXX: this is a bit awkward because there is no exposed helper
* in the API style, only this internal helper.
*/
DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, stridx=%ld, getteridx=%ld, setteridx=%ld, flags=0x%04lx",
(long) i, (long) stridx, (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags));
c_func_getter = duk_bi_native_functions[natidx_getter];
c_func_setter = duk_bi_native_functions[natidx_setter];
duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0); /* always 0 args */
duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1); /* always 1 arg */
/* XXX: magic for getter/setter? */
prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */
duk_hobject_define_accessor_internal(thr,
duk_require_hobject(ctx, i),
DUK_HTHREAD_GET_STRING(thr, stridx),
duk_require_hobject(ctx, -2),
duk_require_hobject(ctx, -1),
prop_flags);
duk_pop_2(ctx); /* getter and setter, now reachable through object */
goto skip_value;
}
default: {
/* exhaustive */
DUK_UNREACHABLE();
}
}
DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
duk_xdef_prop_stridx(ctx, i, stridx, prop_flags);
skip_value:
continue; /* avoid empty label at the end of a compound statement */
}
/* native function properties */
num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS);
DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num));
for (j = 0; j < num; j++) {
duk_small_uint_t stridx;
duk_small_uint_t natidx;
duk_int_t c_nargs; /* must hold DUK_VARARGS */
duk_small_uint_t c_length;
duk_int16_t magic;
duk_c_function c_func;
duk_hnativefunction *h_func;
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
duk_small_int_t lightfunc_eligible;
#endif
stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS);
c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
c_nargs = DUK_VARARGS;
}
c_func = duk_bi_native_functions[natidx];
DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, stridx %ld, natidx %ld, length %ld, nargs %ld",
(long) i, (long) j, (long) stridx, (long) natidx, (long) c_length,
(c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs)));
/* Cast converts magic to 16-bit signed value */
magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
lightfunc_eligible =
((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) &&
(c_length <= DUK_LFUNC_LENGTH_MAX) &&
(magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX);
if (stridx == DUK_STRIDX_EVAL ||
stridx == DUK_STRIDX_YIELD ||
stridx == DUK_STRIDX_RESUME ||
stridx == DUK_STRIDX_REQUIRE) {
/* These functions have trouble working as lightfuncs.
* Some of them have specific asserts and some may have
* additional properties (e.g. 'require.id' may be written).
*/
DUK_D(DUK_DPRINT("reject as lightfunc: stridx=%d, i=%d, j=%d", (int) stridx, (int) i, (int) j));
lightfunc_eligible = 0;
}
if (lightfunc_eligible) {
duk_tval tv_lfunc;
duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs);
duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs);
DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags);
duk_push_tval(ctx, &tv_lfunc);
DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1)));
goto lightfunc_skip;
}
DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic));
#endif /* DUK_USE_LIGHTFUNC_BUILTINS */
/* [ (builtin objects) ] */
duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs);
h_func = duk_require_hnativefunction(ctx, -1);
DUK_UNREF(h_func);
/* Currently all built-in native functions are strict.
* This doesn't matter for many functions, but e.g.
* String.prototype.charAt (and other string functions)
* rely on being strict so that their 'this' binding is
* not automatically coerced.
*/
DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func);
/* No built-in functions are constructable except the top
* level ones (Number, etc).
*/
DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func));
/* XXX: any way to avoid decoding magic bit; there are quite
* many function properties and relatively few with magic values.
*/
h_func->magic = magic;
/* [ (builtin objects) func ] */
duk_push_int(ctx, c_length);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
duk_push_hstring_stridx(ctx, stridx);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
/* XXX: other properties of function instances; 'arguments', 'caller'. */
DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T",
(long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1)));
/* [ (builtin objects) func ] */
/*
* The default property attributes are correct for all
* function valued properties of built-in objects now.
*/
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
lightfunc_skip:
#endif
duk_xdef_prop_stridx(ctx, i, stridx, DUK_PROPDESC_FLAGS_WC);
/* [ (builtin objects) ] */
}
}
/*
* Special post-tweaks, for cases not covered by the init data format.
*
* - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
* toGMTString is required to have the same Function object as
* toUTCString in E5 Section B.2.6. Note that while Smjs respects
* this, V8 does not (the Function objects are distinct).
*
* - Make DoubleError non-extensible.
*
* - Add info about most important effective compile options to Duktape.
*
* - Possibly remove some properties (values or methods) which are not
* desirable with current feature options but are not currently
* conditional in init data.
*/
duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING);
duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC);
h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR);
DUK_ASSERT(h != NULL);
DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY)
DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features"));
(void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW);
#endif
#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF)
DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features"));
(void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW);
#endif
duk_push_string(ctx,
/* Endianness indicator */
#if defined(DUK_USE_INTEGER_LE)
"l"
#elif defined(DUK_USE_INTEGER_BE)
"b"
#elif defined(DUK_USE_INTEGER_ME) /* integer mixed endian not really used now */
"m"
#else
"?"
#endif
#if defined(DUK_USE_DOUBLE_LE)
"l"
#elif defined(DUK_USE_DOUBLE_BE)
"b"
#elif defined(DUK_USE_DOUBLE_ME)
"m"
#else
"?"
#endif
#if defined(DUK_USE_BYTEORDER_FORCED)
"f"
#endif
" "
/* Packed or unpacked tval */
#if defined(DUK_USE_PACKED_TVAL)
"p"
#else
"u"
#endif
#if defined(DUK_USE_FASTINT)
"f"
#endif
" "
/* Low memory options */
#if defined(DUK_USE_STRTAB_CHAIN)
"c" /* chain */
#elif defined(DUK_USE_STRTAB_PROBE)
"p" /* probe */
#else
"?"
#endif
#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16)
"n"
#endif
#if defined(DUK_USE_HEAPPTR16)
"h"
#endif
#if defined(DUK_USE_DATAPTR16)
"d"
#endif
#if defined(DUK_USE_FUNCPTR16)
"f"
#endif
#if defined(DUK_USE_REFCOUNT16)
"R"
#endif
#if defined(DUK_USE_STRHASH16)
"H"
#endif
#if defined(DUK_USE_STRLEN16)
"S"
#endif
#if defined(DUK_USE_BUFLEN16)
"B"
#endif
#if defined(DUK_USE_OBJSIZES16)
"O"
#endif
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
"L"
#endif
" "
/* Object property allocation layout */
#if defined(DUK_USE_HOBJECT_LAYOUT_1)
"p1"
#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
"p2"
#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
"p3"
#else
"p?"
#endif
" "
/* Alignment guarantee */
#if defined(DUK_USE_ALIGN_4)
"a4"
#elif defined(DUK_USE_ALIGN_8)
"a8"
#else
"a1"
#endif
" "
/* Architecture, OS, and compiler strings */
DUK_USE_ARCH_STRING
" "
DUK_USE_OS_STRING
" "
DUK_USE_COMPILER_STRING);
duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC);
/*
* InitJS code - Ecmascript code evaluated from a built-in source
* which provides e.g. backward compatibility. User can also provide
* JS code to be evaluated at startup.
*/
#ifdef DUK_USE_BUILTIN_INITJS
/* XXX: compression */
DUK_DD(DUK_DDPRINT("running built-in initjs"));
duk_eval_string(ctx, (const char *) duk_initjs_data); /* initjs data is NUL terminated */
duk_pop(ctx);
#endif /* DUK_USE_BUILTIN_INITJS */
#ifdef DUK_USE_USER_INITJS
/* XXX: compression (as an option) */
DUK_DD(DUK_DDPRINT("running user initjs"));
duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS);
#endif /* DUK_USE_USER_INITJS */
/*
* Since built-ins are not often extended, compact them.
*/
DUK_DD(DUK_DDPRINT("compact built-ins"));
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_hobject_compact_props(thr, thr->builtins[i]);
}
DUK_D(DUK_DPRINT("INITBUILTINS END"));
#ifdef DUK_USE_DDPRINT
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO",
(long) i, (duk_heaphdr *) thr->builtins[i]));
}
#endif
/*
* Pop built-ins from stack: they are now INCREF'd and
* reachable from the builtins[] array.
*/
duk_pop_n(ctx, DUK_NUM_BUILTINS);
DUK_ASSERT_TOP(ctx, 0);
}
