static void duk__dump_stringtable(duk_heap *heap) {
duk_uint_fast32_t i;
char buf[64+1];
DUK_D(DUK_DPRINT("stringtable %p, used %ld, size %ld, load %ld%%",
(void *) heap->st,
(long) heap->st_used,
(long) heap->st_size,
(long) (((double) heap->st_used) / ((double) heap->st_size) * 100.0)));
for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
duk_hstring *e = heap->st[i];
if (!e) {
DUK_D(DUK_DPRINT(" [%ld]: NULL", (long) i));
} else if (e == DUK_STRTAB_DELETED_MARKER(heap)) {
DUK_D(DUK_DPRINT(" [%ld]: DELETED", (long) i));
} else {
duk__sanitize_snippet(buf, sizeof(buf), e);
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_D(DUK_DPRINT(" [%ld]: %p (flags: 0x%08lx, ref: %ld) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, "
"arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld",
(long) i,
(void *) e,
(unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
(long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) e),
(const char *) buf,
(unsigned long) e->hash,
(long) e->blen,
(long) e->clen,
(long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0)));
#else
DUK_D(DUK_DPRINT(" [%ld]: %p (flags: 0x%08lx) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, "
"arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld",
(long) i,
(void *) e,
(unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
(const char *) buf,
(long) e->hash,
(long) e->blen,
(long) e->clen,
(long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0)));
#endif
}
}
}
static void dump_stringtable(duk_heap *heap) {
duk_uint32_t i;
char buf[64+1];
DUK_DPRINT("stringtable %p, used %d, size %d, load %d%%",
(void *) heap->st,
(int) heap->st_used,
(int) heap->st_size,
(int) (((double) heap->st_used) / ((double) heap->st_size) * 100.0));
for (i = 0; i < heap->st_size; i++) {
duk_hstring *e = heap->st[i];
if (!e) {
DUK_DPRINT(" [%d]: NULL", i);
} else if (e == DUK_STRTAB_DELETED_MARKER(heap)) {
DUK_DPRINT(" [%d]: DELETED", i);
} else {
sanitize_snippet(buf, sizeof(buf), e);
/* FIXME: all string flags not printed now */
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_DPRINT(" [%d]: %p (flags: 0x%08x, ref: %d) '%s', strhash=0x%08x, blen=%d, clen=%d, arridx=%d, internal=%d",
i,
(void *) e,
(int) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
(int) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) e),
buf,
(int) e->hash,
(int) e->blen,
(int) e->clen,
DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0,
DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0);
#else
DUK_DPRINT(" [%d]: %p (flags: 0x%08x) '%s', strhash=0x%08x, blen=%d, clen=%d, arridx=%d, internal=%d",
i,
(void *) e,
(int) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
buf,
(int) e->hash,
(int) e->blen,
(int) e->clen,
DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0,
DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0);
#endif
}
}
}
void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hobject *enum_target;
duk_hobject *curr;
duk_hobject *res;
#if defined(DUK_USE_ES6_PROXY)
duk_hobject *h_proxy_target;
duk_hobject *h_proxy_handler;
duk_hobject *h_trap_result;
#endif
duk_uint_fast32_t i, len; /* used for array, stack, and entry indices */
DUK_ASSERT(ctx != NULL);
DUK_DDD(DUK_DDDPRINT("create enumerator, stack top: %ld", (long) duk_get_top(ctx)));
enum_target = duk_require_hobject(ctx, -1);
DUK_ASSERT(enum_target != NULL);
duk_push_object_internal(ctx);
res = duk_require_hobject(ctx, -1);
DUK_DDD(DUK_DDDPRINT("created internal object"));
/* [enum_target res] */
/* Target must be stored so that we can recheck whether or not
* keys still exist when we enumerate. This is not done if the
* enumeration result comes from a proxy trap as there is no
* real object to check against.
*/
duk_push_hobject(ctx, enum_target);
duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET);
/* Initialize index so that we skip internal control keys. */
duk_push_int(ctx, DUK__ENUM_START_INDEX);
duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT);
/*
* Proxy object handling
*/
#if defined(DUK_USE_ES6_PROXY)
if (DUK_LIKELY((enum_flags & DUK_ENUM_NO_PROXY_BEHAVIOR) != 0)) {
goto skip_proxy;
}
if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
enum_target,
&h_proxy_target,
&h_proxy_handler))) {
goto skip_proxy;
}
DUK_DDD(DUK_DDDPRINT("proxy enumeration"));
duk_push_hobject(ctx, h_proxy_handler);
if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ENUMERATE)) {
/* No need to replace the 'enum_target' value in stack, only the
* enum_target reference. This also ensures that the original
* enum target is reachable, which keeps the proxy and the proxy
* target reachable. We do need to replace the internal _target.
*/
DUK_DDD(DUK_DDDPRINT("no enumerate trap, enumerate proxy target instead"));
DUK_DDD(DUK_DDDPRINT("h_proxy_target=%!O", (duk_heaphdr *) h_proxy_target));
enum_target = h_proxy_target;
duk_push_hobject(ctx, enum_target); /* -> [ ... enum_target res handler undefined target ] */
duk_put_prop_stridx(ctx, -4, DUK_STRIDX_INT_TARGET);
duk_pop_2(ctx); /* -> [ ... enum_target res ] */
goto skip_proxy;
}
/* [ ... enum_target res handler trap ] */
duk_insert(ctx, -2);
duk_push_hobject(ctx, h_proxy_target); /* -> [ ... enum_target res trap handler target ] */
duk_call_method(ctx, 1 /*nargs*/); /* -> [ ... enum_target res trap_result ] */
h_trap_result = duk_require_hobject(ctx, -1);
DUK_UNREF(h_trap_result);
/* Copy trap result keys into the enumerator object. */
len = (duk_uint_fast32_t) duk_get_length(ctx, -1);
for (i = 0; i < len; i++) {
/* XXX: not sure what the correct semantic details are here,
* e.g. handling of missing values (gaps), handling of non-array
* trap results, etc.
*
* For keys, we simply skip non-string keys which seems to be
* consistent with how e.g. Object.keys() will process proxy trap
* results (ES6 draft, Section 19.1.2.14).
*/
if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) {
/* [ ... enum_target res trap_result val ] */
duk_push_true(ctx);
/* [ ... enum_target res trap_result val true ] */
duk_put_prop(ctx, -4);
} else {
duk_pop(ctx);
}
}
/* [ ... enum_target res trap_result ] */
duk_pop(ctx);
duk_remove(ctx, -2);
/* [ ... res ] */
/* The internal _target property is kept pointing to the original
* enumeration target (the proxy object), so that the enumerator
* 'next' operation can read property values if so requested. The
* fact that the _target is a proxy disables key existence check
* during enumeration.
*/
DUK_DDD(DUK_DDDPRINT("proxy enumeration, final res: %!O", (duk_heaphdr *) res));
goto compact_and_return;
skip_proxy:
#endif /* DUK_USE_ES6_PROXY */
curr = enum_target;
while (curr) {
/*
* Virtual properties.
*
* String and buffer indices are virtual and always enumerable,
* 'length' is virtual and non-enumerable. Array and arguments
* object props have special behavior but are concrete.
*/
if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr) ||
DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)) {
/* String and buffer enumeration behavior is identical now,
* so use shared handler.
*/
if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)) {
duk_hstring *h_val;
h_val = duk_hobject_get_internal_value_string(thr->heap, curr);
DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */
len = (duk_uint_fast32_t) DUK_HSTRING_GET_CHARLEN(h_val);
} else {
duk_hbuffer *h_val;
DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr));
h_val = duk_hobject_get_internal_value_buffer(thr->heap, curr);
DUK_ASSERT(h_val != NULL); /* buffer objects must not created without internal value */
len = (duk_uint_fast32_t) DUK_HBUFFER_GET_SIZE(h_val);
}
for (i = 0; i < len; i++) {
duk_hstring *k;
k = duk_heap_string_intern_u32_checked(thr, i);
DUK_ASSERT(k);
duk_push_hstring(ctx, k);
duk_push_true(ctx);
/* [enum_target res key true] */
duk_put_prop(ctx, -3);
/* [enum_target res] */
}
/* 'length' property is not enumerable, but is included if
* non-enumerable properties are requested.
*/
if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
duk_push_true(ctx);
duk_put_prop(ctx, -3);
}
} else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) {
if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
duk_push_true(ctx);
duk_put_prop(ctx, -3);
}
}
/*
* Array part
*
* Note: ordering between array and entry part must match 'abandon array'
* behavior in duk_hobject_props.c: key order after an array is abandoned
* must be the same.
*/
for (i = 0; i < (duk_uint_fast32_t) curr->a_size; i++) {
duk_hstring *k;
duk_tval *tv;
tv = DUK_HOBJECT_A_GET_VALUE_PTR(curr, i);
if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
continue;
}
k = duk_heap_string_intern_u32_checked(thr, i);
DUK_ASSERT(k);
duk_push_hstring(ctx, k);
duk_push_true(ctx);
/* [enum_target res key true] */
duk_put_prop(ctx, -3);
/* [enum_target res] */
}
/*
* Entries part
*/
for (i = 0; i < (duk_uint_fast32_t) curr->e_next; i++) {
duk_hstring *k;
k = DUK_HOBJECT_E_GET_KEY(curr, i);
if (!k) {
continue;
}
if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(curr, i) &&
!(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) {
continue;
}
if (DUK_HSTRING_HAS_INTERNAL(k) &&
!(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) {
continue;
}
if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) &&
(DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) {
continue;
}
DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(curr, i) ||
!DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(curr, i)->v));
duk_push_hstring(ctx, k);
duk_push_true(ctx);
/* [enum_target res key true] */
duk_put_prop(ctx, -3);
/* [enum_target res] */
}
if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) {
break;
}
curr = curr->prototype;
}
/* [enum_target res] */
duk_remove(ctx, -2);
/* [res] */
if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) ==
(DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) {
/*
* Some E5/E5.1 algorithms require that array indices are iterated
* in a strictly ascending order. This is the case for e.g.
* Array.prototype.forEach() and JSON.stringify() PropertyList
* handling.
*
* To ensure this property for arrays with an array part (and
* arbitrary objects too, since e.g. forEach() can be applied
* to an array), the caller can request that we sort the keys
* here.
*/
/* XXX: avoid this at least when enum_target is an Array, it has an
* array part, and no ancestor properties were included? Not worth
* it for JSON, but maybe worth it for forEach().
*/
/* XXX: may need a 'length' filter for forEach()
*/
DUK_DDD(DUK_DDDPRINT("sort array indices by caller request"));
duk__sort_array_indices(res);
}
#if defined(DUK_USE_ES6_PROXY)
compact_and_return:
#endif
/* compact; no need to seal because object is internal */
duk_hobject_compact_props(thr, res);
DUK_DDD(DUK_DDDPRINT("created enumerator object: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
}
void duk_hobject_enumerator_create(duk_context *ctx, int enum_flags) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hobject *target;
duk_hobject *curr;
duk_hobject *res;
DUK_ASSERT(ctx != NULL);
DUK_DDDPRINT("create enumerator, stack top: %d", duk_get_top(ctx));
target = duk_require_hobject(ctx, -1);
DUK_ASSERT(target != NULL);
duk_push_object_internal(ctx);
DUK_DDDPRINT("created internal object");
/* [target res] */
duk_push_hstring_stridx(ctx, DUK_STRIDX_INT_TARGET);
duk_push_hobject(ctx, target);
duk_put_prop(ctx, -3);
/* initialize index so that we skip internal control keys */
duk_push_hstring_stridx(ctx, DUK_STRIDX_INT_NEXT);
duk_push_int(ctx, ENUM_START_INDEX);
duk_put_prop(ctx, -3);
curr = target;
while (curr) {
duk_uint32_t i;
/*
* Virtual properties.
*
* String indices are virtual and always enumerable. String 'length'
* is virtual and non-enumerable. Array and arguments object props
* have special behavior but are concrete.
*/
if (DUK_HOBJECT_HAS_SPECIAL_STRINGOBJ(curr)) {
duk_hstring *h_val;
h_val = duk_hobject_get_internal_value_string(thr->heap, curr);
DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */
/* FIXME: type for 'i' to match string max len (duk_uint32_t) */
for (i = 0; i < DUK_HSTRING_GET_CHARLEN(h_val); i++) {
duk_hstring *k;
k = duk_heap_string_intern_u32_checked(thr, i);
DUK_ASSERT(k);
duk_push_hstring(ctx, k);
duk_push_true(ctx);
/* [target res key true] */
duk_put_prop(ctx, -3);
/* [target res] */
}
/* 'length' property is not enumerable, but is included if
* non-enumerable properties are requested.
*/
if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
duk_push_true(ctx);
duk_put_prop(ctx, -3);
}
}
/*
* Array part
*
* Note: ordering between array and entry part must match 'abandon array'
* behavior in duk_hobject_props.c: key order after an array is abandoned
* must be the same.
*/
for (i = 0; i < curr->a_size; i++) {
duk_hstring *k;
duk_tval *tv;
tv = DUK_HOBJECT_A_GET_VALUE_PTR(curr, i);
if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
continue;
}
k = duk_heap_string_intern_u32_checked(thr, i);
DUK_ASSERT(k);
duk_push_hstring(ctx, k);
duk_push_true(ctx);
/* [target res key true] */
duk_put_prop(ctx, -3);
/* [target res] */
}
/*
* Entries part
*/
for (i = 0; i < curr->e_used; i++) {
duk_hstring *k;
k = DUK_HOBJECT_E_GET_KEY(curr, i);
if (!k) {
continue;
}
if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(curr, i) &&
!(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) {
continue;
}
if (DUK_HSTRING_HAS_INTERNAL(k) &&
!(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) {
continue;
}
if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) &&
(DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) {
continue;
}
DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(curr, i) ||
!DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(curr, i)->v));
duk_push_hstring(ctx, k);
duk_push_true(ctx);
/* [target res key true] */
duk_put_prop(ctx, -3);
/* [target res] */
}
if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) {
break;
}
curr = curr->prototype;
}
/* [target res] */
duk_remove(ctx, -2);
res = duk_require_hobject(ctx, -1);
/* [res] */
if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) ==
(DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) {
/*
* Some E5/E5.1 algorithms require that array indices are iterated
* in a strictly ascending order. This is the case for e.g.
* Array.prototype.forEach() and JSON.stringify() PropertyList
* handling.
*
* To ensure this property for arrays with an array part (and
* arbitrary objects too, since e.g. forEach() can be applied
* to an array), the caller can request that we sort the keys
* here.
*/
/* FIXME: avoid this at least when target is an Array, it has an
* array part, and no ancestor properties were included? Not worth
* it for JSON, but maybe worth it for forEach().
*/
/* FIXME: may need a 'length' filter for forEach()
*/
DUK_DDDPRINT("sort array indices by caller request");
sort_array_indices(res);
}
/* compact; no need to seal because object is internal */
duk_hobject_compact_props(thr, res);
DUK_DDDPRINT("created enumerator object: %!iT", duk_get_tval(ctx, -1));
}
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));
#if defined(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));
#if defined(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;
}
DUK_ASSERT(!DUK_HSTRING_HAS_ARRIDX(res));
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).
*/
DUK_ASSERT(!DUK_HSTRING_HAS_INTERNAL(res));
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);
#if defined(DUK_USE_HSTRING_CLEN)
DUK_HSTRING_SET_CHARLEN(res, clen);
#endif
/* Using an explicit 'ASCII' flag has larger footprint (one call site
* only) but is quite useful for the case when there's no explicit
* 'clen' in duk_hstring.
*/
DUK_ASSERT(!DUK_HSTRING_HAS_ASCII(res));
if (clen == blen) {
DUK_HSTRING_SET_ASCII(res);
}
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;
}
