duktape-1.5.2/src-separate/duk_error_throw.c

Go to the documentation of this file.

/*
 *  Create and throw an Ecmascript error object based on a code and a message.
 *
 *  Used when we throw errors internally.  Ecmascript generated error objects
 *  are created by Ecmascript code, and the throwing is handled by the bytecode
 *  executor.
 */
 
#include "duk_internal.h"
 
/*
 *  Create and throw an error (originating from Duktape internally)
 *
 *  Push an error object on top of the stack, possibly throw augmenting
 *  the error, and finally longjmp.
 *
 *  If an error occurs while we're dealing with the current error, we might
 *  enter an infinite recursion loop.  This is prevented by detecting a
 *  "double fault" through the heap->handling_error flag; the recursion
 *  then stops at the second level.
 */
 
#ifdef DUK_USE_VERBOSE_ERRORS
DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line) {
#else
DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) {
#endif
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t double_error = thr->heap->handling_error;
 
#ifdef DUK_USE_VERBOSE_ERRORS
    DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld, msg=%s, filename=%s, line=%ld",
                       (long) code, (const char *) msg,
                       (const char *) filename, (long) line));
#else
    DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld", (long) code));
#endif
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
 
    thr->heap->handling_error = 1;
 
    if (!double_error) {
        /* Allow headroom for calls during error handling (see GH-191).
         * We allow space for 10 additional recursions, with one extra
         * for, e.g. a print() call at the deepest level.
         */
        DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX);
        thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11;
    }
 
    DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11);  /* just making sure */
 
    /* Sync so that augmentation sees up-to-date activations, NULL
     * thr->ptr_curr_pc so that it's not used if side effects occur
     * in augmentation or longjmp handling.
     */
    duk_hthread_sync_and_null_currpc(thr);
 
    /*
     *  Create and push an error object onto the top of stack.
     *  If a "double error" occurs, use a fixed error instance
     *  to avoid further trouble.
     */
 
    /* XXX: if attempt to push beyond allocated valstack, this double fault
     * handling fails miserably.  We should really write the double error
     * directly to thr->heap->lj.value1 and avoid valstack use entirely.
     */
 
    if (double_error) {
        if (thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
            DUK_D(DUK_DPRINT("double fault detected -> push built-in fixed 'double error' instance"));
            duk_push_hobject_bidx(ctx, DUK_BIDX_DOUBLE_ERROR);
        } else {
            DUK_D(DUK_DPRINT("double fault detected; there is no built-in fixed 'double error' instance "
                             "-> push the error code as a number"));
            duk_push_int(ctx, (duk_int_t) code);
        }
    } else {
        /* Error object is augmented at its creation here. */
        duk_require_stack(ctx, 1);
        /* XXX: unnecessary '%s' formatting here, but cannot use
         * 'msg' as a format string directly.
         */
#ifdef DUK_USE_VERBOSE_ERRORS
        duk_push_error_object_raw(ctx,
                                  code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
                                  filename,
                                  line,
                                  "%s",
                                  (const char *) msg);
#else
        duk_push_error_object_raw(ctx,
                                  code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
                                  NULL,
                                  0,
                                  NULL);
#endif
    }
 
    /*
     *  Augment error (throw time), unless alloc/double error
     */
 
    if (double_error || code == DUK_ERR_ALLOC_ERROR) {
        DUK_D(DUK_DPRINT("alloc or double error: skip throw augmenting to avoid further trouble"));
    } else {
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
        DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT (before throw augment)",
                             (duk_tval *) duk_get_tval(ctx, -1)));
        duk_err_augment_error_throw(thr);
#endif
    }
 
    /*
     *  Finally, longjmp
     */
 
    duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
 
    thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX;  /* reset callstack limit */
    thr->heap->handling_error = 0;
 
    DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT, %!iT (after throw augment)",
                         (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2));
 
    duk_err_longjmp(thr);
    DUK_UNREACHABLE();
}
 
/*
 *  Helper for C function call negative return values.
 */
 
DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc) {
    duk_context *ctx = (duk_context *) thr;
    const char *msg;
    duk_errcode_t code;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(rc < 0);
 
    /* XXX: this generates quite large code - perhaps select the error
     * class based on the code and then just use the error 'name'?
     */
    /* XXX: shared strings */
 
    code = -rc;
 
    switch (rc) {
    case DUK_RET_UNIMPLEMENTED_ERROR:  msg = "unimplemented"; break;
    case DUK_RET_UNSUPPORTED_ERROR:    msg = "unsupported"; break;
    case DUK_RET_INTERNAL_ERROR:       msg = "internal"; break;
    case DUK_RET_ALLOC_ERROR:          msg = "alloc"; break;
    case DUK_RET_ASSERTION_ERROR:      msg = "assertion"; break;
    case DUK_RET_API_ERROR:            msg = "api"; break;
    case DUK_RET_UNCAUGHT_ERROR:       msg = "uncaught"; break;
    case DUK_RET_ERROR:                msg = "error"; break;
    case DUK_RET_EVAL_ERROR:           msg = "eval"; break;
    case DUK_RET_RANGE_ERROR:          msg = "range"; break;
    case DUK_RET_REFERENCE_ERROR:      msg = "reference"; break;
    case DUK_RET_SYNTAX_ERROR:         msg = "syntax"; break;
    case DUK_RET_TYPE_ERROR:           msg = "type"; break;
    case DUK_RET_URI_ERROR:            msg = "uri"; break;
    default:                           msg = "unknown"; break;
    }
 
    DUK_ASSERT(msg != NULL);
 
    /*
     *  The __FILE__ and __LINE__ information is intentionally not used in the
     *  creation of the error object, as it isn't useful in the tracedata.  The
     *  tracedata still contains the function which returned the negative return
     *  code, and having the file/line of this function isn't very useful.
     */
 
    duk_error_raw(ctx, code, NULL, 0, "%s error (rc %ld)", (const char *) msg, (long) rc);
    DUK_UNREACHABLE();
}