duk_error_augment.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
DUK_LOCAL void	duk__err_augment_user (duk_hthread *thr, duk_small_uint_t stridx_cb)
DUK_LOCAL void	duk__add_traceback (duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline)
DUK_LOCAL void	duk__add_compiler_error_line (duk_hthread *thr)
DUK_LOCAL void	duk__err_augment_builtin_create (duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj)
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_INTERNAL void	duk_err_augment_error_throw (duk_hthread *thr)

Function Documentation

duk__add_compiler_error_line()

DUK_LOCAL void duk__add_compiler_error_line

(

duk_hthread *

thr

)

Definition at line 409 of file duktape-1.5.2/src-separate/duk_error_augment.c.

                                                              {
    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)));
}

References duk_hthread::compile_ctx, duk_compiler_ctx::curr_token, DUK_ASSERT, duk_concat(), DUK_DDD, DUK_DDDPRINT, duk_get_prop_stridx(), duk_get_tval(), duk_is_object(), duk_pop(), duk_push_sprintf(), duk_put_prop_stridx(), DUK_STRIDX_MESSAGE, duk_compiler_ctx::h_filename, NULL, and duk_token::start_line.

Referenced by duk__err_augment_builtin_create().

duk__add_traceback()

DUK_LOCAL void duk__add_traceback	(	duk_hthread *	thr,
		duk_hthread *	thr_callstack,
		const char *	c_filename,
		duk_int_t	c_line,
		duk_bool_t	noblame_fileline )

Definition at line 158 of file duktape-1.5.2/src-separate/duk_error_augment.c.

                                                                                                                                                       {
    duk_context *ctx = (duk_context *) thr;
    duk_small_uint_t depth;
    duk_int_t i, i_min;
    duk_uarridx_t arr_idx;
    duk_double_t d;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr_callstack != NULL);
    DUK_ASSERT(ctx != NULL);
 
    /* [ ... error ] */
 
    /*
     *  The traceback format is pretty arcane in an attempt to keep it compact
     *  and cheap to create.  It may change arbitrarily from version to version.
     *  It should be decoded/accessed through version specific accessors only.
     *
     *  See doc/error-objects.rst.
     */
 
    DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk_push_array(ctx);  /* XXX: specify array size, as we know it */
    arr_idx = 0;
 
    /* Compiler SyntaxErrors (and other errors) come first, and are
     * blamed by default (not flagged "noblame").
     */
    if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
        duk_push_hstring(ctx, thr->compile_ctx->h_filename);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
 
        duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);  /* (flags<<32) + (line), flags = 0 */
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
    }
 
    /* Filename/line from C macros (__FILE__, __LINE__) are added as an
     * entry with a special format: (string, number).  The number contains
     * the line and flags.
     */
 
    /* XXX: optimize: allocate an array part to the necessary size (upwards
     * estimate) and fill in the values directly into the array part; finally
     * update 'length'.
     */
 
    /* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype
     * has write-protected array index named properties.  This was seen as DoubleErrors
     * in e.g. some test262 test cases.  Using duk_xdef_prop_index() is better but heavier.
     * The best fix is to fill in the tracedata directly into the array part.  There are
     * no side effect concerns if the array part is allocated directly and only INCREFs
     * happen after that.
     */
 
    /* [ ... error arr ] */
 
    if (c_filename) {
        duk_push_string(ctx, c_filename);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
 
        d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
            (duk_double_t) c_line;
        duk_push_number(ctx, d);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
    }
 
    /* traceback depth doesn't take into account the filename/line
     * special handling above (intentional)
     */
    depth = DUK_USE_TRACEBACK_DEPTH;
    i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
    DUK_ASSERT(i_min >= 0);
 
    /* [ ... error arr ] */
 
    DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX);  /* callstack limits */
    for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
        duk_uint32_t pc;
 
        /*
         *  Note: each API operation potentially resizes the callstack,
         *  so be careful to re-lookup after every operation.  Currently
         *  these is no issue because we don't store a temporary 'act'
         *  pointer at all.  (This would be a non-issue if we operated
         *  directly on the array part.)
         */
 
        /* [... arr] */
 
        DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0);  /* unsigned */
 
        /* Add function object. */
        duk_push_tval(ctx, &(thr_callstack->callstack + i)->tv_func);
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
 
        /* Add a number containing: pc, activation flags.
         *
         * PC points to next instruction, find offending PC.  Note that
         * PC == 0 for native code.
         */
        pc = duk_hthread_get_act_prev_pc(thr_callstack, thr_callstack->callstack + i);
        DUK_ASSERT_DISABLE(pc >= 0);  /* unsigned */
        DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32);  /* assume PC is at most 32 bits and non-negative */
        d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc;
        duk_push_number(ctx, d);  /* -> [... arr num] */
        duk_xdef_prop_index_wec(ctx, -2, arr_idx);
        arr_idx++;
    }
 
    /* XXX: set with duk_hobject_set_length() when tracedata is filled directly */
    duk_push_uint(ctx, (duk_uint_t) arr_idx);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC);
 
    /* [ ... error arr ] */
 
    duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_TRACEDATA);  /* -> [ ... error ] */
}

References duk_hthread::callstack, duk_hthread::callstack_top, duk_hthread::compile_ctx, duk_compiler_ctx::curr_token, depth, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_DDD, DUK_DDDPRINT, DUK_DOUBLE_2TO32, duk_get_tval(), duk_hthread_get_act_prev_pc(), DUK_INT_MAX, DUK_PROPDESC_FLAGS_WC, duk_push_array(), duk_push_hstring(), duk_push_number(), duk_push_string(), duk_push_tval(), duk_push_uint(), DUK_STRIDX_INT_TRACEDATA, DUK_STRIDX_LENGTH, DUK_TB_FLAG_NOBLAME_FILELINE, DUK_USE_TRACEBACK_DEPTH, duk_xdef_prop_index_wec, duk_xdef_prop_stridx(), duk_xdef_prop_stridx_wec, duk_activation::flags, duk_compiler_ctx::h_filename, NULL, and duk_token::start_line.

Referenced by duk__err_augment_builtin_create().

duk__err_augment_builtin_create()

DUK_LOCAL void duk__err_augment_builtin_create	(	duk_hthread *	thr,
		duk_hthread *	thr_callstack,
		const char *	c_filename,
		duk_int_t	c_line,
		duk_small_int_t	noblame_fileline,
		duk_hobject *	obj )

Definition at line 448 of file duktape-1.5.2/src-separate/duk_error_augment.c.

                                                                                                                                                                                           {
    duk_context *ctx = (duk_context *) thr;
#if defined(DUK_USE_ASSERTIONS)
    duk_int_t entry_top;
#endif
 
#if defined(DUK_USE_ASSERTIONS)
    entry_top = duk_get_top(ctx);
#endif
    DUK_ASSERT(obj != NULL);
 
    DUK_UNREF(obj);  /* unreferenced w/o tracebacks */
    DUK_UNREF(ctx);  /* unreferenced w/o asserts */
 
    duk__add_compiler_error_line(thr);
 
#if defined(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_INT_TRACEDATA(thr))) {
        DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it"));
    } else {
        duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline);
    }
#else
    /* Without tracebacks the concrete .fileName and .lineNumber need
     * to be added directly.
     */
    duk__add_fileline(thr, thr_callstack, c_filename, c_line, noblame_fileline);
#endif
 
#if defined(DUK_USE_ASSERTIONS)
    DUK_ASSERT(duk_get_top(ctx) == entry_top);
#endif
}

References duk__add_compiler_error_line(), duk__add_traceback(), DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_get_top(), duk_hobject_hasprop_raw(), DUK_HTHREAD_STRING_INT_TRACEDATA, DUK_UNREF, and NULL.

Referenced by duk_err_augment_error_create().

duk__err_augment_user()

DUK_LOCAL void duk__err_augment_user	(	duk_hthread *	thr,
		duk_small_uint_t	stridx_cb )

Definition at line 62 of file duktape-1.5.2/src-separate/duk_error_augment.c.

                                                                                   {
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_hnd;
    duk_small_uint_t call_flags;
    duk_int_t rc;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT_DISABLE(stridx_cb >= 0);  /* unsigned */
    DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS);
 
    if (DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)) {
        DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore"));
        return;
    }
 
    /*
     *  Check whether or not we have an error handler.
     *
     *  We must be careful of not triggering an error when looking up the
     *  property.  For instance, if the property is a getter, we don't want
     *  to call it, only plain values are allowed.  The value, if it exists,
     *  is not checked.  If the value is not a function, a TypeError happens
     *  when it is called and that error replaces the original one.
     */
 
    DUK_ASSERT_VALSTACK_SPACE(thr, 4);  /* 3 entries actually needed below */
 
    /* [ ... errval ] */
 
    if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) {
        /* When creating built-ins, some of the built-ins may not be set
         * and we want to tolerate that when throwing errors.
         */
        DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring"));
        return;
    }
    tv_hnd = duk_hobject_find_existing_entry_tval_ptr(thr->heap,
                                                      thr->builtins[DUK_BIDX_DUKTAPE],
                                                      DUK_HTHREAD_GET_STRING(thr, stridx_cb));
    if (tv_hnd == NULL) {
        DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T",
                           (duk_tval *) tv_hnd));
        return;
    }
    DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T",
                         (duk_tval *) tv_hnd));
    duk_push_tval(ctx, tv_hnd);
 
    /* [ ... errval errhandler ] */
 
    duk_insert(ctx, -2);  /* -> [ ... errhandler errval ] */
    duk_push_undefined(ctx);
    duk_insert(ctx, -2);  /* -> [ ... errhandler undefined(= this) errval ] */
 
    /* [ ... errhandler undefined errval ] */
 
    /*
     *  DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C
     *  recursion depth limit (and won't increase it either).  This is
     *  dangerous, but useful because it allows the error handler to run
     *  even if the original error is caused by C recursion depth limit.
     *
     *  The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the
     *  duration of the error handler and cleared afterwards.  This flag
     *  prevents the error handler from running recursively.  The flag is
     *  heap level so that the flag properly controls even coroutines
     *  launched by an error handler.  Since the flag is heap level, it is
     *  critical to restore it correctly.
     *
     *  We ignore errors now: a success return and an error value both
     *  replace the original error value.  (This would be easy to change.)
     */
 
    DUK_ASSERT(!DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));  /* since no recursive error handler calls */
    DUK_HEAP_SET_ERRHANDLER_RUNNING(thr->heap);
 
    call_flags = DUK_CALL_FLAG_IGNORE_RECLIMIT;  /* ignore reclimit, not constructor */
 
    rc = duk_handle_call_protected(thr,
                                   1,            /* num args */
                                   call_flags);  /* call_flags */
    DUK_UNREF(rc);  /* no need to check now: both success and error are OK */
 
    DUK_ASSERT(DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));
    DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(thr->heap);
 
    /* [ ... errval ] */
}

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_ASSERT_VALSTACK_SPACE, DUK_BIDX_DUKTAPE, DUK_CALL_FLAG_IGNORE_RECLIMIT, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_handle_call_protected(), DUK_HEAP_CLEAR_ERRHANDLER_RUNNING, DUK_HEAP_HAS_ERRHANDLER_RUNNING, DUK_HEAP_NUM_STRINGS, DUK_HEAP_SET_ERRHANDLER_RUNNING, duk_hobject_find_existing_entry_tval_ptr(), DUK_HTHREAD_GET_STRING, duk_insert(), duk_push_tval(), duk_push_undefined(), DUK_UNREF, duk_hthread::heap, and NULL.

Referenced by duk_err_augment_error_create(), and duk_err_augment_error_throw().

duk_err_augment_error_create()

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 )

Definition at line 505 of file duktape-1.5.2/src-separate/duk_error_augment.c.

                                                                                                                                                                    {
    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
}

References duk_hthread::builtins, duk__err_augment_builtin_create(), duk__err_augment_user(), DUK_ASSERT, DUK_BIDX_ERROR_PROTOTYPE, DUK_DDD, DUK_DDDPRINT, duk_get_hobject(), DUK_HOBJECT_HAS_EXTENSIBLE, duk_hobject_prototype_chain_contains(), DUK_STRIDX_ERR_CREATE, and NULL.

duk_err_augment_error_throw()

DUK_INTERNAL void duk_err_augment_error_throw

(

duk_hthread *

thr

)

Definition at line 562 of file duktape-1.5.2/src-separate/duk_error_augment.c.

                                                                {
#if defined(DUK_USE_ERRTHROW)
    duk__err_augment_user(thr, DUK_STRIDX_ERR_THROW);
#endif  /* DUK_USE_ERRTHROW */
}

References duk__err_augment_user(), and DUK_STRIDX_ERR_THROW.