mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-01 01:41:37 +00:00
1033 lines
33 KiB
C++
1033 lines
33 KiB
C++
/* -*- 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 standard exception implementation.
|
|
*/
|
|
|
|
#include "jsexn.h"
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/PodOperations.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "jsapi.h"
|
|
#include "jscntxt.h"
|
|
#include "jsfun.h"
|
|
#include "jsnum.h"
|
|
#include "jsobj.h"
|
|
#include "jsprf.h"
|
|
#include "jsscript.h"
|
|
#include "jstypes.h"
|
|
#include "jsutil.h"
|
|
#include "jswrapper.h"
|
|
|
|
#include "gc/Marking.h"
|
|
#include "vm/ErrorObject.h"
|
|
#include "vm/GlobalObject.h"
|
|
#include "vm/SavedStacks.h"
|
|
#include "vm/StringBuffer.h"
|
|
|
|
#include "jsobjinlines.h"
|
|
|
|
#include "vm/ErrorObject-inl.h"
|
|
#include "vm/SavedStacks-inl.h"
|
|
|
|
using namespace js;
|
|
using namespace js::gc;
|
|
|
|
using mozilla::ArrayLength;
|
|
using mozilla::PodArrayZero;
|
|
|
|
static void
|
|
exn_finalize(FreeOp* fop, JSObject* obj);
|
|
|
|
bool
|
|
Error(JSContext* cx, unsigned argc, Value* vp);
|
|
|
|
static bool
|
|
exn_toSource(JSContext* cx, unsigned argc, Value* vp);
|
|
|
|
static const JSPropertySpec exception_properties[] = {
|
|
JS_PSGS("stack", ErrorObject::getStack, ErrorObject::setStack, 0),
|
|
JS_PS_END
|
|
};
|
|
|
|
static const JSFunctionSpec exception_methods[] = {
|
|
#if JS_HAS_TOSOURCE
|
|
JS_FN(js_toSource_str, exn_toSource, 0, 0),
|
|
#endif
|
|
JS_SELF_HOSTED_FN(js_toString_str, "ErrorToString", 0,0),
|
|
JS_FS_END
|
|
};
|
|
|
|
#define IMPLEMENT_ERROR_SUBCLASS(name) \
|
|
{ \
|
|
js_Error_str, /* yes, really */ \
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_##name) | \
|
|
JSCLASS_HAS_RESERVED_SLOTS(ErrorObject::RESERVED_SLOTS), \
|
|
nullptr, /* addProperty */ \
|
|
nullptr, /* delProperty */ \
|
|
nullptr, /* getProperty */ \
|
|
nullptr, /* setProperty */ \
|
|
nullptr, /* enumerate */ \
|
|
nullptr, /* resolve */ \
|
|
nullptr, /* mayResolve */ \
|
|
exn_finalize, \
|
|
nullptr, /* call */ \
|
|
nullptr, /* hasInstance */ \
|
|
nullptr, /* construct */ \
|
|
nullptr, /* trace */ \
|
|
{ \
|
|
ErrorObject::createConstructor, \
|
|
ErrorObject::createProto, \
|
|
nullptr, \
|
|
nullptr, \
|
|
exception_methods, \
|
|
exception_properties, \
|
|
nullptr, \
|
|
JSProto_Error \
|
|
} \
|
|
}
|
|
|
|
const Class
|
|
ErrorObject::classes[JSEXN_LIMIT] = {
|
|
{
|
|
js_Error_str,
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_Error) |
|
|
JSCLASS_HAS_RESERVED_SLOTS(ErrorObject::RESERVED_SLOTS),
|
|
nullptr, /* addProperty */
|
|
nullptr, /* delProperty */
|
|
nullptr, /* getProperty */
|
|
nullptr, /* setProperty */
|
|
nullptr, /* enumerate */
|
|
nullptr, /* resolve */
|
|
nullptr, /* mayResolve */
|
|
exn_finalize,
|
|
nullptr, /* call */
|
|
nullptr, /* hasInstance */
|
|
nullptr, /* construct */
|
|
nullptr, /* trace */
|
|
{
|
|
ErrorObject::createConstructor,
|
|
ErrorObject::createProto,
|
|
nullptr,
|
|
nullptr,
|
|
exception_methods,
|
|
exception_properties,
|
|
nullptr
|
|
}
|
|
},
|
|
IMPLEMENT_ERROR_SUBCLASS(InternalError),
|
|
IMPLEMENT_ERROR_SUBCLASS(EvalError),
|
|
IMPLEMENT_ERROR_SUBCLASS(RangeError),
|
|
IMPLEMENT_ERROR_SUBCLASS(ReferenceError),
|
|
IMPLEMENT_ERROR_SUBCLASS(SyntaxError),
|
|
IMPLEMENT_ERROR_SUBCLASS(TypeError),
|
|
IMPLEMENT_ERROR_SUBCLASS(URIError)
|
|
};
|
|
|
|
JSErrorReport*
|
|
js::CopyErrorReport(JSContext* cx, JSErrorReport* report)
|
|
{
|
|
/*
|
|
* We use a single malloc block to make a deep copy of JSErrorReport with
|
|
* the following layout:
|
|
* JSErrorReport
|
|
* array of copies of report->messageArgs
|
|
* char16_t array with characters for all messageArgs
|
|
* char16_t array with characters for ucmessage
|
|
* char16_t array with characters for linebuf
|
|
* char array with characters for filename
|
|
* Such layout together with the properties enforced by the following
|
|
* asserts does not need any extra alignment padding.
|
|
*/
|
|
JS_STATIC_ASSERT(sizeof(JSErrorReport) % sizeof(const char*) == 0);
|
|
JS_STATIC_ASSERT(sizeof(const char*) % sizeof(char16_t) == 0);
|
|
|
|
#define JS_CHARS_SIZE(chars) ((js_strlen(chars) + 1) * sizeof(char16_t))
|
|
|
|
size_t filenameSize = report->filename ? strlen(report->filename) + 1 : 0;
|
|
size_t linebufSize = 0;
|
|
if (report->linebuf())
|
|
linebufSize = (report->linebufLength() + 1) * sizeof(char16_t);
|
|
size_t ucmessageSize = 0;
|
|
size_t argsArraySize = 0;
|
|
size_t argsCopySize = 0;
|
|
if (report->ucmessage) {
|
|
ucmessageSize = JS_CHARS_SIZE(report->ucmessage);
|
|
if (report->messageArgs) {
|
|
size_t i = 0;
|
|
for (; report->messageArgs[i]; ++i)
|
|
argsCopySize += JS_CHARS_SIZE(report->messageArgs[i]);
|
|
|
|
/* Non-null messageArgs should have at least one non-null arg. */
|
|
MOZ_ASSERT(i != 0);
|
|
argsArraySize = (i + 1) * sizeof(const char16_t*);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The mallocSize can not overflow since it represents the sum of the
|
|
* sizes of already allocated objects.
|
|
*/
|
|
size_t mallocSize = sizeof(JSErrorReport) + argsArraySize + argsCopySize +
|
|
ucmessageSize + linebufSize + filenameSize;
|
|
uint8_t* cursor = cx->pod_calloc<uint8_t>(mallocSize);
|
|
if (!cursor)
|
|
return nullptr;
|
|
|
|
JSErrorReport* copy = (JSErrorReport*)cursor;
|
|
cursor += sizeof(JSErrorReport);
|
|
|
|
if (argsArraySize != 0) {
|
|
copy->messageArgs = (const char16_t**)cursor;
|
|
cursor += argsArraySize;
|
|
size_t i = 0;
|
|
for (; report->messageArgs[i]; ++i) {
|
|
copy->messageArgs[i] = (const char16_t*)cursor;
|
|
size_t argSize = JS_CHARS_SIZE(report->messageArgs[i]);
|
|
js_memcpy(cursor, report->messageArgs[i], argSize);
|
|
cursor += argSize;
|
|
}
|
|
copy->messageArgs[i] = nullptr;
|
|
MOZ_ASSERT(cursor == (uint8_t*)copy->messageArgs[0] + argsCopySize);
|
|
}
|
|
|
|
if (report->ucmessage) {
|
|
copy->ucmessage = (const char16_t*)cursor;
|
|
js_memcpy(cursor, report->ucmessage, ucmessageSize);
|
|
cursor += ucmessageSize;
|
|
}
|
|
|
|
if (report->linebuf()) {
|
|
const char16_t* linebufCopy = (const char16_t*)cursor;
|
|
js_memcpy(cursor, report->linebuf(), linebufSize);
|
|
cursor += linebufSize;
|
|
copy->initLinebuf(linebufCopy, report->linebufLength(), report->tokenOffset());
|
|
}
|
|
|
|
if (report->filename) {
|
|
copy->filename = (const char*)cursor;
|
|
js_memcpy(cursor, report->filename, filenameSize);
|
|
}
|
|
MOZ_ASSERT(cursor + filenameSize == (uint8_t*)copy + mallocSize);
|
|
|
|
/* Copy non-pointer members. */
|
|
copy->isMuted = report->isMuted;
|
|
copy->lineno = report->lineno;
|
|
copy->column = report->column;
|
|
copy->errorNumber = report->errorNumber;
|
|
copy->exnType = report->exnType;
|
|
|
|
/* Note that this is before it gets flagged with JSREPORT_EXCEPTION */
|
|
copy->flags = report->flags;
|
|
|
|
#undef JS_CHARS_SIZE
|
|
return copy;
|
|
}
|
|
|
|
struct SuppressErrorsGuard
|
|
{
|
|
JSContext* cx;
|
|
JSErrorReporter prevReporter;
|
|
JS::AutoSaveExceptionState prevState;
|
|
|
|
explicit SuppressErrorsGuard(JSContext* cx)
|
|
: cx(cx),
|
|
prevReporter(JS_SetErrorReporter(cx->runtime(), nullptr)),
|
|
prevState(cx)
|
|
{}
|
|
|
|
~SuppressErrorsGuard()
|
|
{
|
|
JS_SetErrorReporter(cx->runtime(), prevReporter);
|
|
}
|
|
};
|
|
|
|
// Cut off the stack if it gets too deep (most commonly for infinite recursion
|
|
// errors).
|
|
static const size_t MAX_REPORTED_STACK_DEPTH = 1u << 7;
|
|
|
|
static bool
|
|
CaptureStack(JSContext* cx, MutableHandleObject stack)
|
|
{
|
|
return CaptureCurrentStack(cx, stack, MAX_REPORTED_STACK_DEPTH);
|
|
}
|
|
|
|
JSString*
|
|
js::ComputeStackString(JSContext* cx)
|
|
{
|
|
SuppressErrorsGuard seg(cx);
|
|
|
|
RootedObject stack(cx);
|
|
if (!CaptureStack(cx, &stack))
|
|
return nullptr;
|
|
|
|
RootedString str(cx);
|
|
if (!BuildStackString(cx, stack, &str))
|
|
return nullptr;
|
|
|
|
return str.get();
|
|
}
|
|
|
|
static void
|
|
exn_finalize(FreeOp* fop, JSObject* obj)
|
|
{
|
|
if (JSErrorReport* report = obj->as<ErrorObject>().getErrorReport())
|
|
fop->free_(report);
|
|
}
|
|
|
|
JSErrorReport*
|
|
js::ErrorFromException(JSContext* cx, HandleObject objArg)
|
|
{
|
|
// It's ok to UncheckedUnwrap here, since all we do is get the
|
|
// JSErrorReport, and consumers are careful with the information they get
|
|
// from that anyway. Anyone doing things that would expose anything in the
|
|
// JSErrorReport to page script either does a security check on the
|
|
// JSErrorReport's principal or also tries to do toString on our object and
|
|
// will fail if they can't unwrap it.
|
|
RootedObject obj(cx, UncheckedUnwrap(objArg));
|
|
if (!obj->is<ErrorObject>())
|
|
return nullptr;
|
|
|
|
return obj->as<ErrorObject>().getOrCreateErrorReport(cx);
|
|
}
|
|
|
|
JS_PUBLIC_API(JSObject*)
|
|
ExceptionStackOrNull(JSContext* cx, HandleObject objArg)
|
|
{
|
|
AssertHeapIsIdle(cx);
|
|
CHECK_REQUEST(cx);
|
|
assertSameCompartment(cx, objArg);
|
|
RootedObject obj(cx, CheckedUnwrap(objArg));
|
|
if (!obj || !obj->is<ErrorObject>()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return obj->as<ErrorObject>().stack();
|
|
}
|
|
|
|
bool
|
|
Error(JSContext* cx, unsigned argc, Value* vp)
|
|
{
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
// ES6 19.5.1.1 mandates the .prototype lookup happens before the toString
|
|
RootedObject proto(cx);
|
|
if (!GetPrototypeFromCallableConstructor(cx, args, &proto))
|
|
return false;
|
|
|
|
/* Compute the error message, if any. */
|
|
RootedString message(cx, nullptr);
|
|
if (args.hasDefined(0)) {
|
|
message = ToString<CanGC>(cx, args[0]);
|
|
if (!message)
|
|
return false;
|
|
}
|
|
|
|
/* Find the scripted caller, but only ones we're allowed to know about. */
|
|
NonBuiltinFrameIter iter(cx, cx->compartment()->principals());
|
|
|
|
/* Set the 'fileName' property. */
|
|
RootedString fileName(cx);
|
|
if (args.length() > 1) {
|
|
fileName = ToString<CanGC>(cx, args[1]);
|
|
} else {
|
|
fileName = cx->runtime()->emptyString;
|
|
if (!iter.done()) {
|
|
if (const char* cfilename = iter.scriptFilename())
|
|
fileName = JS_NewStringCopyZ(cx, cfilename);
|
|
}
|
|
}
|
|
if (!fileName)
|
|
return false;
|
|
|
|
/* Set the 'lineNumber' property. */
|
|
uint32_t lineNumber, columnNumber = 0;
|
|
if (args.length() > 2) {
|
|
if (!ToUint32(cx, args[2], &lineNumber))
|
|
return false;
|
|
} else {
|
|
lineNumber = iter.done() ? 0 : iter.computeLine(&columnNumber);
|
|
// XXX: Make the column 1-based as in other browsers, instead of 0-based
|
|
// which is how SpiderMonkey stores it internally. This will be
|
|
// unnecessary once bug 1144340 is fixed.
|
|
++columnNumber;
|
|
}
|
|
|
|
RootedObject stack(cx);
|
|
if (!CaptureStack(cx, &stack))
|
|
return false;
|
|
|
|
/*
|
|
* ECMA ed. 3, 15.11.1 requires Error, etc., to construct even when
|
|
* called as functions, without operator new. But as we do not give
|
|
* each constructor a distinct JSClass, we must get the exception type
|
|
* ourselves.
|
|
*/
|
|
JSExnType exnType = JSExnType(args.callee().as<JSFunction>().getExtendedSlot(0).toInt32());
|
|
|
|
RootedObject obj(cx, ErrorObject::create(cx, exnType, stack, fileName,
|
|
lineNumber, columnNumber, nullptr, message, proto));
|
|
if (!obj)
|
|
return false;
|
|
|
|
args.rval().setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
#if JS_HAS_TOSOURCE
|
|
/*
|
|
* Return a string that may eval to something similar to the original object.
|
|
*/
|
|
static bool
|
|
exn_toSource(JSContext* cx, unsigned argc, Value* vp)
|
|
{
|
|
JS_CHECK_RECURSION(cx, return false);
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
RootedObject obj(cx, ToObject(cx, args.thisv()));
|
|
if (!obj)
|
|
return false;
|
|
|
|
RootedValue nameVal(cx);
|
|
RootedString name(cx);
|
|
if (!GetProperty(cx, obj, obj, cx->names().name, &nameVal) ||
|
|
!(name = ToString<CanGC>(cx, nameVal)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
RootedValue messageVal(cx);
|
|
RootedString message(cx);
|
|
if (!GetProperty(cx, obj, obj, cx->names().message, &messageVal) ||
|
|
!(message = ValueToSource(cx, messageVal)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
RootedValue filenameVal(cx);
|
|
RootedString filename(cx);
|
|
if (!GetProperty(cx, obj, obj, cx->names().fileName, &filenameVal) ||
|
|
!(filename = ValueToSource(cx, filenameVal)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
RootedValue linenoVal(cx);
|
|
uint32_t lineno;
|
|
if (!GetProperty(cx, obj, obj, cx->names().lineNumber, &linenoVal) ||
|
|
!ToUint32(cx, linenoVal, &lineno))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
StringBuffer sb(cx);
|
|
if (!sb.append("(new ") || !sb.append(name) || !sb.append("("))
|
|
return false;
|
|
|
|
if (!sb.append(message))
|
|
return false;
|
|
|
|
if (!filename->empty()) {
|
|
if (!sb.append(", ") || !sb.append(filename))
|
|
return false;
|
|
}
|
|
if (lineno != 0) {
|
|
/* We have a line, but no filename, add empty string */
|
|
if (filename->empty() && !sb.append(", \"\""))
|
|
return false;
|
|
|
|
JSString* linenumber = ToString<CanGC>(cx, linenoVal);
|
|
if (!linenumber)
|
|
return false;
|
|
if (!sb.append(", ") || !sb.append(linenumber))
|
|
return false;
|
|
}
|
|
|
|
if (!sb.append("))"))
|
|
return false;
|
|
|
|
JSString* str = sb.finishString();
|
|
if (!str)
|
|
return false;
|
|
args.rval().setString(str);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
/* static */ JSObject*
|
|
ErrorObject::createProto(JSContext* cx, JSProtoKey key)
|
|
{
|
|
RootedObject errorProto(cx, GenericCreatePrototype(cx, key));
|
|
if (!errorProto)
|
|
return nullptr;
|
|
|
|
Rooted<ErrorObject*> err(cx, &errorProto->as<ErrorObject>());
|
|
RootedString emptyStr(cx, cx->names().empty);
|
|
JSExnType type = ExnTypeFromProtoKey(key);
|
|
if (!ErrorObject::init(cx, err, type, nullptr, emptyStr, nullptr, 0, 0, emptyStr))
|
|
return nullptr;
|
|
|
|
// The various prototypes also have .name in addition to the normal error
|
|
// instance properties.
|
|
RootedPropertyName name(cx, ClassName(key, cx));
|
|
RootedValue nameValue(cx, StringValue(name));
|
|
if (!DefineProperty(cx, err, cx->names().name, nameValue, nullptr, nullptr, 0))
|
|
return nullptr;
|
|
|
|
return errorProto;
|
|
}
|
|
|
|
/* static */ JSObject*
|
|
ErrorObject::createConstructor(JSContext* cx, JSProtoKey key)
|
|
{
|
|
RootedObject ctor(cx);
|
|
ctor = GenericCreateConstructor<Error, 1, gc::AllocKind::FUNCTION_EXTENDED>(cx, key);
|
|
if (!ctor)
|
|
return nullptr;
|
|
|
|
ctor->as<JSFunction>().setExtendedSlot(0, Int32Value(ExnTypeFromProtoKey(key)));
|
|
return ctor;
|
|
}
|
|
|
|
JS_FRIEND_API(JSFlatString*)
|
|
js::GetErrorTypeName(JSRuntime* rt, int16_t exnType)
|
|
{
|
|
/*
|
|
* JSEXN_INTERNALERR returns null to prevent that "InternalError: "
|
|
* is prepended before "uncaught exception: "
|
|
*/
|
|
if (exnType <= JSEXN_NONE || exnType >= JSEXN_LIMIT ||
|
|
exnType == JSEXN_INTERNALERR)
|
|
{
|
|
return nullptr;
|
|
}
|
|
JSProtoKey key = GetExceptionProtoKey(JSExnType(exnType));
|
|
return ClassName(key, rt);
|
|
}
|
|
|
|
bool
|
|
js::ErrorToException(JSContext* cx, const char* message, JSErrorReport* reportp,
|
|
JSErrorCallback callback, void* userRef)
|
|
{
|
|
// Tell our caller to report immediately if this report is just a warning.
|
|
MOZ_ASSERT(reportp);
|
|
if (JSREPORT_IS_WARNING(reportp->flags))
|
|
return false;
|
|
|
|
// Similarly, we cannot throw a proper object inside the self-hosting
|
|
// compartment, as we cannot construct the Error constructor without
|
|
// self-hosted code. Tell our caller to report immediately.
|
|
// Without self-hosted code, we cannot get started anyway.
|
|
if (cx->runtime()->isSelfHostingCompartment(cx->compartment()))
|
|
return false;
|
|
|
|
// Find the exception index associated with this error.
|
|
JSErrNum errorNumber = static_cast<JSErrNum>(reportp->errorNumber);
|
|
if (!callback)
|
|
callback = GetErrorMessage;
|
|
const JSErrorFormatString* errorString = callback(userRef, errorNumber);
|
|
JSExnType exnType = errorString ? static_cast<JSExnType>(errorString->exnType) : JSEXN_NONE;
|
|
MOZ_ASSERT(exnType < JSEXN_LIMIT);
|
|
|
|
// Return false (no exception raised) if no exception is associated
|
|
// with the given error number.
|
|
if (exnType == JSEXN_NONE)
|
|
return false;
|
|
|
|
// Prevent infinite recursion.
|
|
if (cx->generatingError)
|
|
return false;
|
|
AutoScopedAssign<bool> asa(&cx->generatingError, true);
|
|
|
|
// Create an exception object.
|
|
RootedString messageStr(cx, reportp->ucmessage ? JS_NewUCStringCopyZ(cx, reportp->ucmessage)
|
|
: JS_NewStringCopyZ(cx, message));
|
|
if (!messageStr)
|
|
return cx->isExceptionPending();
|
|
|
|
RootedString fileName(cx, JS_NewStringCopyZ(cx, reportp->filename));
|
|
if (!fileName)
|
|
return cx->isExceptionPending();
|
|
|
|
uint32_t lineNumber = reportp->lineno;
|
|
uint32_t columnNumber = reportp->column;
|
|
|
|
RootedObject stack(cx);
|
|
if (!CaptureStack(cx, &stack))
|
|
return cx->isExceptionPending();
|
|
|
|
js::ScopedJSFreePtr<JSErrorReport> report(CopyErrorReport(cx, reportp));
|
|
if (!report)
|
|
return cx->isExceptionPending();
|
|
|
|
RootedObject errObject(cx, ErrorObject::create(cx, exnType, stack, fileName,
|
|
lineNumber, columnNumber, &report, messageStr));
|
|
if (!errObject)
|
|
return cx->isExceptionPending();
|
|
|
|
// Throw it.
|
|
RootedValue errValue(cx, ObjectValue(*errObject));
|
|
JS_SetPendingException(cx, errValue);
|
|
|
|
// Flag the error report passed in to indicate an exception was raised.
|
|
reportp->flags |= JSREPORT_EXCEPTION;
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
IsDuckTypedErrorObject(JSContext* cx, HandleObject exnObject, const char** filename_strp)
|
|
{
|
|
/*
|
|
* This function is called from ErrorReport::init and so should not generate
|
|
* any new exceptions.
|
|
*/
|
|
AutoClearPendingException acpe(cx);
|
|
|
|
bool found;
|
|
if (!JS_HasProperty(cx, exnObject, js_message_str, &found) || !found)
|
|
return false;
|
|
|
|
const char* filename_str = *filename_strp;
|
|
if (!JS_HasProperty(cx, exnObject, filename_str, &found) || !found) {
|
|
/* Now try "fileName", in case this quacks like an Error */
|
|
filename_str = js_fileName_str;
|
|
if (!JS_HasProperty(cx, exnObject, filename_str, &found) || !found)
|
|
return false;
|
|
}
|
|
|
|
if (!JS_HasProperty(cx, exnObject, js_lineNumber_str, &found) || !found)
|
|
return false;
|
|
|
|
*filename_strp = filename_str;
|
|
return true;
|
|
}
|
|
|
|
JS_FRIEND_API(JSString*)
|
|
js::ErrorReportToString(JSContext* cx, JSErrorReport* reportp)
|
|
{
|
|
JSExnType type = static_cast<JSExnType>(reportp->exnType);
|
|
RootedString str(cx, cx->runtime()->emptyString);
|
|
if (type != JSEXN_NONE)
|
|
str = ClassName(GetExceptionProtoKey(type), cx);
|
|
RootedString toAppend(cx, JS_NewUCStringCopyN(cx, MOZ_UTF16(": "), 2));
|
|
if (!str || !toAppend)
|
|
return nullptr;
|
|
str = ConcatStrings<CanGC>(cx, str, toAppend);
|
|
if (!str)
|
|
return nullptr;
|
|
toAppend = JS_NewUCStringCopyZ(cx, reportp->ucmessage);
|
|
if (toAppend)
|
|
str = ConcatStrings<CanGC>(cx, str, toAppend);
|
|
return str;
|
|
}
|
|
|
|
bool
|
|
js::ReportUncaughtException(JSContext* cx)
|
|
{
|
|
if (!cx->isExceptionPending())
|
|
return true;
|
|
|
|
RootedValue exn(cx);
|
|
if (!cx->getPendingException(&exn)) {
|
|
cx->clearPendingException();
|
|
return false;
|
|
}
|
|
|
|
cx->clearPendingException();
|
|
|
|
ErrorReport err(cx);
|
|
if (!err.init(cx, exn)) {
|
|
cx->clearPendingException();
|
|
return false;
|
|
}
|
|
|
|
cx->setPendingException(exn);
|
|
CallErrorReporter(cx, err.message(), err.report());
|
|
cx->clearPendingException();
|
|
return true;
|
|
}
|
|
|
|
ErrorReport::ErrorReport(JSContext* cx)
|
|
: reportp(nullptr),
|
|
message_(nullptr),
|
|
ownedMessage(nullptr),
|
|
str(cx),
|
|
strChars(cx),
|
|
exnObject(cx)
|
|
{
|
|
}
|
|
|
|
ErrorReport::~ErrorReport()
|
|
{
|
|
if (!ownedMessage)
|
|
return;
|
|
|
|
js_free(ownedMessage);
|
|
if (ownedReport.messageArgs) {
|
|
/*
|
|
* ExpandErrorArgumentsVA owns its messageArgs only if it had to
|
|
* inflate the arguments (from regular |char*|s), which is always in
|
|
* our case.
|
|
*/
|
|
size_t i = 0;
|
|
while (ownedReport.messageArgs[i])
|
|
js_free(const_cast<char16_t*>(ownedReport.messageArgs[i++]));
|
|
js_free(ownedReport.messageArgs);
|
|
}
|
|
js_free(const_cast<char16_t*>(ownedReport.ucmessage));
|
|
}
|
|
|
|
void
|
|
ErrorReport::ReportAddonExceptionToTelementry(JSContext* cx)
|
|
{
|
|
MOZ_ASSERT(exnObject);
|
|
RootedObject unwrapped(cx, UncheckedUnwrap(exnObject));
|
|
MOZ_ASSERT(unwrapped, "UncheckedUnwrap failed?");
|
|
|
|
// There is not much we can report if the exception is not an ErrorObject, let's ignore those.
|
|
if (!unwrapped->is<ErrorObject>())
|
|
return;
|
|
|
|
Rooted<ErrorObject*> errObj(cx, &unwrapped->as<ErrorObject>());
|
|
RootedObject stack(cx, errObj->stack());
|
|
|
|
// Let's ignore TOP level exceptions. For regular add-ons those will not be reported anyway,
|
|
// for SDK based once it should not be a valid case either.
|
|
// At this point the frame stack is unwound but the exception object stored the stack so let's
|
|
// use that for getting the function name.
|
|
if (!stack)
|
|
return;
|
|
|
|
JSCompartment* comp = stack->compartment();
|
|
JSAddonId* addonId = comp->addonId;
|
|
|
|
// We only want to send the report if the scope that just have thrown belongs to an add-on.
|
|
// Let's check the compartment of the youngest function on the stack, to determine that.
|
|
if (!addonId)
|
|
return;
|
|
|
|
RootedString funnameString(cx);
|
|
JS::SavedFrameResult result = GetSavedFrameFunctionDisplayName(cx, stack, &funnameString);
|
|
// AccessDenied should never be the case here for add-ons but let's not risk it.
|
|
JSAutoByteString bytes;
|
|
const char* funname = nullptr;
|
|
bool denied = result == JS::SavedFrameResult::AccessDenied;
|
|
funname = denied ? "unknown"
|
|
: funnameString ? AtomToPrintableString(cx,
|
|
&funnameString->asAtom(),
|
|
&bytes)
|
|
: "anonymous";
|
|
|
|
UniqueChars addonIdChars(JS_EncodeString(cx, addonId));
|
|
|
|
const char* filename = nullptr;
|
|
if (reportp && reportp->filename) {
|
|
filename = strrchr(reportp->filename, '/');
|
|
if (filename)
|
|
filename++;
|
|
}
|
|
if (!filename) {
|
|
filename = "FILE_NOT_FOUND";
|
|
}
|
|
char histogramKey[64];
|
|
JS_snprintf(histogramKey, sizeof(histogramKey),
|
|
"%s %s %s %u",
|
|
addonIdChars.get(),
|
|
funname,
|
|
filename,
|
|
(reportp ? reportp->lineno : 0) );
|
|
cx->runtime()->addTelemetry(JS_TELEMETRY_ADDON_EXCEPTIONS, 1, histogramKey);
|
|
}
|
|
|
|
bool
|
|
ErrorReport::init(JSContext* cx, HandleValue exn)
|
|
{
|
|
MOZ_ASSERT(!cx->isExceptionPending());
|
|
|
|
if (exn.isObject()) {
|
|
// Because ToString below could error and an exception object could become
|
|
// unrooted, we must root our exception object, if any.
|
|
exnObject = &exn.toObject();
|
|
reportp = ErrorFromException(cx, exnObject);
|
|
|
|
// Let's see if the exception is from add-on code, if so, it should be reported
|
|
// to telementry.
|
|
ReportAddonExceptionToTelementry(cx);
|
|
}
|
|
|
|
|
|
// Be careful not to invoke ToString if we've already successfully extracted
|
|
// an error report, since the exception might be wrapped in a security
|
|
// wrapper, and ToString-ing it might throw.
|
|
if (reportp)
|
|
str = ErrorReportToString(cx, reportp);
|
|
else
|
|
str = ToString<CanGC>(cx, exn);
|
|
|
|
if (!str)
|
|
cx->clearPendingException();
|
|
|
|
// If ErrorFromException didn't get us a JSErrorReport, then the object
|
|
// was not an ErrorObject, security-wrapped or otherwise. However, it might
|
|
// still quack like one. Give duck-typing a chance. We start by looking for
|
|
// "filename" (all lowercase), since that's where DOMExceptions store their
|
|
// filename. Then we check "fileName", which is where Errors store it. We
|
|
// have to do it in that order, because DOMExceptions have Error.prototype
|
|
// on their proto chain, and hence also have a "fileName" property, but its
|
|
// value is "".
|
|
const char* filename_str = "filename";
|
|
if (!reportp && exnObject && IsDuckTypedErrorObject(cx, exnObject, &filename_str))
|
|
{
|
|
// Temporary value for pulling properties off of duck-typed objects.
|
|
RootedValue val(cx);
|
|
|
|
RootedString name(cx);
|
|
if (JS_GetProperty(cx, exnObject, js_name_str, &val) && val.isString())
|
|
name = val.toString();
|
|
else
|
|
cx->clearPendingException();
|
|
|
|
RootedString msg(cx);
|
|
if (JS_GetProperty(cx, exnObject, js_message_str, &val) && val.isString())
|
|
msg = val.toString();
|
|
else
|
|
cx->clearPendingException();
|
|
|
|
// If we have the right fields, override the ToString we performed on
|
|
// the exception object above with something built out of its quacks
|
|
// (i.e. as much of |NameQuack: MessageQuack| as we can make).
|
|
//
|
|
// It would be nice to use ErrorReportToString here, but we can't quite
|
|
// do it - mostly because we'd need to figure out what JSExnType |name|
|
|
// corresponds to, which may not be any JSExnType at all.
|
|
if (name && msg) {
|
|
RootedString colon(cx, JS_NewStringCopyZ(cx, ": "));
|
|
if (!colon)
|
|
return false;
|
|
RootedString nameColon(cx, ConcatStrings<CanGC>(cx, name, colon));
|
|
if (!nameColon)
|
|
return false;
|
|
str = ConcatStrings<CanGC>(cx, nameColon, msg);
|
|
if (!str)
|
|
return false;
|
|
} else if (name) {
|
|
str = name;
|
|
} else if (msg) {
|
|
str = msg;
|
|
}
|
|
|
|
if (JS_GetProperty(cx, exnObject, filename_str, &val)) {
|
|
RootedString tmp(cx, ToString<CanGC>(cx, val));
|
|
if (tmp)
|
|
filename.encodeUtf8(cx, tmp);
|
|
else
|
|
cx->clearPendingException();
|
|
} else {
|
|
cx->clearPendingException();
|
|
}
|
|
|
|
uint32_t lineno;
|
|
if (!JS_GetProperty(cx, exnObject, js_lineNumber_str, &val) ||
|
|
!ToUint32(cx, val, &lineno))
|
|
{
|
|
cx->clearPendingException();
|
|
lineno = 0;
|
|
}
|
|
|
|
uint32_t column;
|
|
if (!JS_GetProperty(cx, exnObject, js_columnNumber_str, &val) ||
|
|
!ToUint32(cx, val, &column))
|
|
{
|
|
cx->clearPendingException();
|
|
column = 0;
|
|
}
|
|
|
|
reportp = &ownedReport;
|
|
new (reportp) JSErrorReport();
|
|
ownedReport.filename = filename.ptr();
|
|
ownedReport.lineno = lineno;
|
|
ownedReport.exnType = int16_t(JSEXN_NONE);
|
|
ownedReport.column = column;
|
|
if (str) {
|
|
// Note that using |str| for |ucmessage| here is kind of wrong,
|
|
// because |str| is supposed to be of the format
|
|
// |ErrorName: ErrorMessage|, and |ucmessage| is supposed to
|
|
// correspond to |ErrorMessage|. But this is what we've historically
|
|
// done for duck-typed error objects.
|
|
//
|
|
// If only this stuff could get specced one day...
|
|
if (str->ensureFlat(cx) && strChars.initTwoByte(cx, str))
|
|
ownedReport.ucmessage = strChars.twoByteChars();
|
|
}
|
|
}
|
|
|
|
if (str)
|
|
message_ = bytesStorage.encodeUtf8(cx, str);
|
|
if (!message_)
|
|
message_ = "unknown (can't convert to string)";
|
|
|
|
if (!reportp) {
|
|
// This is basically an inlined version of
|
|
//
|
|
// JS_ReportErrorNumber(cx, GetErrorMessage, nullptr,
|
|
// JSMSG_UNCAUGHT_EXCEPTION, message_);
|
|
//
|
|
// but without the reporting bits. Instead it just puts all
|
|
// the stuff we care about in our ownedReport and message_.
|
|
if (!populateUncaughtExceptionReport(cx, message_)) {
|
|
// Just give up. We're out of memory or something; not much we can
|
|
// do here.
|
|
return false;
|
|
}
|
|
} else {
|
|
/* Flag the error as an exception. */
|
|
reportp->flags |= JSREPORT_EXCEPTION;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ErrorReport::populateUncaughtExceptionReport(JSContext* cx, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, cx);
|
|
bool ok = populateUncaughtExceptionReportVA(cx, ap);
|
|
va_end(ap);
|
|
return ok;
|
|
}
|
|
|
|
bool
|
|
ErrorReport::populateUncaughtExceptionReportVA(JSContext* cx, va_list ap)
|
|
{
|
|
new (&ownedReport) JSErrorReport();
|
|
ownedReport.flags = JSREPORT_ERROR;
|
|
ownedReport.errorNumber = JSMSG_UNCAUGHT_EXCEPTION;
|
|
// XXXbz this assumes the stack we have right now is still
|
|
// related to our exception object. It would be better if we
|
|
// could accept a passed-in stack of some sort instead.
|
|
NonBuiltinFrameIter iter(cx, cx->compartment()->principals());
|
|
if (!iter.done()) {
|
|
ownedReport.filename = iter.scriptFilename();
|
|
ownedReport.lineno = iter.computeLine(&ownedReport.column);
|
|
// XXX: Make the column 1-based as in other browsers, instead of 0-based
|
|
// which is how SpiderMonkey stores it internally. This will be
|
|
// unnecessary once bug 1144340 is fixed.
|
|
++ownedReport.column;
|
|
ownedReport.isMuted = iter.mutedErrors();
|
|
}
|
|
|
|
if (!ExpandErrorArgumentsVA(cx, GetErrorMessage, nullptr,
|
|
JSMSG_UNCAUGHT_EXCEPTION, &ownedMessage,
|
|
&ownedReport, ArgumentsAreASCII, ap)) {
|
|
return false;
|
|
}
|
|
|
|
reportp = &ownedReport;
|
|
message_ = ownedMessage;
|
|
ownsMessageAndReport = true;
|
|
return true;
|
|
}
|
|
|
|
JSObject*
|
|
js::CopyErrorObject(JSContext* cx, Handle<ErrorObject*> err)
|
|
{
|
|
js::ScopedJSFreePtr<JSErrorReport> copyReport;
|
|
if (JSErrorReport* errorReport = err->getErrorReport()) {
|
|
copyReport = CopyErrorReport(cx, errorReport);
|
|
if (!copyReport)
|
|
return nullptr;
|
|
}
|
|
|
|
RootedString message(cx, err->getMessage());
|
|
if (message && !cx->compartment()->wrap(cx, &message))
|
|
return nullptr;
|
|
RootedString fileName(cx, err->fileName(cx));
|
|
if (!cx->compartment()->wrap(cx, &fileName))
|
|
return nullptr;
|
|
RootedObject stack(cx, err->stack());
|
|
if (!cx->compartment()->wrap(cx, &stack))
|
|
return nullptr;
|
|
uint32_t lineNumber = err->lineNumber();
|
|
uint32_t columnNumber = err->columnNumber();
|
|
JSExnType errorType = err->type();
|
|
|
|
// Create the Error object.
|
|
return ErrorObject::create(cx, errorType, stack, fileName,
|
|
lineNumber, columnNumber, ©Report, message);
|
|
}
|
|
|
|
JS_PUBLIC_API(bool)
|
|
JS::CreateError(JSContext* cx, JSExnType type, HandleObject stack, HandleString fileName,
|
|
uint32_t lineNumber, uint32_t columnNumber, JSErrorReport* report,
|
|
HandleString message, MutableHandleValue rval)
|
|
{
|
|
assertSameCompartment(cx, stack, fileName, message);
|
|
AssertObjectIsSavedFrameOrWrapper(cx, stack);
|
|
|
|
js::ScopedJSFreePtr<JSErrorReport> rep;
|
|
if (report)
|
|
rep = CopyErrorReport(cx, report);
|
|
|
|
RootedObject obj(cx,
|
|
js::ErrorObject::create(cx, type, stack, fileName,
|
|
lineNumber, columnNumber, &rep, message));
|
|
if (!obj)
|
|
return false;
|
|
|
|
rval.setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
const char*
|
|
js::ValueToSourceForError(JSContext* cx, HandleValue val, JSAutoByteString& bytes)
|
|
{
|
|
if (val.isUndefined()) {
|
|
return "undefined";
|
|
}
|
|
if (val.isNull()) {
|
|
return "null";
|
|
}
|
|
|
|
RootedString str(cx, JS_ValueToSource(cx, val));
|
|
if (!str) {
|
|
JS_ClearPendingException(cx);
|
|
return "<<error converting value to string>>";
|
|
}
|
|
|
|
StringBuffer sb(cx);
|
|
if (val.isObject()) {
|
|
RootedObject valObj(cx, val.toObjectOrNull());
|
|
ESClassValue cls;
|
|
if (!GetBuiltinClass(cx, valObj, &cls)) {
|
|
JS_ClearPendingException(cx);
|
|
return "<<error determining class of value>>";
|
|
}
|
|
if (cls == ESClass_Array) {
|
|
sb.append("the array ");
|
|
} else if (cls == ESClass_ArrayBuffer) {
|
|
sb.append("the array buffer ");
|
|
} else if (JS_IsArrayBufferViewObject(valObj)) {
|
|
sb.append("the typed array ");
|
|
} else {
|
|
sb.append("the object ");
|
|
}
|
|
} else if (val.isNumber()) {
|
|
sb.append("the number ");
|
|
} else if (val.isString()) {
|
|
sb.append("the string ");
|
|
} else {
|
|
MOZ_ASSERT(val.isBoolean() || val.isSymbol());
|
|
return bytes.encodeLatin1(cx, str);
|
|
}
|
|
sb.append(str);
|
|
return bytes.encodeLatin1(cx, sb.finishString());
|
|
}
|