import 12.2.13 release

[ceph.git] / ceph / src / civetweb / src / third_party / duktape-1.8.0 / src-separate / duk_error_augment.c

/*
 *  Augmenting errors at their creation site and their throw site.
 *
 *  When errors are created, traceback data is added by built-in code
 *  and a user error handler (if defined) can process or replace the
 *  error.  Similarly, when errors are thrown, a user error handler
 *  (if defined) can process or replace the error.
 *
 *  Augmentation and other processing at error creation time is nice
 *  because an error is only created once, but it may be thrown and
 *  rethrown multiple times.  User error handler registered for processing
 *  an error at its throw site must be careful to handle rethrowing in
 *  a useful manner.
 *
 *  Error augmentation may throw an internal error (e.g. alloc error).
 *
 *  Ecmascript allows throwing any values, so all values cannot be
 *  augmented.  Currently, the built-in augmentation at error creation
 *  only augments error values which are Error instances (= have the
 *  built-in Error.prototype in their prototype chain) and are also
 *  extensible.  User error handlers have no limitations in this respect.
 */

#include "duk_internal.h"

/*
 *  Helper for calling a user error handler.
 *
 *  'thr' must be the currently active thread; the error handler is called
 *  in its context.  The valstack of 'thr' must have the error value on
 *  top, and will be replaced by another error value based on the return
 *  value of the error handler.
 *
 *  The helper calls duk_handle_call() recursively in protected mode.
 *  Before that call happens, no longjmps should happen; as a consequence,
 *  we must assume that the valstack contains enough temporary space for
 *  arguments and such.
 *
 *  While the error handler runs, any errors thrown will not trigger a
 *  recursive error handler call (this is implemented using a heap level
 *  flag which will "follow" through any coroutines resumed inside the
 *  error handler).  If the error handler is not callable or throws an
 *  error, the resulting error replaces the original error (for Duktape
 *  internal errors, duk_error_throw.c further substitutes this error with
 *  a DoubleError which is not ideal).  This would be easy to change and
 *  even signal to the caller.
 *
 *  The user error handler is stored in 'Duktape.errCreate' or
 *  'Duktape.errThrow' depending on whether we're augmenting the error at
 *  creation or throw time.  There are several alternatives to this approach,
 *  see doc/error-objects.rst for discussion.
 *
 *  Note: since further longjmp()s may occur while calling the error handler
 *  (for many reasons, e.g. a labeled 'break' inside the handler), the
 *  caller can make no assumptions on the thr->heap->lj state after the
 *  call (this affects especially duk_error_throw.c).  This is not an issue
 *  as long as the caller writes to the lj state only after the error handler
 *  finishes.
 */

#if defined(DUK_USE_ERRTHROW) || defined(DUK_USE_ERRCREATE)
DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb) {
        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 ] */
}
#endif  /* DUK_USE_ERRTHROW || DUK_USE_ERRCREATE */

/*
 *  Add ._Tracedata to an error on the stack top.
 */

#if defined(DUK_USE_TRACEBACKS)
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_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 ] */
}
#endif  /* DUK_USE_TRACEBACKS */

/*
 *  Add .fileName and .lineNumber to an error on the stack top.
 */

#if !defined(DUK_USE_TRACEBACKS)
DUK_LOCAL void duk__add_fileline(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
        duk_context *ctx;
#if defined(DUK_USE_ASSERTIONS)
        duk_int_t entry_top;
#endif

        ctx = (duk_context *) thr;
#if defined(DUK_USE_ASSERTIONS)
        entry_top = duk_get_top(ctx);
#endif

        /*
         *  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 (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
                /* Compiler SyntaxError (or other error) gets the primary blame.
                 * Currently no flag to prevent blaming.
                 */
                duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);
                duk_push_hstring(ctx, thr->compile_ctx->h_filename);
        } else if (c_filename && !noblame_fileline) {
                /* C call site gets blamed next, unless flagged not to do so.
                 * XXX: file/line is disabled in minimal builds, so disable this
                 * too when appropriate.
                 */
                duk_push_int(ctx, c_line);
                duk_push_string(ctx, c_filename);
        } else {
                /* Finally, blame the innermost callstack entry which has a
                 * .fileName property.
                 */
                duk_small_uint_t depth;
                duk_int_t i, i_min;
                duk_uint32_t ecma_line;

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

                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_activation *act;
                        duk_hobject *func;
                        duk_uint32_t pc;

                        DUK_UNREF(pc);
                        act = thr_callstack->callstack + i;
                        DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size);

                        func = DUK_ACT_GET_FUNC(act);
                        if (func == NULL) {
                                /* Lightfunc, not blamed now. */
                                continue;
                        }

                        /* PC points to next instruction, find offending PC,
                         * PC == 0 for native code.
                         */
                        pc = duk_hthread_get_act_prev_pc(thr, act);  /* thr argument only used for thr->heap, so specific thread doesn't matter */
                        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 */
                        act = NULL;  /* invalidated by pushes, so get out of the way */

                        duk_push_hobject(ctx, func);

                        /* [ ... error func ] */

                        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
                        if (!duk_is_string(ctx, -1)) {
                                duk_pop_2(ctx);
                                continue;
                        }

                        /* [ ... error func fileName ] */

                        ecma_line = 0;
#if defined(DUK_USE_PC2LINE)
                        if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
                                ecma_line = duk_hobject_pc2line_query(ctx, -2, (duk_uint_fast32_t) pc);
                        } else {
                                /* Native function, no relevant lineNumber. */
                        }
#endif  /* DUK_USE_PC2LINE */
                        duk_push_u32(ctx, ecma_line);

                        /* [ ... error func fileName lineNumber ] */

                        duk_replace(ctx, -3);

                        /* [ ... error lineNumber fileName ] */
                        goto define_props;
                }

                /* No activation matches, use undefined for both .fileName and
                 * .lineNumber (matches what we do with a _Tracedata based
                 * no-match lookup.
                 */
                duk_push_undefined(ctx);
                duk_push_undefined(ctx);
        }

 define_props:
        /* [ ... error lineNumber fileName ] */
#if defined(DUK_USE_ASSERTIONS)
        DUK_ASSERT(duk_get_top(ctx) == entry_top + 2);
#endif
        duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
}
#endif  /* !DUK_USE_TRACEBACKS */

/*
 *  Add line number to a compiler error.
 */

DUK_LOCAL void duk__add_compiler_error_line(duk_hthread *thr) {
        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)));
}

/*
 *  Augment an error being created using Duktape specific properties
 *  like _Tracedata or .fileName/.lineNumber.
 */

#if defined(DUK_USE_AUGMENT_ERROR_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) {
        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
}
#endif  /* DUK_USE_AUGMENT_ERROR_CREATE */

/*
 *  Augment an error at creation time with _Tracedata/fileName/lineNumber
 *  and allow a user error handler (if defined) to process/replace the error.
 *  The error to be augmented is at the stack top.
 *
 *  thr: thread containing the error value
 *  thr_callstack: thread which should be used for generating callstack etc.
 *  c_filename: C __FILE__ related to the error
 *  c_line: C __LINE__ related to the error
 *  noblame_fileline: if true, don't fileName/line as error source, otherwise use traceback
 *                    (needed because user code filename/line are reported but internal ones
 *                    are not)
 *
 *  XXX: rename noblame_fileline to flags field; combine it to some existing
 *  field (there are only a few call sites so this may not be worth it).
 */

#if defined(DUK_USE_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) {
        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
}
#endif  /* DUK_USE_AUGMENT_ERROR_CREATE */

/*
 *  Augment an error at throw time; allow a user error handler (if defined)
 *  to process/replace the error.  The error to be augmented is at the
 *  stack top.
 */

#if defined(DUK_USE_AUGMENT_ERROR_THROW)
DUK_INTERNAL void duk_err_augment_error_throw(duk_hthread *thr) {
#if defined(DUK_USE_ERRTHROW)
        duk__err_augment_user(thr, DUK_STRIDX_ERR_THROW);
#endif  /* DUK_USE_ERRTHROW */
}
#endif  /* DUK_USE_AUGMENT_ERROR_THROW */