From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- js/src/jsexn.h | 133 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 js/src/jsexn.h (limited to 'js/src/jsexn.h') diff --git a/js/src/jsexn.h b/js/src/jsexn.h new file mode 100644 index 0000000000..5e681248c7 --- /dev/null +++ b/js/src/jsexn.h @@ -0,0 +1,133 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * JS runtime exception classes. + */ + +#ifndef jsexn_h +#define jsexn_h + +#include "mozilla/Assertions.h" + +#include "jspubtd.h" +#include "jstypes.h" +#include "NamespaceImports.h" + +#include "js/ErrorReport.h" +#include "js/Exception.h" +#include "js/friend/ErrorMessages.h" // JSErr_Limit +#include "js/RootingAPI.h" +#include "js/TypeDecls.h" +#include "js/UniquePtr.h" +#include "js/Utility.h" + +extern const JSErrorFormatString js_ErrorFormatString[JSErr_Limit]; + +namespace js { + +class ErrorObject; + +UniquePtr CopyErrorNote(JSContext* cx, + JSErrorNotes::Note* note); + +UniquePtr CopyErrorReport(JSContext* cx, JSErrorReport* report); + +bool CaptureStack(JSContext* cx, MutableHandleObject stack); + +JSString* ComputeStackString(JSContext* cx); + +/* + * Given a JSErrorReport, check to see if there is an exception associated with + * the error number. If there is, then create an appropriate Error object, + * set it as the pending exception. + * + * It's possible we fail (due to OOM or some other error) and end up setting + * JSContext::unwrappedException to a different exception. + * The original error described by reportp typically won't be reported anywhere + * in this case. + * + * Returns true if the error was converted to an exception. If the error code + * is unrecognized, we fail due to OOM, or if we decided to do nothing in order + * to avoid recursion, we return false and this error is just being swept under + * the rug. + */ +extern bool ErrorToException(JSContext* cx, JSErrorReport* reportp, + JSErrorCallback callback, void* userRef); + +extern JSErrorReport* ErrorFromException(JSContext* cx, HandleObject obj); + +/* + * Make a copy of errobj parented to cx's compartment's global. + * + * errobj may be in a different compartment than cx, but it must be an Error + * object (not a wrapper of one) and it must not be one of the standard error + * prototype objects (errobj->getPrivate() must not be nullptr). + */ +extern JSObject* CopyErrorObject(JSContext* cx, + JS::Handle errobj); + +static_assert( + JSEXN_ERR == 0 && + JSProto_Error + int(JSEXN_INTERNALERR) == JSProto_InternalError && + JSProto_Error + int(JSEXN_AGGREGATEERR) == JSProto_AggregateError && + JSProto_Error + int(JSEXN_EVALERR) == JSProto_EvalError && + JSProto_Error + int(JSEXN_RANGEERR) == JSProto_RangeError && + JSProto_Error + int(JSEXN_REFERENCEERR) == JSProto_ReferenceError && + JSProto_Error + int(JSEXN_SYNTAXERR) == JSProto_SyntaxError && + JSProto_Error + int(JSEXN_TYPEERR) == JSProto_TypeError && + JSProto_Error + int(JSEXN_URIERR) == JSProto_URIError && + JSProto_Error + int(JSEXN_DEBUGGEEWOULDRUN) == + JSProto_DebuggeeWouldRun && + JSProto_Error + int(JSEXN_WASMCOMPILEERROR) == JSProto_CompileError && + JSProto_Error + int(JSEXN_WASMLINKERROR) == JSProto_LinkError && + JSProto_Error + int(JSEXN_WASMRUNTIMEERROR) == JSProto_RuntimeError && + JSEXN_WASMRUNTIMEERROR + 1 == JSEXN_WARN && + JSEXN_WARN + 1 == JSEXN_NOTE && JSEXN_NOTE + 1 == JSEXN_LIMIT, + "GetExceptionProtoKey and ExnTypeFromProtoKey require that " + "each corresponding JSExnType and JSProtoKey value be separated " + "by the same constant value"); + +static inline constexpr JSProtoKey GetExceptionProtoKey(JSExnType exn) { + MOZ_ASSERT(JSEXN_ERR <= exn); + MOZ_ASSERT(exn < JSEXN_WARN); + return JSProtoKey(JSProto_Error + int(exn)); +} + +static inline JSExnType ExnTypeFromProtoKey(JSProtoKey key) { + JSExnType type = static_cast(key - JSProto_Error); + MOZ_ASSERT(type >= JSEXN_ERR); + MOZ_ASSERT(type < JSEXN_ERROR_LIMIT); + return type; +} + +static inline bool IsErrorProtoKey(JSProtoKey key) { + int type = key - JSProto_Error; + return type >= JSEXN_ERR && type < JSEXN_ERROR_LIMIT; +} + +class AutoClearPendingException { + JSContext* cx; + + public: + explicit AutoClearPendingException(JSContext* cxArg) : cx(cxArg) {} + + ~AutoClearPendingException() { JS_ClearPendingException(cx); } +}; + +extern const char* ValueToSourceForError(JSContext* cx, HandleValue val, + JS::UniqueChars& bytes); + +bool GetInternalError(JSContext* cx, unsigned errorNumber, + MutableHandleValue error); +bool GetTypeError(JSContext* cx, unsigned errorNumber, + MutableHandleValue error); +bool GetAggregateError(JSContext* cx, unsigned errorNumber, + MutableHandleValue error); + +} // namespace js + +#endif /* jsexn_h */ -- cgit v1.2.3