1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sts=4 et sw=4 tw=99:
* 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 "jsapi.h"
#include "jscntxt.h"
#include "NamespaceImports.h"
namespace js {
class ErrorObject;
JSErrorReport*
CopyErrorReport(JSContext* cx, JSErrorReport* report);
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 exception object,
* set it as the pending exception, and set the JSREPORT_EXCEPTION flag on the
* error report.
*
* It's possible we fail (due to OOM or some other error) and end up setting
* cx->exception to a different exception. The original error described by
* *reportp typically won't be reported anywhere in this case.
*
* If the error code is unrecognized, or if we decided to do nothing in order to
* avoid recursion, we simply return and this error is just being swept under
* the rug.
*/
extern void
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<ErrorObject*> errobj);
static_assert(JSEXN_ERR == 0 &&
JSProto_Error + JSEXN_INTERNALERR == JSProto_InternalError &&
JSProto_Error + JSEXN_EVALERR == JSProto_EvalError &&
JSProto_Error + JSEXN_RANGEERR == JSProto_RangeError &&
JSProto_Error + JSEXN_REFERENCEERR == JSProto_ReferenceError &&
JSProto_Error + JSEXN_SYNTAXERR == JSProto_SyntaxError &&
JSProto_Error + JSEXN_TYPEERR == JSProto_TypeError &&
JSProto_Error + JSEXN_URIERR == JSProto_URIError &&
JSProto_Error + JSEXN_DEBUGGEEWOULDRUN == JSProto_DebuggeeWouldRun &&
JSProto_Error + JSEXN_WASMCOMPILEERROR == JSProto_CompileError &&
JSProto_Error + JSEXN_WASMRUNTIMEERROR == JSProto_RuntimeError &&
JSEXN_WASMRUNTIMEERROR + 1 == JSEXN_WARN &&
JSEXN_WARN + 1 == JSEXN_LIMIT,
"GetExceptionProtoKey and ExnTypeFromProtoKey require that "
"each corresponding JSExnType and JSProtoKey value be separated "
"by the same constant value");
static inline 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<JSExnType>(key - JSProto_Error);
MOZ_ASSERT(type >= JSEXN_ERR);
MOZ_ASSERT(type < JSEXN_WARN);
return type;
}
class AutoClearPendingException
{
JSContext* cx;
public:
explicit AutoClearPendingException(JSContext* cxArg)
: cx(cxArg)
{ }
~AutoClearPendingException() {
JS_ClearPendingException(cx);
}
};
class AutoAssertNoPendingException
{
mozilla::DebugOnly<JSContext*> cx;
public:
explicit AutoAssertNoPendingException(JSContext* cxArg)
: cx(cxArg)
{ }
~AutoAssertNoPendingException() {
MOZ_ASSERT(!JS_IsExceptionPending(cx));
}
};
extern const char*
ValueToSourceForError(JSContext* cx, HandleValue val, JSAutoByteString& bytes);
} // namespace js
#endif /* jsexn_h */
|
