diff options
Diffstat (limited to 'js/src/jsexn.cpp')
| -rw-r--r-- | js/src/jsexn.cpp | 1021 |
1 files changed, 1021 insertions, 0 deletions
diff --git a/js/src/jsexn.cpp b/js/src/jsexn.cpp new file mode 100644 index 000000000..d17c6f8b7 --- /dev/null +++ b/js/src/jsexn.cpp @@ -0,0 +1,1021 @@ +/* -*- 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 "mozilla/Sprintf.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 "js/CharacterEncoding.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 +}; + +static const ClassOps ErrorObjectClassOps = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + exn_finalize, + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + nullptr, /* trace */ +}; + +#define IMPLEMENT_ERROR_CLASS(name, classSpecPtr) \ + { \ + js_Error_str, /* yes, really */ \ + JSCLASS_HAS_CACHED_PROTO(JSProto_##name) | \ + JSCLASS_HAS_RESERVED_SLOTS(ErrorObject::RESERVED_SLOTS) | \ + JSCLASS_BACKGROUND_FINALIZE, \ + &ErrorObjectClassOps, \ + classSpecPtr \ + } + +const ClassSpec +ErrorObject::errorClassSpec_ = { + ErrorObject::createConstructor, + ErrorObject::createProto, + nullptr, + nullptr, + exception_methods, + exception_properties, + nullptr, + 0 +}; + +const ClassSpec +ErrorObject::subErrorClassSpec_ = { + ErrorObject::createConstructor, + ErrorObject::createProto, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + JSProto_Error +}; + +const ClassSpec +ErrorObject::nonGlobalErrorClassSpec_ = { + ErrorObject::createConstructor, + ErrorObject::createProto, + nullptr, + nullptr, + exception_methods, + exception_properties, + nullptr, + JSProto_Error | ClassSpec::DontDefineConstructor +}; + +const Class +ErrorObject::classes[JSEXN_LIMIT] = { + IMPLEMENT_ERROR_CLASS(Error, &ErrorObject::errorClassSpec_), + IMPLEMENT_ERROR_CLASS(InternalError, &ErrorObject::subErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(EvalError, &ErrorObject::subErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(RangeError, &ErrorObject::subErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(ReferenceError, &ErrorObject::subErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(SyntaxError, &ErrorObject::subErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(TypeError, &ErrorObject::subErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(URIError, &ErrorObject::subErrorClassSpec_), + + // These Error subclasses are not accessible via the global object: + IMPLEMENT_ERROR_CLASS(DebuggeeWouldRun, &ErrorObject::nonGlobalErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(CompileError, &ErrorObject::nonGlobalErrorClassSpec_), + IMPLEMENT_ERROR_CLASS(RuntimeError, &ErrorObject::nonGlobalErrorClassSpec_) +}; + +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 + * char array with characters for message_ + * 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 messageSize = 0; + if (report->message()) + messageSize = strlen(report->message().c_str()) + 1; + + /* + * The mallocSize can not overflow since it represents the sum of the + * sizes of already allocated objects. + */ + size_t mallocSize = sizeof(JSErrorReport) + messageSize + linebufSize + filenameSize; + uint8_t* cursor = cx->pod_calloc<uint8_t>(mallocSize); + if (!cursor) + return nullptr; + + JSErrorReport* copy = (JSErrorReport*)cursor; + cursor += sizeof(JSErrorReport); + + if (report->message()) { + copy->initBorrowedMessage((const char*)cursor); + js_memcpy(cursor, report->message().c_str(), messageSize); + cursor += messageSize; + } + + if (report->linebuf()) { + const char16_t* linebufCopy = (const char16_t*)cursor; + js_memcpy(cursor, report->linebuf(), linebufSize); + cursor += linebufSize; + copy->initBorrowedLinebuf(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; + JS::WarningReporter prevReporter; + JS::AutoSaveExceptionState prevState; + + explicit SuppressErrorsGuard(JSContext* cx) + : cx(cx), + prevReporter(JS::SetWarningReporter(cx, nullptr)), + prevState(cx) + {} + + ~SuppressErrorsGuard() + { + JS::SetWarningReporter(cx, 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, + JS::StackCapture(JS::MaxFrames(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) +{ + MOZ_ASSERT(fop->maybeOffMainThread()); + 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; + + JSErrorReport* report = obj->as<ErrorObject>().getOrCreateErrorReport(cx); + if (!report) { + MOZ_ASSERT(cx->isThrowingOutOfMemory()); + cx->recoverFromOutOfMemory(); + } + + return report; +} + +JS_PUBLIC_API(JSObject*) +ExceptionStackOrNull(HandleObject objArg) +{ + JSObject* obj = 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.filename()) + 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(JSContext* cx, int16_t exnType) +{ + /* + * JSEXN_INTERNALERR returns null to prevent that "InternalError: " + * is prepended before "uncaught exception: " + */ + if (exnType < 0 || exnType >= JSEXN_LIMIT || + exnType == JSEXN_INTERNALERR || exnType == JSEXN_WARN) + { + return nullptr; + } + JSProtoKey key = GetExceptionProtoKey(JSExnType(exnType)); + return ClassName(key, cx); +} + +void +js::ErrorToException(JSContext* cx, JSErrorReport* reportp, + JSErrorCallback callback, void* userRef) +{ + MOZ_ASSERT(reportp); + MOZ_ASSERT(!JSREPORT_IS_WARNING(reportp->flags)); + + // We cannot throw a proper object inside the self-hosting compartment, as + // we cannot construct the Error constructor without self-hosted code. Just + // print the error to stderr to help debugging. + if (cx->runtime()->isSelfHostingCompartment(cx->compartment())) { + PrintError(cx, stderr, JS::ConstUTF8CharsZ(), reportp, true); + return; + } + + // 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_ERR; + MOZ_ASSERT(exnType < JSEXN_LIMIT); + + if (exnType == JSEXN_WARN) { + // werror must be enabled, so we use JSEXN_ERR. + MOZ_ASSERT(cx->options().werror()); + exnType = JSEXN_ERR; + } + + // Prevent infinite recursion. + if (cx->generatingError) + return; + AutoScopedAssign<bool> asa(&cx->generatingError, true); + + // Create an exception object. + RootedString messageStr(cx, reportp->newMessageString(cx)); + if (!messageStr) + return; + + RootedString fileName(cx, JS_NewStringCopyZ(cx, reportp->filename)); + if (!fileName) + return; + + uint32_t lineNumber = reportp->lineno; + uint32_t columnNumber = reportp->column; + + RootedObject stack(cx); + if (!CaptureStack(cx, &stack)) + return; + + js::ScopedJSFreePtr<JSErrorReport> report(CopyErrorReport(cx, reportp)); + if (!report) + return; + + RootedObject errObject(cx, ErrorObject::create(cx, exnType, stack, fileName, + lineNumber, columnNumber, &report, messageStr)); + if (!errObject) + return; + + // Throw it. + cx->setPendingException(ObjectValue(*errObject)); + + // Flag the error report passed in to indicate an exception was raised. + reportp->flags |= JSREPORT_EXCEPTION; +} + +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; +} + +static JSString* +ErrorReportToString(JSContext* cx, JSErrorReport* reportp) +{ + /* + * We do NOT want to use GetErrorTypeName() here because it will not do the + * "right thing" for JSEXN_INTERNALERR. That is, the caller of this API + * expects that "InternalError: " will be prepended but GetErrorTypeName + * goes out of its way to avoid this. + */ + JSExnType type = static_cast<JSExnType>(reportp->exnType); + RootedString str(cx); + if (type != JSEXN_WARN) + str = ClassName(GetExceptionProtoKey(type), cx); + + /* + * If "str" is null at this point, that means we just want to use + * message without prefixing it with anything. + */ + if (str) { + RootedString separator(cx, JS_NewUCStringCopyN(cx, u": ", 2)); + if (!separator) + return nullptr; + str = ConcatStrings<CanGC>(cx, str, separator); + if (!str) + return nullptr; + } + + RootedString message(cx, reportp->newMessageString(cx)); + if (!message) + return nullptr; + + if (!str) + return message; + + return ConcatStrings<CanGC>(cx, str, message); +} + +ErrorReport::ErrorReport(JSContext* cx) + : reportp(nullptr), + str(cx), + strChars(cx), + exnObject(cx) +{ +} + +ErrorReport::~ErrorReport() +{ +} + +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->creationOptions().addonIdOrNull(); + + // 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]; + SprintfLiteral(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, + SniffingBehavior sniffingBehavior) +{ + MOZ_ASSERT(!cx->isExceptionPending()); + MOZ_ASSERT(!reportp); + + 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); + + if (!reportp && sniffingBehavior == NoSideEffects) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_ERR_DURING_THROW); + return false; + } + + // 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 if (exn.isSymbol()) { + RootedValue strVal(cx); + if (js::SymbolDescriptiveString(cx, exn.toSymbol(), &strVal)) + str = strVal.toString(); + else + str = nullptr; + } 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 = JSEXN_INTERNALERR; + ownedReport.column = column; + if (str) { + // Note that using |str| for |message_| here is kind of wrong, + // because |str| is supposed to be of the format + // |ErrorName: ErrorMessage|, and |message_| 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... + char* utf8; + if (str->ensureFlat(cx) && + strChars.initTwoByte(cx, str) && + (utf8 = JS::CharsToNewUTF8CharsZ(cx, strChars.twoByteRange()).c_str())) + { + ownedReport.initOwnedMessage(utf8); + } else { + cx->clearPendingException(); + str = nullptr; + } + } + } + + const char* utf8Message = nullptr; + if (str) + utf8Message = toStringResultBytesStorage.encodeUtf8(cx, str); + if (!utf8Message) + utf8Message = "unknown (can't convert to string)"; + + if (!reportp) { + // This is basically an inlined version of + // + // JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, + // JSMSG_UNCAUGHT_EXCEPTION, utf8Message); + // + // but without the reporting bits. Instead it just puts all + // the stuff we care about in our ownedReport and message_. + if (!populateUncaughtExceptionReportUTF8(cx, utf8Message)) { + // Just give up. We're out of memory or something; not much we can + // do here. + return false; + } + } else { + toStringResult_ = JS::ConstUTF8CharsZ(utf8Message, strlen(utf8Message)); + /* Flag the error as an exception. */ + reportp->flags |= JSREPORT_EXCEPTION; + } + + return true; +} + +bool +ErrorReport::populateUncaughtExceptionReportUTF8(JSContext* cx, ...) +{ + va_list ap; + va_start(ap, cx); + bool ok = populateUncaughtExceptionReportUTF8VA(cx, ap); + va_end(ap); + return ok; +} + +bool +ErrorReport::populateUncaughtExceptionReportUTF8VA(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.filename(); + 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, + nullptr, ArgumentsAreUTF8, &ownedReport, ap)) { + return false; + } + + toStringResult_ = ownedReport.message(); + reportp = &ownedReport; + 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"; + + AutoClearPendingException acpe(cx); + + RootedString str(cx, JS_ValueToSource(cx, val)); + if (!str) + return "<<error converting value to string>>"; + + StringBuffer sb(cx); + if (val.isObject()) { + RootedObject valObj(cx, val.toObjectOrNull()); + ESClass cls; + if (!GetBuiltinClass(cx, valObj, &cls)) + return "<<error determining class of value>>"; + const char* s; + if (cls == ESClass::Array) + s = "the array "; + else if (cls == ESClass::ArrayBuffer) + s = "the array buffer "; + else if (JS_IsArrayBufferViewObject(valObj)) + s = "the typed array "; + else + s = "the object "; + if (!sb.append(s, strlen(s))) + return "<<error converting value to string>>"; + } else if (val.isNumber()) { + if (!sb.append("the number ")) + return "<<error converting value to string>>"; + } else if (val.isString()) { + if (!sb.append("the string ")) + return "<<error converting value to string>>"; + } else { + MOZ_ASSERT(val.isBoolean() || val.isSymbol()); + return bytes.encodeLatin1(cx, str); + } + if (!sb.append(str)) + return "<<error converting value to string>>"; + str = sb.finishString(); + if (!str) + return "<<error converting value to string>>"; + return bytes.encodeLatin1(cx, str); +} |