duk_bi_error.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Macros
#define	DUK__OUTPUT_TYPE_TRACEBACK   (-1)
#define	DUK__OUTPUT_TYPE_FILENAME   0
#define	DUK__OUTPUT_TYPE_LINENUMBER   1

Functions
DUK_INTERNAL duk_ret_t	duk_bi_error_constructor_shared (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_to_string (duk_context *ctx)
DUK_LOCAL duk_ret_t	duk__error_getter_helper (duk_context *ctx, duk_small_int_t output_type)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_stack_getter (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_filename_getter (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_linenumber_getter (duk_context *ctx)
DUK_LOCAL duk_ret_t	duk__error_setter_helper (duk_context *ctx, duk_small_uint_t stridx_key)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_stack_setter (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_filename_setter (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_error_prototype_linenumber_setter (duk_context *ctx)

Macro Definition Documentation

DUK__OUTPUT_TYPE_FILENAME

#define DUK__OUTPUT_TYPE_FILENAME   0

Definition at line 114 of file duktape-1.5.2/src-separate/duk_bi_error.c.

Referenced by duk__error_getter_helper(), and duk_bi_error_prototype_filename_getter().

DUK__OUTPUT_TYPE_LINENUMBER

#define DUK__OUTPUT_TYPE_LINENUMBER   1

Definition at line 115 of file duktape-1.5.2/src-separate/duk_bi_error.c.

Referenced by duk__error_getter_helper(), and duk_bi_error_prototype_linenumber_getter().

DUK__OUTPUT_TYPE_TRACEBACK

#define DUK__OUTPUT_TYPE_TRACEBACK   (-1)

Definition at line 113 of file duktape-1.5.2/src-separate/duk_bi_error.c.

Referenced by duk__error_getter_helper(), and duk_bi_error_prototype_stack_getter().

Function Documentation

duk__error_getter_helper()

DUK_LOCAL duk_ret_t duk__error_getter_helper	(	duk_context *	ctx,
		duk_small_int_t	output_type )

Definition at line 117 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t idx_td;
    duk_small_int_t i;  /* traceback depth fits into 16 bits */
    duk_small_int_t t;  /* stack type fits into 16 bits */
    duk_small_int_t count_func = 0;  /* traceback depth ensures fits into 16 bits */
    const char *str_tailcall = " tailcall";
    const char *str_strict = " strict";
    const char *str_construct = " construct";
    const char *str_prevyield = " preventsyield";
    const char *str_directeval = " directeval";
    const char *str_empty = "";
 
    DUK_ASSERT_TOP(ctx, 0);  /* fixed arg count */
    DUK_UNREF(thr);
 
    duk_push_this(ctx);
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TRACEDATA);
    idx_td = duk_get_top_index(ctx);
 
    duk_push_hstring_stridx(ctx, DUK_STRIDX_NEWLINE_4SPACE);
    duk_push_this(ctx);
 
    /* [ ... this tracedata sep this ] */
 
    /* XXX: skip null filename? */
 
    if (duk_check_type(ctx, idx_td, DUK_TYPE_OBJECT)) {
        /* Current tracedata contains 2 entries per callstack entry. */
        for (i = 0; ; i += 2) {
            duk_int_t pc;
            duk_int_t line;
            duk_int_t flags;
            duk_double_t d;
            const char *funcname;
            const char *filename;
            duk_hobject *h_func;
            duk_hstring *h_name;
 
            duk_require_stack(ctx, 5);
            duk_get_prop_index(ctx, idx_td, i);
            duk_get_prop_index(ctx, idx_td, i + 1);
            d = duk_to_number(ctx, -1);
            pc = (duk_int_t) DUK_FMOD(d, DUK_DOUBLE_2TO32);
            flags = (duk_int_t) DUK_FLOOR(d / DUK_DOUBLE_2TO32);
            t = (duk_small_int_t) duk_get_type(ctx, -2);
 
            if (t == DUK_TYPE_OBJECT || t == DUK_TYPE_LIGHTFUNC) {
                /*
                 *  Ecmascript/native function call or lightfunc call
                 */
 
                count_func++;
 
                /* [ ... v1(func) v2(pc+flags) ] */
 
                h_func = duk_get_hobject(ctx, -2);  /* NULL for lightfunc */
 
                duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
                duk_get_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME);
 
#if defined(DUK_USE_PC2LINE)
                line = duk_hobject_pc2line_query(ctx, -4, (duk_uint_fast32_t) pc);
#else
                line = 0;
#endif
 
                /* [ ... v1 v2 name filename ] */
 
                /* When looking for .fileName/.lineNumber, blame first
                 * function which has a .fileName.
                 */
                if (duk_is_string(ctx, -1)) {
                    if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
                        return 1;
                    } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
                        duk_push_int(ctx, line);
                        return 1;
                    }
                }
 
                /* XXX: Change 'anon' handling here too, to use empty string for anonymous functions? */
                /* XXX: Could be improved by coercing to a readable duk_tval (especially string escaping) */
                h_name = duk_get_hstring(ctx, -2);  /* may be NULL */
                funcname = (h_name == NULL || h_name == DUK_HTHREAD_STRING_EMPTY_STRING(thr)) ?
                           "[anon]" : (const char *) DUK_HSTRING_GET_DATA(h_name);
                filename = duk_get_string(ctx, -1);
                filename = filename ? filename : "";
                DUK_ASSERT(funcname != NULL);
                DUK_ASSERT(filename != NULL);
 
                if (h_func == NULL) {
                    duk_push_sprintf(ctx, "at %s light%s%s%s%s%s",
                                     (const char *) funcname,
                                     (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
                } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h_func)) {
                    duk_push_sprintf(ctx, "at %s (%s) native%s%s%s%s%s",
                                     (const char *) funcname,
                                     (const char *) filename,
                                     (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
                } else {
                    duk_push_sprintf(ctx, "at %s (%s:%ld)%s%s%s%s%s",
                                     (const char *) funcname,
                                     (const char *) filename,
                                     (long) line,
                                     (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcall : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
                                     (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
                }
                duk_replace(ctx, -5);   /* [ ... v1 v2 name filename str ] -> [ ... str v2 name filename ] */
                duk_pop_n(ctx, 3);      /* -> [ ... str ] */
            } else if (t == DUK_TYPE_STRING) {
                /*
                 *  __FILE__ / __LINE__ entry, here 'pc' is line number directly.
                 *  Sometimes __FILE__ / __LINE__ is reported as the source for
                 *  the error (fileName, lineNumber), sometimes not.
                 */
 
                /* [ ... v1(filename) v2(line+flags) ] */
 
                /* When looking for .fileName/.lineNumber, blame compilation
                 * or C call site unless flagged not to do so.
                 */
                if (!(flags & DUK_TB_FLAG_NOBLAME_FILELINE)) {
                    if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
                        duk_pop(ctx);
                        return 1;
                    } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
                        duk_push_int(ctx, pc);
                        return 1;
                    }
                }
 
                duk_push_sprintf(ctx, "at [anon] (%s:%ld) internal",
                                 (const char *) duk_get_string(ctx, -2), (long) pc);
                duk_replace(ctx, -3);  /* [ ... v1 v2 str ] -> [ ... str v2 ] */
                duk_pop(ctx);          /* -> [ ... str ] */
            } else {
                /* unknown, ignore */
                duk_pop_2(ctx);
                break;
            }
        }
 
        if (count_func >= DUK_USE_TRACEBACK_DEPTH) {
            /* Possibly truncated; there is no explicit truncation
             * marker so this is the best we can do.
             */
 
            duk_push_hstring_stridx(ctx, DUK_STRIDX_BRACKETED_ELLIPSIS);
        }
    }
 
    /* [ ... this tracedata sep this str1 ... strN ] */
 
    if (output_type != DUK__OUTPUT_TYPE_TRACEBACK) {
        return 0;
    } else {
        /* The 'this' after 'sep' will get ToString() coerced by
         * duk_join() automatically.  We don't want to do that
         * coercion when providing .fileName or .lineNumber (GH-254).
         */
        duk_join(ctx, duk_get_top(ctx) - (idx_td + 2) /*count, not including sep*/);
        return 1;
    }
}

References DUK__OUTPUT_TYPE_FILENAME, DUK__OUTPUT_TYPE_LINENUMBER, DUK__OUTPUT_TYPE_TRACEBACK, DUK_ACT_FLAG_CONSTRUCT, DUK_ACT_FLAG_DIRECT_EVAL, DUK_ACT_FLAG_PREVENT_YIELD, DUK_ACT_FLAG_STRICT, DUK_ACT_FLAG_TAILCALLED, DUK_ASSERT, DUK_ASSERT_TOP, duk_check_type(), DUK_DOUBLE_2TO32, DUK_FLOOR, DUK_FMOD, duk_get_hobject(), duk_get_hstring(), duk_get_prop_index(), duk_get_prop_stridx(), duk_get_string(), duk_get_top(), duk_get_top_index(), duk_get_type(), DUK_HOBJECT_HAS_NATIVEFUNCTION, duk_hobject_pc2line_query(), DUK_HSTRING_GET_DATA, DUK_HTHREAD_STRING_EMPTY_STRING, duk_is_string(), duk_join(), duk_pop(), duk_pop_2(), duk_pop_n(), duk_push_hstring_stridx(), duk_push_int(), duk_push_sprintf(), duk_push_this(), duk_replace(), duk_require_stack(), DUK_STRIDX_BRACKETED_ELLIPSIS, DUK_STRIDX_FILE_NAME, DUK_STRIDX_INT_TRACEDATA, DUK_STRIDX_NAME, DUK_STRIDX_NEWLINE_4SPACE, DUK_TB_FLAG_NOBLAME_FILELINE, duk_to_number(), DUK_TYPE_LIGHTFUNC, DUK_TYPE_OBJECT, DUK_TYPE_STRING, DUK_UNREF, DUK_USE_TRACEBACK_DEPTH, funcname(), and NULL.

Referenced by duk_bi_error_prototype_filename_getter(), duk_bi_error_prototype_linenumber_getter(), and duk_bi_error_prototype_stack_getter().

duk__error_setter_helper()

DUK_LOCAL duk_ret_t duk__error_setter_helper	(	duk_context *	ctx,
		duk_small_uint_t	stridx_key )

Definition at line 347 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                                            {
    /* Attempt to write 'stack', 'fileName', 'lineNumber' works as if
     * user code called Object.defineProperty() to create an overriding
     * own property.  This allows user code to overwrite .fileName etc
     * intuitively as e.g. "err.fileName = 'dummy'" as one might expect.
     * See https://github.com/svaarala/duktape/issues/387.
     */
 
    DUK_ASSERT_TOP(ctx, 1);  /* fixed arg count: value */
 
    duk_push_this(ctx);
    duk_push_hstring_stridx(ctx, (duk_small_int_t) stridx_key);
    duk_dup(ctx, 0);
 
    /* [ ... obj key value ] */
 
    DUK_DD(DUK_DDPRINT("error setter: %!T %!T %!T",
                       duk_get_tval(ctx, -3), duk_get_tval(ctx, -2), duk_get_tval(ctx, -1)));
 
    duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE |
                          DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE |
                          DUK_DEFPROP_HAVE_ENUMERABLE | /*not enumerable*/
                          DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE);
    return 0;
}

References DUK_ASSERT_TOP, DUK_DD, DUK_DDPRINT, duk_def_prop(), DUK_DEFPROP_CONFIGURABLE, DUK_DEFPROP_HAVE_CONFIGURABLE, DUK_DEFPROP_HAVE_ENUMERABLE, DUK_DEFPROP_HAVE_VALUE, DUK_DEFPROP_HAVE_WRITABLE, DUK_DEFPROP_WRITABLE, duk_dup(), duk_get_tval(), duk_push_hstring_stridx(), and duk_push_this().

Referenced by duk_bi_error_prototype_filename_setter(), duk_bi_error_prototype_linenumber_setter(), and duk_bi_error_prototype_stack_setter().

duk_bi_error_constructor_shared()

DUK_INTERNAL duk_ret_t duk_bi_error_constructor_shared

(

duk_context *

ctx

)

Definition at line 7 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                         {
    /* Behavior for constructor and non-constructor call is
     * the same except for augmenting the created error.  When
     * called as a constructor, the caller (duk_new()) will handle
     * augmentation; when called as normal function, we need to do
     * it here.
     */
 
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_int_t bidx_prototype = duk_get_current_magic(ctx);
 
    /* same for both error and each subclass like TypeError */
    duk_uint_t flags_and_class = DUK_HOBJECT_FLAG_EXTENSIBLE |
                                 DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR);
 
    DUK_UNREF(thr);
 
    duk_push_object_helper(ctx, flags_and_class, bidx_prototype);
 
    /* If message is undefined, the own property 'message' is not set at
     * all to save property space.  An empty message is inherited anyway.
     */
    if (!duk_is_undefined(ctx, 0)) {
        duk_to_string(ctx, 0);
        duk_dup(ctx, 0);  /* [ message error message ] */
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
    }
 
    /* Augment the error if called as a normal function.  __FILE__ and __LINE__
     * are not desirable in this case.
     */
 
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
    if (!duk_is_constructor_call(ctx)) {
        duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/);
    }
#endif
 
    return 1;
}

References duk_dup(), duk_err_augment_error_create(), duk_get_current_magic(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_ERROR, DUK_HOBJECT_FLAG_EXTENSIBLE, duk_is_constructor_call(), duk_is_undefined(), DUK_PROPDESC_FLAGS_WC, duk_push_object_helper(), DUK_STRIDX_MESSAGE, duk_to_string(), DUK_UNREF, duk_xdef_prop_stridx(), and NULL.

duk_bi_error_prototype_filename_getter()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter

(

duk_context *

ctx

)

Definition at line 302 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                                {
    return duk__error_getter_helper(ctx, DUK__OUTPUT_TYPE_FILENAME);
}

References duk__error_getter_helper(), and DUK__OUTPUT_TYPE_FILENAME.

duk_bi_error_prototype_filename_setter()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_setter

(

duk_context *

ctx

)

Definition at line 377 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                                {
    return duk__error_setter_helper(ctx, DUK_STRIDX_FILE_NAME);
}

References duk__error_setter_helper(), and DUK_STRIDX_FILE_NAME.

duk_bi_error_prototype_linenumber_getter()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter

(

duk_context *

ctx

)

Definition at line 306 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                                  {
    return duk__error_getter_helper(ctx, DUK__OUTPUT_TYPE_LINENUMBER);
}

References duk__error_getter_helper(), and DUK__OUTPUT_TYPE_LINENUMBER.

duk_bi_error_prototype_linenumber_setter()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_setter

(

duk_context *

ctx

)

Definition at line 381 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                                  {
    return duk__error_setter_helper(ctx, DUK_STRIDX_LINE_NUMBER);
}

References duk__error_setter_helper(), and DUK_STRIDX_LINE_NUMBER.

duk_bi_error_prototype_stack_getter()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter

(

duk_context *

ctx

)

Definition at line 298 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                             {
    return duk__error_getter_helper(ctx, DUK__OUTPUT_TYPE_TRACEBACK);
}

References duk__error_getter_helper(), and DUK__OUTPUT_TYPE_TRACEBACK.

duk_bi_error_prototype_stack_setter()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_setter

(

duk_context *

ctx

)

Definition at line 373 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                             {
    return duk__error_setter_helper(ctx, DUK_STRIDX_STACK);
}

References duk__error_setter_helper(), and DUK_STRIDX_STACK.

duk_bi_error_prototype_to_string()

DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string

(

duk_context *

ctx

)

Definition at line 48 of file duktape-1.5.2/src-separate/duk_bi_error.c.

                                                                          {
    /* XXX: optimize with more direct internal access */
 
    duk_push_this(ctx);
    (void) duk_require_hobject_or_lfunc_coerce(ctx, -1);
 
    /* [ ... this ] */
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
    if (duk_is_undefined(ctx, -1)) {
        duk_pop(ctx);
        duk_push_string(ctx, "Error");
    } else {
        duk_to_string(ctx, -1);
    }
 
    /* [ ... this name ] */
 
    /* XXX: Are steps 6 and 7 in E5 Section 15.11.4.4 duplicated by
     * accident or are they actually needed?  The first ToString()
     * could conceivably return 'undefined'.
     */
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE);
    if (duk_is_undefined(ctx, -1)) {
        duk_pop(ctx);
        duk_push_string(ctx, "");
    } else {
        duk_to_string(ctx, -1);
    }
 
    /* [ ... this name message ] */
 
    if (duk_get_length(ctx, -2) == 0) {
        /* name is empty -> return message */
        return 1;
    }
    if (duk_get_length(ctx, -1) == 0) {
        /* message is empty -> return name */
        duk_pop(ctx);
        return 1;
    }
    duk_push_string(ctx, ": ");
    duk_insert(ctx, -2);  /* ... name ': ' message */
    duk_concat(ctx, 3);
 
    return 1;
}

References duk_concat(), duk_get_length(), duk_get_prop_stridx(), duk_insert(), duk_is_undefined(), duk_pop(), duk_push_string(), duk_push_this(), duk_require_hobject_or_lfunc_coerce(), DUK_STRIDX_MESSAGE, DUK_STRIDX_NAME, and duk_to_string().