--- /dev/null
+/*
+ * 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();
+}
projects / ceph.git / blobdiff