duk_error_misc.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
DUK_INTERNAL duk_hobject *	duk_error_prototype_from_code (duk_hthread *thr, duk_errcode_t code)
DUK_INTERNAL void	duk_err_setup_heap_ljstate (duk_hthread *thr, duk_small_int_t lj_type)

Function Documentation

duk_err_setup_heap_ljstate()

DUK_INTERNAL void duk_err_setup_heap_ljstate	(	duk_hthread *	thr,
		duk_small_int_t	lj_type )

Definition at line 74 of file duktape-1.5.2/src-separate/duk_error_misc.c.

                                                                                        {
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    /* If something is thrown with the debugger attached and nobody will
     * catch it, execution is paused before the longjmp, turning over
     * control to the debug client.  This allows local state to be examined
     * before the stack is unwound.  Errors are not intercepted when debug
     * message loop is active (e.g. for Eval).
     */
 
    /* XXX: Allow customizing the pause and notify behavior at runtime
     * using debugger runtime flags.  For now the behavior is fixed using
     * config options.
     */
#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
    if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) &&
        !thr->heap->dbg_processing &&
        lj_type == DUK_LJ_TYPE_THROW) {
        duk_context *ctx = (duk_context *) thr;
        duk_bool_t fatal;
        duk_hobject *h_obj;
 
        /* Don't intercept a DoubleError, we may have caused the initial double
         * fault and attempting to intercept it will cause us to be called
         * recursively and exhaust the C stack.
         */
        h_obj = duk_get_hobject(ctx, -1);
        if (h_obj == thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
            DUK_D(DUK_DPRINT("built-in DoubleError instance thrown, not intercepting"));
            goto skip_throw_intercept;
        }
 
        DUK_D(DUK_DPRINT("throw with debugger attached, report to client"));
 
        fatal = !duk__have_active_catcher(thr);
 
#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY)
        /* Report it to the debug client */
        duk_debug_send_throw(thr, fatal);
#endif
 
#if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
        if (fatal) {
            DUK_D(DUK_DPRINT("throw will be fatal, halt before longjmp"));
            duk_debug_halt_execution(thr, 1 /*use_prev_pc*/);
        }
#endif
    }
 
 skip_throw_intercept:
#endif  /* DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT */
#endif  /* DUK_USE_DEBUGGER_SUPPORT */
 
    thr->heap->lj.type = lj_type;
 
    DUK_ASSERT(thr->valstack_top > thr->valstack);
    DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, thr->valstack_top - 1);  /* side effects */
 
    duk_pop((duk_context *) thr);
}

References duk_hthread::builtins, DUK_ASSERT, DUK_BIDX_DOUBLE_ERROR, DUK_D, DUK_DPRINT, duk_get_hobject(), DUK_LJ_TYPE_THROW, duk_pop(), DUK_TVAL_SET_TVAL_UPDREF, fatal(), duk_hthread::heap, duk_heap::lj, duk_ljstate::type, duk_hthread::valstack, duk_hthread::valstack_top, and duk_ljstate::value1.

duk_error_prototype_from_code()

DUK_INTERNAL duk_hobject * duk_error_prototype_from_code	(	duk_hthread *	thr,
		duk_errcode_t	code )

Definition at line 43 of file duktape-1.5.2/src-separate/duk_error_misc.c.

                                                                                              {
    switch (code) {
    case DUK_ERR_EVAL_ERROR:
        return thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE];
    case DUK_ERR_RANGE_ERROR:
        return thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE];
    case DUK_ERR_REFERENCE_ERROR:
        return thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE];
    case DUK_ERR_SYNTAX_ERROR:
        return thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE];
    case DUK_ERR_TYPE_ERROR:
        return thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE];
    case DUK_ERR_URI_ERROR:
        return thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE];
 
    /* XXX: more specific error classes? */
    case DUK_ERR_UNIMPLEMENTED_ERROR:
    case DUK_ERR_INTERNAL_ERROR:
    case DUK_ERR_ALLOC_ERROR:
    case DUK_ERR_ASSERTION_ERROR:
    case DUK_ERR_API_ERROR:
    case DUK_ERR_ERROR:
    default:
        return thr->builtins[DUK_BIDX_ERROR_PROTOTYPE];
    }
}

References duk_hthread::builtins, DUK_BIDX_ERROR_PROTOTYPE, DUK_BIDX_EVAL_ERROR_PROTOTYPE, DUK_BIDX_RANGE_ERROR_PROTOTYPE, DUK_BIDX_REFERENCE_ERROR_PROTOTYPE, DUK_BIDX_SYNTAX_ERROR_PROTOTYPE, DUK_BIDX_TYPE_ERROR_PROTOTYPE, DUK_BIDX_URI_ERROR_PROTOTYPE, DUK_ERR_ALLOC_ERROR, DUK_ERR_API_ERROR, DUK_ERR_ASSERTION_ERROR, DUK_ERR_ERROR, DUK_ERR_EVAL_ERROR, DUK_ERR_INTERNAL_ERROR, DUK_ERR_RANGE_ERROR, DUK_ERR_REFERENCE_ERROR, DUK_ERR_SYNTAX_ERROR, DUK_ERR_TYPE_ERROR, DUK_ERR_UNIMPLEMENTED_ERROR, and DUK_ERR_URI_ERROR.