自学教程：C++ DUK_DDD函数代码示例

static duk_hstring *duk__find_matching_string(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {	duk_uint32_t i;	duk_uint32_t step;	DUK_ASSERT(size > 0);	i = DUK__HASH_INITIAL(strhash, size);	step = DUK__HASH_PROBE_STEP(strhash);	for (;;) {		duk_hstring *e;		e = entries[i];		if (!e) {			return NULL;		}		if (e != DUK__DELETED_MARKER(heap) && DUK_HSTRING_GET_BYTELEN(e) == blen) {			if (DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e), blen) == 0) {				DUK_DDD(DUK_DDDPRINT("find matching hit: %d (step %d, size %d)", i, step, size));				return e;			}		}		DUK_DDD(DUK_DDDPRINT("find matching miss: %d (step %d, size %d)", i, step, size));		i = (i + step) % size;		/* looping should never happen */		DUK_ASSERT(i != DUK__HASH_INITIAL(strhash, size));	}	DUK_UNREACHABLE();}

static void duk__remove_matching_hstring(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) {	duk_uint32_t i;	duk_uint32_t step;	DUK_ASSERT(size > 0);	i = DUK__HASH_INITIAL(h->hash, size);	step = DUK__HASH_PROBE_STEP(h->hash);	for (;;) {		duk_hstring *e;		e = entries[i];		if (!e) {			DUK_UNREACHABLE();			break;		}		if (e == h) {			/* st_used remains the same, DELETED is counted as used */			DUK_DDD(DUK_DDDPRINT("free matching hit: %d", i));			entries[i] = DUK__DELETED_MARKER(heap);			break;		}		DUK_DDD(DUK_DDDPRINT("free matching miss: %d", i));		i = (i + step) % size;		/* looping should never happen */		DUK_ASSERT(i != DUK__HASH_INITIAL(h->hash, size));	}}

/* Prepare value stack for a method call through an object property. * May currently throw an error e.g. when getting the property. */DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_idx, duk_idx_t nargs) {	DUK_ASSERT_CTX_VALID(ctx);	DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_idx=%ld, nargs=%ld, stacktop=%ld",	                     (long) normalized_obj_idx, (long) nargs, (long) duk_get_top(ctx)));	/* [... key arg1 ... argN] */	/* duplicate key */	duk_dup(ctx, -nargs - 1);  /* Note: -nargs alone would fail for nargs == 0, this is OK */	duk_get_prop(ctx, normalized_obj_idx);	DUK_DDD(DUK_DDDPRINT("func: %!T", (duk_tval *) duk_get_tval(ctx, -1)));	/* [... key arg1 ... argN func] */	duk_replace(ctx, -nargs - 2);	/* [... func arg1 ... argN] */	duk_dup(ctx, normalized_obj_idx);	duk_insert(ctx, -nargs - 1);	/* [... func this arg1 ... argN] */}

DUK_INTERNAL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos) {	duk_uint32_t boff;	const duk_uint8_t *p, *p_start, *p_end;	duk_ucodepoint_t cp;	/* Caller must check character offset to be inside the string. */	DUK_ASSERT(thr != NULL);	DUK_ASSERT(h != NULL);	DUK_ASSERT_DISABLE(pos >= 0);  /* unsigned */	DUK_ASSERT(pos < (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h));	boff = duk_heap_strcache_offset_char2byte(thr, h, (duk_uint32_t) pos);	DUK_DDD(DUK_DDDPRINT("charCodeAt: pos=%ld -> boff=%ld, str=%!O",	                     (long) pos, (long) boff, (duk_heaphdr *) h));	DUK_ASSERT_DISABLE(boff >= 0);	DUK_ASSERT(boff < DUK_HSTRING_GET_BYTELEN(h));	p_start = DUK_HSTRING_GET_DATA(h);	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h);	p = p_start + boff;	DUK_DDD(DUK_DDDPRINT("p_start=%p, p_end=%p, p=%p",	                     (void *) p_start, (void *) p_end, (void *) p));	/* This may throw an error though not for valid E5 strings. */	cp = duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);	return cp;}

static void duk__insert_hstring(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {	duk_uint32_t i;	duk_uint32_t step;	DUK_ASSERT(size > 0);	i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size);	step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(h)); 	for (;;) {		duk_hstring *e;				e = entries[i];		if (e == NULL) {			DUK_DDD(DUK_DDDPRINT("insert hit (null): %d", i));			entries[i] = h;			(*p_used)++;			break;		} else if (e == DUK__DELETED_MARKER(heap)) {			/* st_used remains the same, DELETED is counted as used */			DUK_DDD(DUK_DDDPRINT("insert hit (deleted): %d", i));			entries[i] = h;			break;		}		DUK_DDD(DUK_DDDPRINT("insert miss: %d", i));		i = (i + step) % size;		/* looping should never happen */		DUK_ASSERT(i != DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size));	}}

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_LOCAL void duk__add_compiler_error_line(duk_hthread *thr) {	duk_context *ctx;	/* Append a "(line NNN)" to the "message" property of any error	 * thrown during compilation.  Usually compilation errors are	 * SyntaxErrors but they can also be out-of-memory errors and	 * the like.	 */	/* [ ... error ] */	ctx = (duk_context *) thr;	DUK_ASSERT(duk_is_object(ctx, -1));	if (!(thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL)) {		return;	}	DUK_DDD(DUK_DDDPRINT("compile error, before adding line info: %!T",	                     (duk_tval *) duk_get_tval(ctx, -1)));	if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_MESSAGE)) {		duk_push_sprintf(ctx, " (line %ld)", (long) thr->compile_ctx->curr_token.start_line);		duk_concat(ctx, 2);		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE);	} else {		duk_pop(ctx);	}	DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T",	                     (duk_tval *) duk_get_tval(ctx, -1)));}

DUK_INTERNAL duk_ret_t duk_bi_array_prototype_to_string(duk_context *ctx) {	(void) duk_push_this_coercible_to_object(ctx);	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_JOIN);	/* [ ... this func ] */	if (!duk_is_callable(ctx, -1)) {		/* Fall back to the initial (original) Object.toString().  We don't		 * currently have pointers to the built-in functions, only the top		 * level global objects (like "Array") so this is now done in a bit		 * of a hacky manner.  It would be cleaner to push the (original)		 * function and use duk_call_method().		 */		/* XXX: 'this' will be ToObject() coerced twice, which is incorrect		 * but should have no visible side effects.		 */		DUK_DDD(DUK_DDDPRINT("this.join is not callable, fall back to (original) Object.toString"));		duk_set_top(ctx, 0);		return duk_bi_object_prototype_to_string(ctx);  /* has access to 'this' binding */	}	/* [ ... this func ] */	duk_insert(ctx, -2);	/* [ ... func this ] */	DUK_DDD(DUK_DDDPRINT("calling: func=%!iT, this=%!iT",	                     (duk_tval *) duk_get_tval(ctx, -2),	                     (duk_tval *) duk_get_tval(ctx, -1)));	duk_call_method(ctx, 0);	return 1;}

static duk_double_t duk__push_this_number_plain(duk_context *ctx) {	duk_hobject *h;	/* Number built-in accepts a plain number or a Number object (whose	 * internal value is operated on).  Other types cause TypeError.	 */	duk_push_this(ctx);	if (duk_is_number(ctx, -1)) {		DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));		goto done;	}	h = duk_get_hobject(ctx, -1);	if (!h || 	    (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_NUMBER)) {		DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, "expected a number");	}	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);	DUK_ASSERT(duk_is_number(ctx, -1));	DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T",	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));	duk_remove(ctx, -2); done:	return duk_get_number(ctx, -1);}

DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx, void *udata) {	duk_hthread *thr;	DUK_ASSERT(ctx != NULL);	thr = (duk_hthread *) ctx;	DUK_UNREF(udata);	DUK_DDD(DUK_DDDPRINT("protected finalization helper running"));	/* [... obj] */	/* XXX: Finalizer lookup should traverse the prototype chain (to allow	 * inherited finalizers) but should not invoke accessors or proxy object	 * behavior.  At the moment this lookup will invoke proxy behavior, so	 * caller must ensure that this function is not called if the target is	 * a Proxy.	 */	duk_get_prop_stridx_short(ctx, -1, DUK_STRIDX_INT_FINALIZER);  /* -> [... obj finalizer] */	if (!duk_is_callable(ctx, -1)) {		DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable"));		return 0;	}	duk_dup_m2(ctx);	duk_push_boolean(ctx, DUK_HEAP_HAS_FINALIZER_NORESCUE(thr->heap));	DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer"));	duk_call(ctx, 2);  /* [ ... obj finalizer obj heapDestruct ]  -> [ ... obj retval ] */	DUK_DDD(DUK_DDDPRINT("finalizer finished successfully"));	return 0;	/* Note: we rely on duk_safe_call() to fix up the stack for the caller,	 * so we don't need to pop stuff here.  There is no return value;	 * caller determines rescued status based on object refcount.	 */}

DUK_INTERNAL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj) {	duk_context *ctx = (duk_context *) thr;	duk_ret_t rc;#if defined(DUK_USE_ASSERTIONS)	duk_idx_t entry_top;#endif	DUK_DDD(DUK_DDDPRINT("running object finalizer for object: %p", (void *) obj));	DUK_ASSERT(thr != NULL);	DUK_ASSERT(ctx != NULL);	DUK_ASSERT(obj != NULL);	DUK_ASSERT_VALSTACK_SPACE(thr, 1);#if defined(DUK_USE_ASSERTIONS)	entry_top = duk_get_top(ctx);#endif	/*	 *  Get and call the finalizer.  All of this must be wrapped	 *  in a protected call, because even getting the finalizer	 *  may trigger an error (getter may throw one, for instance).	 */	DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) obj));	if (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) obj)) {		DUK_D(DUK_DPRINT("object already finalized, avoid running finalizer twice: %!O", obj));		return;	}	DUK_HEAPHDR_SET_FINALIZED((duk_heaphdr *) obj);  /* ensure never re-entered until rescue cycle complete */	if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) {		/* This shouldn't happen; call sites should avoid looking up		 * _Finalizer "through" a Proxy, but ignore if we come here		 * with a Proxy to avoid finalizer re-entry.		 */		DUK_D(DUK_DPRINT("object is a proxy, skip finalizer call"));		return;	}	/* XXX: use a NULL error handler for the finalizer call? */	DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling wrapped finalize helper"));	duk_push_hobject(ctx, obj);  /* this also increases refcount by one */	rc = duk_safe_call(ctx, duk__finalize_helper, NULL /*udata*/, 0 /*nargs*/, 1 /*nrets*/);  /* -> [... obj retval/error] */	DUK_ASSERT_TOP(ctx, entry_top + 2);  /* duk_safe_call discipline */	if (rc != DUK_EXEC_SUCCESS) {		/* Note: we ask for one return value from duk_safe_call to get this		 * error debugging here.		 */		DUK_D(DUK_DPRINT("wrapped finalizer call failed for object %p (ignored); error: %!T",		                 (void *) obj, (duk_tval *) duk_get_tval(ctx, -1)));	}	duk_pop_2(ctx);  /* -> [...] */	DUK_ASSERT_TOP(ctx, entry_top);}

DUK_INTERNAL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {	duk_context *ctx = (duk_context *) thr;	duk_hobject *obj;	DUK_ASSERT(thr != NULL);	DUK_ASSERT(thr_callstack != NULL);	DUK_ASSERT(ctx != NULL);	/* [ ... error ] */	/*	 *  Criteria for augmenting:	 *	 *   - augmentation enabled in build (naturally)	 *   - error value internal prototype chain contains the built-in	 *     Error prototype object (i.e. 'val instanceof Error')	 *	 *  Additional criteria for built-in augmenting:	 *	 *   - error value is an extensible object	 */	obj = duk_get_hobject(ctx, -1);	if (!obj) {		DUK_DDD(DUK_DDDPRINT("value is not an object, skip both built-in and user augment"));		return;	}	if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE], 1 /*ignore_loop*/)) {		/* If the value has a prototype loop, it's critical not to		 * throw here.  Instead, assume the value is not to be		 * augmented.		 */		DUK_DDD(DUK_DDDPRINT("value is not an error instance, skip both built-in and user augment"));		return;	}	if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {		DUK_DDD(DUK_DDDPRINT("error meets criteria, built-in augment"));		duk__err_augment_builtin_create(thr, thr_callstack, c_filename, c_line, noblame_fileline, obj);	} else {		DUK_DDD(DUK_DDDPRINT("error does not meet criteria, no built-in augment"));	}	/* [ ... error ] */#if defined(DUK_USE_ERRCREATE)	duk__err_augment_user(thr, DUK_STRIDX_ERR_CREATE);#endif}

/* Debug print which visualizes the qsort partitioning process. */DUK_LOCAL void duk__debuglog_qsort_state(duk_context *ctx, duk_int_t lo, duk_int_t hi, duk_int_t pivot) {	char buf[4096];	char *ptr = buf;	duk_int_t i, n;	n = (duk_int_t) duk_get_length(ctx, 1);	if (n > 4000) {		n = 4000;	}	*ptr++ = '[';	for (i = 0; i < n; i++) {		if (i == pivot) {			*ptr++ = '|';		} else if (i == lo) {			*ptr++ = '<';		} else if (i == hi) {			*ptr++ = '>';		} else if (i >= lo && i <= hi) {			*ptr++ = '-';		} else {			*ptr++ = ' ';		}	}	*ptr++ = ']';	*ptr++ = '/0';	DUK_DDD(DUK_DDDPRINT("%s   (lo=%ld, hi=%ld, pivot=%ld)",	                     (const char *) buf, (long) lo, (long) hi, (long) pivot));}

DUK_INTERNAL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx) {	duk_idx_t nargs;	/* Step 1 is not necessary because duk_call_method() will take	 * care of it.	 */	/* vararg function, thisArg needs special handling */	nargs = duk_get_top(ctx);  /* = 1 + arg count */	if (nargs == 0) {		duk_push_undefined(ctx);		nargs++;	}	DUK_ASSERT(nargs >= 1);	/* [ thisArg arg1 ... argN ] */	duk_push_this(ctx);  /* 'func' in the algorithm */	duk_insert(ctx, 0);	/* [ func thisArg arg1 ... argN ] */	DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argcount=%ld, top=%ld",	                     (duk_tval *) duk_get_tval(ctx, 0),	                     (duk_tval *) duk_get_tval(ctx, 1),	                     (long) (nargs - 1),	                     (long) duk_get_top(ctx)));	duk_call_method(ctx, nargs - 1);	return 1;}

/* Debug print which visualizes the qsort partitioning process. */static void duk__debuglog_qsort_state(duk_context *ctx, int lo, int hi, int pivot) {	char buf[4096];	char *ptr = buf;	int i, n;	n = duk_get_length(ctx, 1);	if (n > 4000) {		n = 4000;	}	*ptr++ = '[';	for (i = 0; i < n; i++) {		if (i == pivot) {			*ptr++ = '|';		} else if (i == lo) {			*ptr++ = '<';		} else if (i == hi) {			*ptr++ = '>';		} else if (i >= lo && i <= hi) {			*ptr++ = '-';		} else {			*ptr++ = ' ';		}	}	*ptr++ = ']';	*ptr++ = '/0';	DUK_DDD(DUK_DDDPRINT("%s   (lo=%d, hi=%d, pivot=%d)", buf, lo, hi, pivot));}

DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx) {	duk_hthread *thr = (duk_hthread *) ctx;	duk_int_t pos;	duk_hstring *h;	duk_bool_t clamped;	/* XXX: faster implementation */	DUK_DDD(DUK_DDDPRINT("arg=%!T", (duk_tval *) duk_get_tval(ctx, 0)));	h = duk_push_this_coercible_to_string(ctx);	DUK_ASSERT(h != NULL);	pos = duk_to_int_clamped_raw(ctx,	                             0 /*index*/,	                             0 /*min(incl)*/,	                             DUK_HSTRING_GET_CHARLEN(h) - 1 /*max(incl)*/,	                             &clamped /*out_clamped*/);	if (clamped) {		duk_push_number(ctx, DUK_DOUBLE_NAN);		return 1;	}	duk_push_u32(ctx, (duk_uint32_t) duk_hstring_char_code_at_raw(thr, h, pos));	return 1;}

DUK_LOCAL void duk__finalize_refcounts(duk_heap *heap) {	duk_hthread *thr;	duk_heaphdr *hdr;	thr = duk__get_temp_hthread(heap);	DUK_ASSERT(thr != NULL);	DUK_DD(DUK_DDPRINT("duk__finalize_refcounts: heap=%p, hthread=%p",	                   (void *) heap, (void *) thr));	hdr = heap->heap_allocated;	while (hdr) {		if (!DUK_HEAPHDR_HAS_REACHABLE(hdr)) {			/*			 *  Unreachable object about to be swept.  Finalize target refcounts			 *  (objects which the unreachable object points to) without doing			 *  refzero processing.  Recursive decrefs are also prevented when			 *  refzero processing is disabled.			 *			 *  Value cannot be a finalizable object, as they have been made			 *  temporarily reachable for this round.			 */			DUK_DDD(DUK_DDDPRINT("unreachable object, refcount finalize before sweeping: %p", (void *) hdr));			duk_heaphdr_refcount_finalize(thr, hdr);		}		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);	}}

/* recursion tracking happens here only */DUK_LOCAL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h) {	DUK_DDD(DUK_DDDPRINT("duk__mark_heaphdr %p, type %ld",	                     (void *) h,	                     (h != NULL ? (long) DUK_HEAPHDR_GET_TYPE(h) : (long) -1)));	if (!h) {		return;	}#if defined(DUK_USE_ROM_OBJECTS)	if (DUK_HEAPHDR_HAS_READONLY(h)) {		DUK_DDD(DUK_DDDPRINT("readonly object %p, skip", (void *) h));		return;	}#endif	if (DUK_HEAPHDR_HAS_REACHABLE(h)) {		DUK_DDD(DUK_DDDPRINT("already marked reachable, skip"));		return;	}	DUK_HEAPHDR_SET_REACHABLE(h);	if (heap->mark_and_sweep_recursion_depth >= DUK_USE_MARK_AND_SWEEP_RECLIMIT) {		/* log this with a normal debug level because this should be relatively rare */		DUK_D(DUK_DPRINT("mark-and-sweep recursion limit reached, marking as temproot: %p", (void *) h));		DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap);		DUK_HEAPHDR_SET_TEMPROOT(h);		return;	}	heap->mark_and_sweep_recursion_depth++;	switch (DUK_HEAPHDR_GET_TYPE(h)) {	case DUK_HTYPE_STRING:		duk__mark_hstring(heap, (duk_hstring *) h);		break;	case DUK_HTYPE_OBJECT:		duk__mark_hobject(heap, (duk_hobject *) h);		break;	case DUK_HTYPE_BUFFER:		/* nothing to mark */		break;	default:		DUK_D(DUK_DPRINT("attempt to mark heaphdr %p with invalid htype %ld", (void *) h, (long) DUK_HEAPHDR_GET_TYPE(h)));		DUK_UNREACHABLE();	}	heap->mark_and_sweep_recursion_depth--;}

static void duk__sweep_stringtable(duk_heap *heap, duk_size_t *out_count_keep) {	duk_hstring *h;	duk_uint_fast32_t i;#ifdef DUK_USE_DEBUG	duk_size_t count_free = 0;#endif	duk_size_t count_keep = 0;	DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap));	for (i = 0; i < heap->st_size; i++) {		h = heap->st[i];		if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {			continue;		} else if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {			DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);			count_keep++;			continue;		}#ifdef DUK_USE_DEBUG		count_free++;#endif#if defined(DUK_USE_REFERENCE_COUNTING)		/* Non-zero refcounts should not happen for unreachable strings,		 * because we refcount finalize all unreachable objects which		 * should have decreased unreachable string refcounts to zero		 * (even for cycles).		 */		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);#endif		DUK_DDD(DUK_DDDPRINT("sweep string, not reachable: %p", (void *) h));		/* deal with weak references first */		duk_heap_strcache_string_remove(heap, (duk_hstring *) h);		/* remove the string (mark DELETED), could also call		 * duk_heap_string_remove() but that would be slow and		 * pointless because we already know the slot.		 */		heap->st[i] = DUK_STRTAB_DELETED_MARKER(heap);		/* then free */#if 1		DUK_FREE(heap, (duk_heaphdr *) h);  /* no inner refs/allocs, just free directly */#else		duk_heap_free_heaphdr_raw(heap, (duk_heaphdr *) h);  /* this would be OK but unnecessary */#endif	}#ifdef DUK_USE_DEBUG	DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %d freed, %d kept",	                 (int) count_free, (int) count_keep));#endif	*out_count_keep = count_keep;}

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_LOCAL void duk__run_object_finalizers(duk_heap *heap, duk_small_uint_t flags) {	duk_heaphdr *curr;	duk_heaphdr *next;#if defined(DUK_USE_DEBUG)	duk_size_t count = 0;#endif	duk_hthread *thr;	DUK_DD(DUK_DDPRINT("duk__run_object_finalizers: %p", (void *) heap));	thr = duk__get_temp_hthread(heap);	DUK_ASSERT(thr != NULL);	curr = heap->finalize_list;	while (curr) {		DUK_DDD(DUK_DDDPRINT("mark-and-sweep finalize: %p", (void *) curr));		DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);  /* only objects have finalizers */		DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));                /* flags have been already cleared */		DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(curr));		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));		DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(curr));  /* No finalizers for ROM objects */		if (DUK_LIKELY((flags & DUK_MS_FLAG_SKIP_FINALIZERS) == 0)) {			/* Run the finalizer, duk_hobject_run_finalizer() sets FINALIZED.			 * Next mark-and-sweep will collect the object unless it has			 * become reachable (i.e. rescued).  FINALIZED prevents the			 * finalizer from being executed again before that.			 */			duk_hobject_run_finalizer(thr, (duk_hobject *) curr);  /* must never longjmp */			DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(curr));		} else {			/* Used during heap destruction: don't actually run finalizers			 * because we're heading into forced finalization.  Instead,			 * queue finalizable objects back to the heap_allocated list.			 */			DUK_D(DUK_DPRINT("skip finalizers flag set, queue object to heap_allocated without finalizing"));			DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));		}		/* queue back to heap_allocated */		next = DUK_HEAPHDR_GET_NEXT(heap, curr);		DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, curr);		curr = next;#if defined(DUK_USE_DEBUG)		count++;#endif	}	/* finalize_list will always be processed completely */	heap->finalize_list = NULL;#if defined(DUK_USE_DEBUG)	DUK_D(DUK_DPRINT("mark-and-sweep finalize objects: %ld finalizers called", (long) count));#endif}

DUK_LOCAL void duk__mark_tval(duk_heap *heap, duk_tval *tv) {	DUK_DDD(DUK_DDDPRINT("duk__mark_tval %p", (void *) tv));	if (!tv) {		return;	}	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {		duk__mark_heaphdr(heap, DUK_TVAL_GET_HEAPHDR(tv));	}}

DUK_LOCAL void duk__mark_hstring(duk_heap *heap, duk_hstring *h) {	DUK_UNREF(heap);	DUK_UNREF(h);	DUK_DDD(DUK_DDDPRINT("duk__mark_hstring: %p", (void *) h));	DUK_ASSERT(h);	/* nothing to process */}

DUK_INTERNAL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h) {	DUK_ASSERT(heap != NULL);	DUK_ASSERT(h != NULL);	if (DUK_HBUFFER_HAS_DYNAMIC(h)) {		duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h;		DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(g)));		DUK_FREE(heap, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(g));	}}

static void duk__free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h) {	DUK_ASSERT(heap != NULL);	DUK_ASSERT(h != NULL);	if (DUK_HBUFFER_HAS_DYNAMIC(h)) {		duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h;		DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", g->curr_alloc));		DUK_FREE(heap, g->curr_alloc);	}}

static void duk__free_markandsweep_finalize_list(duk_heap *heap) {	duk_heaphdr *curr;	duk_heaphdr *next;	curr = heap->finalize_list;	while (curr) {		DUK_DDD(DUK_DDDPRINT("FINALFREE (finalize_list): %!iO", curr));		next = DUK_HEAPHDR_GET_NEXT(curr);		duk_heap_free_heaphdr_raw(heap, curr);		curr = next;	}}

static void duk__free_refzero_list(duk_heap *heap) {	duk_heaphdr *curr;	duk_heaphdr *next;	curr = heap->refzero_list;	while (curr) {		DUK_DDD(DUK_DDDPRINT("FINALFREE (refzero_list): %!iO", curr));		next = DUK_HEAPHDR_GET_NEXT(curr);		duk_heap_free_heaphdr_raw(heap, curr);		curr = next;	}}

DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start, duk_size_t *p_count_check, duk_size_t *p_count_compact, duk_size_t *p_count_bytes_saved) {#elseDUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start) {#endif	duk_heaphdr *curr;#if defined(DUK_USE_DEBUG)	duk_size_t old_size, new_size;#endif	duk_hobject *obj;	DUK_UNREF(heap);	curr = start;	while (curr) {		DUK_DDD(DUK_DDDPRINT("mark-and-sweep compact: %p", (void *) curr));		if (DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_OBJECT) {			goto next;		}		obj = (duk_hobject *) curr;#if defined(DUK_USE_DEBUG)		old_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),		                                      DUK_HOBJECT_GET_ASIZE(obj),		                                      DUK_HOBJECT_GET_HSIZE(obj));#endif		DUK_DD(DUK_DDPRINT("compact object: %p", (void *) obj));		duk_push_hobject((duk_context *) thr, obj);		/* XXX: disable error handlers for duration of compaction? */		duk_safe_call((duk_context *) thr, duk__protected_compact_object, NULL, 1, 0);#if defined(DUK_USE_DEBUG)		new_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),		                                      DUK_HOBJECT_GET_ASIZE(obj),		                                      DUK_HOBJECT_GET_HSIZE(obj));#endif#if defined(DUK_USE_DEBUG)		(*p_count_compact)++;		(*p_count_bytes_saved) += (duk_size_t) (old_size - new_size);#endif	 next:		curr = DUK_HEAPHDR_GET_NEXT(heap, curr);#if defined(DUK_USE_DEBUG)		(*p_count_check)++;#endif	}}

DUK_INTERNAL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h) {	DUK_ASSERT(heap != NULL);	DUK_ASSERT(h != NULL);	DUK_UNREF(heap);	DUK_UNREF(h);#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_FREE)	if (DUK_HSTRING_HAS_EXTDATA(h)) {		DUK_DDD(DUK_DDDPRINT("free extstr: hstring %!O, extdata: %p",		                     h, DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h)));		DUK_USE_EXTSTR_FREE((const void *) DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h));	}#endif}

DUK_INTERNAL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx) {	duk_idx_t len;	duk_idx_t i;	DUK_ASSERT_TOP(ctx, 2);  /* not a vararg function */	duk_push_this(ctx);	if (!duk_is_callable(ctx, -1)) {		DUK_DDD(DUK_DDDPRINT("func is not callable"));		goto type_error;	}	duk_insert(ctx, 0);	DUK_ASSERT_TOP(ctx, 3);	DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argArray=%!iT",	                     (duk_tval *) duk_get_tval(ctx, 0),	                     (duk_tval *) duk_get_tval(ctx, 1),	                     (duk_tval *) duk_get_tval(ctx, 2)));	/* [ func thisArg argArray ] */	if (duk_is_null_or_undefined(ctx, 2)) {		DUK_DDD(DUK_DDDPRINT("argArray is null/undefined, no args"));		len = 0;	} else if (!duk_is_object(ctx, 2)) {		goto type_error;	} else {		DUK_DDD(DUK_DDDPRINT("argArray is an object"));		/* XXX: make this an internal helper */		duk_get_prop_stridx(ctx, 2, DUK_STRIDX_LENGTH);		len = (duk_idx_t) duk_to_uint32(ctx, -1);  /* ToUint32() coercion required */		duk_pop(ctx);		duk_require_stack(ctx, len);		DUK_DDD(DUK_DDDPRINT("argArray length is %ld", (long) len));		for (i = 0; i < len; i++) {			duk_get_prop_index(ctx, 2, i);		}	}	duk_remove(ctx, 2);	DUK_ASSERT_TOP(ctx, 2 + len);	/* [ func thisArg arg1 ... argN ] */	DUK_DDD(DUK_DDDPRINT("apply, func=%!iT, thisArg=%!iT, len=%ld",	                     (duk_tval *) duk_get_tval(ctx, 0),	                     (duk_tval *) duk_get_tval(ctx, 1),	                     (long) len));	duk_call_method(ctx, len);	return 1; type_error:	return DUK_RET_TYPE_ERROR;}