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
}
duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hobject *h_v;
duk_hobject *h_obj;
DUK_ASSERT_TOP(ctx, 1);
h_v = duk_get_hobject(ctx, 0);
if (!h_v) {
duk_push_false(ctx); /* XXX: tail call: return duk_push_false(ctx) */
return 1;
}
h_obj = duk_push_this_coercible_to_object(ctx);
DUK_ASSERT(h_obj != NULL);
/* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare */
duk_push_boolean(ctx, duk_hobject_prototype_chain_contains(thr, h_v->prototype, h_obj));
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_hthread *thr) {
duk_hobject *h_v;
duk_hobject *h_obj;
DUK_ASSERT_TOP(thr, 1);
h_v = duk_get_hobject(thr, 0);
if (!h_v) {
duk_push_false(thr); /* XXX: tail call: return duk_push_false(thr) */
return 1;
}
h_obj = duk_push_this_coercible_to_object(thr);
DUK_ASSERT(h_obj != NULL);
/* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare.
* Prototype loops should cause an error to be thrown.
*/
duk_push_boolean(thr, duk_hobject_prototype_chain_contains(thr, DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_v), h_obj, 0 /*ignore_loop*/));
return 1;
}
void duk_err_augment_error(duk_hthread *thr, duk_hthread *thr_callstack, int err_index, const char *filename, int line, int noblame_fileline) {
duk_context *ctx = (duk_context *) thr;
duk_hobject *obj;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr_callstack != NULL);
DUK_ASSERT(ctx != NULL);
err_index = duk_require_normalize_index(ctx, err_index);
/*
* Criteria for augmenting:
*
* - augmentation enabled in build (naturally)
* - error value is an extensible object
* - error value internal prototype chain contains the built-in
* Error prototype object (i.e. 'val instanceof Error')
*/
obj = duk_require_hobject(ctx, err_index);
if (!obj) {
DUK_DDDPRINT("error value not an object, not augmented");
return;
}
if (!DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {
DUK_DDDPRINT("error value not extensible, not augmented");
return;
}
if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE])) {
DUK_DDDPRINT("error value not inherited from Error, not augmented");
return;
}
/* Yes, augment error. */
#ifdef DUK_USE_TRACEBACKS
/*
* If tracebacks are enabled, the 'tracedata' property is the only
* thing we need: 'fileName' and 'lineNumber' are virtual properties
* which use 'tracedata'.
*/
if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_TRACEDATA(thr))) {
DUK_DDDPRINT("error value already has a 'traceback' property, not modifying it");
} else {
add_traceback(thr, thr_callstack, obj, err_index, filename, line, noblame_fileline);
}
#else
/*
* If tracebacks are disabled, 'fileName' and 'lineNumber' are added
* as plain own properties. Since Error.prototype has accessors of
* the same name, we need to define own properties directly (cannot
* just use e.g. duk_put_prop_stridx). Existing properties are not
* overwritten in case they already exist.
*/
if (filename && !noblame_fileline) {
/* FIXME: file/line is disabled in minimal builds, so disable this too
* when appropriate.
*/
duk_push_string(ctx, filename);
duk_def_prop_stridx(ctx, err_index, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
duk_push_int(ctx, line);
duk_def_prop_stridx(ctx, err_index, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
} else if (thr_callstack->callstack_top > 0) {
duk_activation *act;
duk_hobject *func;
duk_hbuffer *pc2line;
act = thr_callstack->callstack + thr_callstack->callstack_top - 1;
DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size);
func = act->func;
if (func) {
int pc;
duk_uint32_t line;
/* PC points to next instruction, find offending PC. Note that
* PC == 0 for native code.
*/
pc = act->pc;
if (pc > 0) {
pc--;
}
DUK_ASSERT(pc >= 0 && (double) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */
act = NULL; /* invalidated by pushes, so get out of the way */
duk_push_hobject(ctx, func);
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
duk_def_prop_stridx(ctx, err_index, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
#if 0
duk_push_number(ctx, pc);
duk_def_prop_stridx(ctx, err_index, DUK_STRIDX_PC, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAGS_NO_OVERWRITE);
#endif
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_PC2LINE);
if (duk_is_buffer(ctx, -1)) {
pc2line = duk_get_hbuffer(ctx, -1);
DUK_ASSERT(pc2line != NULL);
DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC(pc2line));
line = duk_hobject_pc2line_query((duk_hbuffer_fixed *) pc2line, (duk_uint_fast32_t) pc);
duk_push_number(ctx, (double) line); /* FIXME: u32 */
duk_def_prop_stridx(ctx, err_index, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
}
duk_pop(ctx);
} else {
/* Native function, no relevant lineNumber. */
}
duk_pop(ctx);
}
}
#endif /* DUK_USE_TRACEBACKS */
}
