1998-10-14 14:22:38 +04:00
|
|
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
*
|
1999-09-29 03:12:09 +04:00
|
|
|
* The contents of this file are subject to the Netscape Public
|
|
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
|
|
* except in compliance with the License. You may obtain a copy of
|
|
|
|
* the License at http://www.mozilla.org/NPL/
|
1998-10-14 14:22:38 +04:00
|
|
|
*
|
1999-09-29 03:12:09 +04:00
|
|
|
* Software distributed under the License is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
|
|
|
|
* implied. See the License for the specific language governing
|
|
|
|
* rights and limitations under the License.
|
1998-10-14 14:22:38 +04:00
|
|
|
*
|
1999-09-29 03:12:09 +04:00
|
|
|
* The Original Code is Mozilla Communicator client code, released
|
|
|
|
* March 31, 1998.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1998-10-14 14:22:38 +04:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-09-29 03:12:09 +04:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the
|
|
|
|
* terms of the GNU Public License (the "GPL"), in which case the
|
|
|
|
* provisions of the GPL are applicable instead of those above.
|
|
|
|
* If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of the GPL and not to allow others to use your
|
|
|
|
* version of this file under the NPL, indicate your decision by
|
|
|
|
* deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this
|
|
|
|
* file under either the NPL or the GPL.
|
1998-10-14 14:22:38 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JS standard exception implementation.
|
|
|
|
*/
|
|
|
|
|
1999-07-16 03:37:05 +04:00
|
|
|
#include <string.h>
|
1998-10-14 14:22:38 +04:00
|
|
|
#include "jsstddef.h"
|
|
|
|
#include "jstypes.h"
|
|
|
|
#include "jsutil.h" /* Added by JSIFY */
|
|
|
|
#include "jsprf.h"
|
|
|
|
#include "jsapi.h"
|
|
|
|
#include "jscntxt.h"
|
|
|
|
#include "jsconfig.h"
|
|
|
|
#include "jsexn.h"
|
1998-11-05 03:08:43 +03:00
|
|
|
#include "jsfun.h"
|
1998-10-14 14:22:38 +04:00
|
|
|
|
|
|
|
#if JS_HAS_ERROR_EXCEPTIONS
|
|
|
|
#if !JS_HAS_EXCEPTIONS
|
|
|
|
# error "JS_HAS_EXCEPTIONS must be defined to use JS_HAS_ERROR_EXCEPTIONS"
|
|
|
|
#endif
|
|
|
|
|
1999-10-06 01:07:23 +04:00
|
|
|
/* Declaration to resolve circular reference of js_ErrorClass by Exception. */
|
1998-11-05 03:08:43 +03:00
|
|
|
static JSBool
|
|
|
|
Exception(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);
|
1999-09-21 22:58:51 +04:00
|
|
|
JSBool
|
|
|
|
js_exnHasInstance(JSContext *cx, JSObject *obj, jsval v, JSBool *bp);
|
1998-11-05 03:08:43 +03:00
|
|
|
|
|
|
|
static void
|
|
|
|
exn_finalize(JSContext *cx, JSObject *obj);
|
|
|
|
|
1999-10-06 01:07:23 +04:00
|
|
|
JSClass js_ErrorClass = {
|
1998-11-05 03:08:43 +03:00
|
|
|
"Exception",
|
|
|
|
JSCLASS_HAS_PRIVATE,
|
|
|
|
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
|
|
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, exn_finalize,
|
|
|
|
NULL, NULL, NULL, Exception
|
|
|
|
};
|
1998-10-14 14:22:38 +04:00
|
|
|
|
|
|
|
/*
|
1998-11-05 03:08:43 +03:00
|
|
|
* A copy of the JSErrorReport originally generated.
|
1998-10-14 14:22:38 +04:00
|
|
|
*/
|
|
|
|
typedef struct JSExnPrivate {
|
|
|
|
JSErrorReport *errorReport;
|
|
|
|
} JSExnPrivate;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy everything interesting about an error into allocated memory.
|
|
|
|
*/
|
|
|
|
static JSExnPrivate *
|
1998-11-05 03:08:43 +03:00
|
|
|
exn_initPrivate(JSContext *cx, JSErrorReport *report)
|
1998-10-14 14:22:38 +04:00
|
|
|
{
|
|
|
|
JSExnPrivate *newPrivate;
|
1998-11-05 03:08:43 +03:00
|
|
|
JSErrorReport *newReport;
|
1998-10-14 14:22:38 +04:00
|
|
|
|
|
|
|
newPrivate = (JSExnPrivate *)JS_malloc(cx, sizeof (JSExnPrivate));
|
|
|
|
|
|
|
|
/* Copy the error report */
|
|
|
|
newReport = (JSErrorReport *)JS_malloc(cx, sizeof (JSErrorReport));
|
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
if (report->filename != NULL) {
|
1998-10-14 14:22:38 +04:00
|
|
|
newReport->filename =
|
|
|
|
(const char *)JS_malloc(cx, strlen(report->filename)+1);
|
|
|
|
strcpy((char *)newReport->filename, report->filename);
|
|
|
|
} else {
|
|
|
|
newReport->filename = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
newReport->lineno = report->lineno;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't need to copy linebuf and tokenptr, because they
|
|
|
|
* point into the deflated string cache. (currently?)
|
|
|
|
*/
|
|
|
|
newReport->linebuf = report->linebuf;
|
|
|
|
newReport->tokenptr = report->tokenptr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* But we do need to copy uclinebuf, uctokenptr, because they're
|
|
|
|
* pointers into internal tokenstream structs, and may go away.
|
|
|
|
*
|
|
|
|
* NOTE nothing uses this and I'm not really maintaining it until
|
|
|
|
* I know it's the desired API.
|
|
|
|
*/
|
1998-11-05 03:08:43 +03:00
|
|
|
if (report->uclinebuf != NULL) {
|
1999-04-27 19:18:57 +04:00
|
|
|
jsint len = js_strlen(report->uclinebuf) + 1;
|
1998-10-14 14:22:38 +04:00
|
|
|
newReport->uclinebuf =
|
1998-11-05 03:08:43 +03:00
|
|
|
(const jschar *)JS_malloc(cx, len * sizeof(jschar));
|
1999-04-27 19:18:57 +04:00
|
|
|
js_strncpy((jschar *)newReport->uclinebuf, report->uclinebuf, len);
|
1998-10-14 14:22:38 +04:00
|
|
|
newReport->uctokenptr = newReport->uclinebuf + (report->uctokenptr -
|
|
|
|
report->uclinebuf);
|
|
|
|
} else
|
|
|
|
newReport->uclinebuf = newReport->uctokenptr = NULL;
|
1999-07-16 03:37:05 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
if (report->ucmessage != NULL) {
|
1999-04-27 19:18:57 +04:00
|
|
|
jsint len = js_strlen(report->ucmessage) + 1;
|
1999-07-16 03:37:05 +04:00
|
|
|
newReport->ucmessage = (const jschar *)JS_malloc(cx, len * sizeof(jschar));
|
1998-11-05 03:08:43 +03:00
|
|
|
js_strncpy((jschar *)newReport->ucmessage, report->ucmessage, len);
|
|
|
|
|
|
|
|
if (report->messageArgs) {
|
1999-04-27 19:18:57 +04:00
|
|
|
intN i;
|
1998-11-05 03:08:43 +03:00
|
|
|
|
|
|
|
for (i = 0; report->messageArgs[i] != NULL; i++)
|
|
|
|
;
|
|
|
|
JS_ASSERT(i);
|
|
|
|
newReport->messageArgs =
|
|
|
|
(const jschar **)JS_malloc(cx, (i + 1) * sizeof(jschar *));
|
|
|
|
for (i = 0; report->messageArgs[i] != NULL; i++) {
|
|
|
|
len = js_strlen(report->messageArgs[i]) + 1;
|
|
|
|
newReport->messageArgs[i] =
|
|
|
|
(const jschar *)JS_malloc(cx, len * sizeof(jschar));
|
|
|
|
js_strncpy((jschar *)(newReport->messageArgs[i]),
|
|
|
|
report->messageArgs[i], len);
|
|
|
|
}
|
1999-07-16 03:37:05 +04:00
|
|
|
newReport->messageArgs[i] = NULL;
|
1998-11-05 03:08:43 +03:00
|
|
|
} else {
|
1999-07-16 03:37:05 +04:00
|
|
|
newReport->messageArgs = NULL;
|
1998-11-05 03:08:43 +03:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
newReport->ucmessage = NULL;
|
|
|
|
newReport->messageArgs = NULL;
|
|
|
|
}
|
1999-04-27 19:18:57 +04:00
|
|
|
newReport->errorNumber = report->errorNumber;
|
1998-11-05 03:08:43 +03:00
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
/* Note that this is before it gets flagged with JSREPORT_EXCEPTION */
|
|
|
|
newReport->flags = report->flags;
|
|
|
|
|
|
|
|
newPrivate->errorReport = newReport;
|
|
|
|
return newPrivate;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Undo all the damage done by exn_initPrivate.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
exn_destroyPrivate(JSContext *cx, JSExnPrivate *privateData)
|
|
|
|
{
|
1998-11-05 03:08:43 +03:00
|
|
|
JSErrorReport *report;
|
|
|
|
const jschar **args;
|
|
|
|
|
|
|
|
report = privateData->errorReport;
|
|
|
|
JS_ASSERT(report);
|
|
|
|
if (report->uclinebuf)
|
|
|
|
JS_free(cx, (void *)report->uclinebuf);
|
|
|
|
if (report->filename)
|
|
|
|
JS_free(cx, (void *)report->filename);
|
|
|
|
if (report->ucmessage)
|
|
|
|
JS_free(cx, (void *)report->ucmessage);
|
|
|
|
if (report->messageArgs) {
|
|
|
|
args = report->messageArgs;
|
1999-04-27 19:18:57 +04:00
|
|
|
while(*args != NULL)
|
|
|
|
JS_free(cx, (void *)*args++);
|
1998-11-05 03:08:43 +03:00
|
|
|
JS_free(cx, (void *)report->messageArgs);
|
|
|
|
}
|
|
|
|
JS_free(cx, report);
|
1998-10-14 14:22:38 +04:00
|
|
|
JS_free(cx, privateData);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
exn_finalize(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
|
|
|
JSExnPrivate *privateData;
|
1998-11-05 03:08:43 +03:00
|
|
|
jsval private;
|
1998-10-14 14:22:38 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
private = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
|
1998-10-14 14:22:38 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
if (private != JSVAL_NULL) {
|
|
|
|
privateData = JSVAL_TO_PRIVATE(private);
|
|
|
|
if (privateData)
|
|
|
|
exn_destroyPrivate(cx, privateData);
|
1998-10-14 14:22:38 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-10-06 01:07:23 +04:00
|
|
|
JSErrorReport *
|
1998-11-05 03:08:43 +03:00
|
|
|
js_ErrorFromException(JSContext *cx, jsval exn)
|
|
|
|
{
|
|
|
|
JSObject *obj;
|
|
|
|
JSExnPrivate *privateData;
|
|
|
|
jsval private;
|
|
|
|
|
|
|
|
if (!JSVAL_IS_OBJECT(exn))
|
|
|
|
return NULL;
|
|
|
|
obj = JSVAL_TO_OBJECT(exn);
|
1999-10-06 01:07:23 +04:00
|
|
|
if (OBJ_GET_CLASS(cx, obj) != &js_ErrorClass)
|
1998-11-05 03:08:43 +03:00
|
|
|
return NULL;
|
|
|
|
private = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
|
1999-10-06 01:07:23 +04:00
|
|
|
if (private == JSVAL_NULL)
|
|
|
|
return NULL;
|
|
|
|
privateData = JSVAL_TO_PRIVATE(private);
|
1998-11-05 03:08:43 +03:00
|
|
|
if (!privateData)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
JS_ASSERT(privateData->errorReport);
|
|
|
|
return privateData->errorReport;
|
|
|
|
}
|
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
/* This must be kept in synch with the exceptions array below. */
|
|
|
|
typedef enum JSExnType {
|
|
|
|
JSEXN_NONE = -1,
|
|
|
|
JSEXN_ERR,
|
|
|
|
JSEXN_INTERNALERR,
|
|
|
|
JSEXN_CONVERSIONERR,
|
1999-09-21 22:58:51 +04:00
|
|
|
JSEXN_EVALERR,
|
1999-09-16 11:12:00 +04:00
|
|
|
JSEXN_RANGEERR,
|
1999-09-21 22:58:51 +04:00
|
|
|
JSEXN_REFERENCEERR,
|
|
|
|
JSEXN_SYNTAXERR,
|
|
|
|
JSEXN_TYPEERR,
|
|
|
|
JSEXN_URIERR,
|
1998-10-14 14:22:38 +04:00
|
|
|
JSEXN_LIMIT
|
|
|
|
} JSExnType;
|
|
|
|
|
|
|
|
struct JSExnSpec {
|
|
|
|
int protoIndex;
|
1998-11-05 03:08:43 +03:00
|
|
|
const char *name;
|
1998-10-14 14:22:38 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct JSExnSpec exceptions[] = {
|
1999-09-21 22:58:51 +04:00
|
|
|
{ JSEXN_NONE, "Error" },
|
1998-11-05 03:08:43 +03:00
|
|
|
{ JSEXN_ERR, "InternalError" },
|
|
|
|
{ JSEXN_ERR, "ConversionError" },
|
1999-09-21 22:58:51 +04:00
|
|
|
{ JSEXN_ERR, "EvalError" },
|
1999-09-16 11:12:00 +04:00
|
|
|
{ JSEXN_ERR, "RangeError" },
|
1999-09-21 22:58:51 +04:00
|
|
|
{ JSEXN_ERR, "ReferenceError" },
|
|
|
|
{ JSEXN_ERR, "SyntaxError" },
|
|
|
|
{ JSEXN_ERR, "TypeError" },
|
|
|
|
{ JSEXN_ERR, "URIError" },
|
1998-10-14 14:22:38 +04:00
|
|
|
{0}
|
|
|
|
};
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
Exception(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
1998-11-05 03:08:43 +03:00
|
|
|
JSString *message;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Does it make sense to throw a not-a-function-error here?
|
|
|
|
* A constructor that was not a function would be novel.
|
|
|
|
*/
|
1998-10-14 14:22:38 +04:00
|
|
|
if (!cx->fp->constructing) {
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
/*
|
|
|
|
* If it's a new object of class Exception, then null out the private
|
|
|
|
* data so that the finalizer doesn't attempt to free it.
|
|
|
|
*/
|
1999-10-06 01:07:23 +04:00
|
|
|
if (OBJ_GET_CLASS(cx, obj) == &js_ErrorClass)
|
1998-11-05 03:08:43 +03:00
|
|
|
OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, JSVAL_NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the 'message' property.
|
|
|
|
*/
|
|
|
|
if (argc > 0) {
|
|
|
|
message = js_ValueToString(cx, argv[0]);
|
|
|
|
if (!message)
|
|
|
|
return JS_FALSE;
|
|
|
|
} else {
|
|
|
|
message = cx->runtime->emptyString;
|
|
|
|
}
|
|
|
|
if (!JS_DefineProperty(cx, obj, "message", STRING_TO_JSVAL(message),
|
|
|
|
NULL, NULL, JSPROP_ENUMERATE));
|
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1999-09-21 22:58:51 +04:00
|
|
|
/*
|
1999-10-06 01:07:23 +04:00
|
|
|
* Called by fun_hasInstance when 'obj' has js_ErrorClass, to see if
|
1999-09-21 22:58:51 +04:00
|
|
|
* 'v' could be an instanceof an exception from some other context
|
|
|
|
* - we'll know it is if it has that special 'something'
|
|
|
|
*/
|
|
|
|
|
|
|
|
JSBool
|
|
|
|
js_exnHasInstance(JSContext *cx, JSObject *obj, jsval v, JSBool *bp)
|
|
|
|
{
|
|
|
|
JSFunction *fun;
|
|
|
|
JSAtom *functionName;
|
|
|
|
jsval pval;
|
|
|
|
|
|
|
|
JSObject *obj2;
|
|
|
|
*bp = JS_FALSE;
|
|
|
|
|
|
|
|
fun = (JSFunction *)JS_GetPrivate(cx, obj);
|
|
|
|
functionName = fun->atom;
|
|
|
|
|
|
|
|
obj2 = JSVAL_TO_OBJECT(v);
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj2, (jsid)functionName, &pval))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
if (JSVAL_IS_INT(pval))
|
|
|
|
*bp = JS_TRUE;
|
|
|
|
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
/*
|
1998-11-05 03:08:43 +03:00
|
|
|
* Convert to string.
|
1998-10-14 14:22:38 +04:00
|
|
|
*
|
1998-11-05 03:08:43 +03:00
|
|
|
* This method only uses JavaScript-modifiable properties name, message; it is
|
|
|
|
* left to the host to check for private data and report filename and line
|
|
|
|
* number information along with this message.
|
1998-10-14 14:22:38 +04:00
|
|
|
*/
|
|
|
|
static JSBool
|
|
|
|
exn_toString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
|
|
|
jsval v;
|
1998-11-05 03:08:43 +03:00
|
|
|
JSString *name, *message, *result;
|
|
|
|
jschar *chars, *cp;
|
|
|
|
size_t length;
|
|
|
|
jsid id;
|
|
|
|
|
|
|
|
id = (jsid) cx->runtime->atomState.nameAtom;
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, &v) || !(name = js_ValueToString(cx, v)))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
if (!JS_GetProperty(cx, obj, "message", &v) ||
|
|
|
|
!(message = js_ValueToString(cx, v)))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
if (message->length > 0) {
|
|
|
|
length = name->length + message->length + 2;
|
|
|
|
cp = chars = JS_malloc(cx, (length + 1) * sizeof(jschar));
|
|
|
|
if (!chars)
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
js_strncpy(cp, name->chars, name->length);
|
|
|
|
cp += name->length;
|
|
|
|
*cp++ = ':'; *cp++ = ' ';
|
|
|
|
js_strncpy(cp, message->chars, message->length);
|
|
|
|
cp += message->length;
|
|
|
|
*cp = 0;
|
|
|
|
|
|
|
|
result = js_NewString(cx, chars, length, 0);
|
|
|
|
if (!result) {
|
|
|
|
JS_free(cx, chars);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
1998-10-14 14:22:38 +04:00
|
|
|
} else {
|
1998-11-05 03:08:43 +03:00
|
|
|
result = name;
|
1998-10-14 14:22:38 +04:00
|
|
|
}
|
1998-11-05 03:08:43 +03:00
|
|
|
|
|
|
|
*rval = STRING_TO_JSVAL(result);
|
1998-10-14 14:22:38 +04:00
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
#if JS_HAS_TOSOURCE
|
|
|
|
/*
|
|
|
|
* Return a string that may eval to something similar to the original object.
|
|
|
|
*/
|
|
|
|
static JSBool
|
|
|
|
exn_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
|
|
|
|
{
|
|
|
|
JSString *name, *message, *result;
|
|
|
|
jschar *chars, *cp;
|
|
|
|
jsid id;
|
|
|
|
size_t length;
|
|
|
|
jsval v;
|
|
|
|
|
|
|
|
id = (jsid) cx->runtime->atomState.nameAtom;
|
|
|
|
if (!OBJ_GET_PROPERTY(cx, obj, id, &v) || !(name = js_ValueToString(cx, v)))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
if (!JS_GetProperty(cx, obj, "message", &v) ||
|
|
|
|
!(message = js_ValueToString(cx, v)))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
length = (message->length > 0) ? name->length + message->length + 10
|
|
|
|
: name->length + 8;
|
|
|
|
|
|
|
|
cp = chars = JS_malloc(cx, (length + 1) * sizeof(jschar));
|
|
|
|
if (!chars)
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
*cp++ = '('; *cp++ = 'n'; *cp++ = 'e'; *cp++ = 'w'; *cp++ = ' ';
|
|
|
|
js_strncpy(cp, name->chars, name->length);
|
|
|
|
cp += name->length;
|
|
|
|
*cp++ = '(';
|
|
|
|
if (message->length > 0) {
|
|
|
|
*cp++ = '"';
|
|
|
|
js_strncpy(cp, message->chars, message->length);
|
|
|
|
cp += message->length;
|
|
|
|
*cp++ = '"';
|
|
|
|
}
|
|
|
|
*cp++ = ')'; *cp++ = ')'; *cp = 0;
|
|
|
|
|
|
|
|
result = js_NewString(cx, chars, length, 0);
|
|
|
|
if (!result) {
|
|
|
|
JS_free(cx, chars);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*rval = STRING_TO_JSVAL(result);
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
static JSFunctionSpec exception_methods[] = {
|
1998-11-05 03:08:43 +03:00
|
|
|
#if JS_HAS_TOSOURCE
|
|
|
|
{js_toSource_str, exn_toSource, 0},
|
|
|
|
#endif
|
1998-10-14 14:22:38 +04:00
|
|
|
{js_toString_str, exn_toString, 0},
|
|
|
|
{0}
|
|
|
|
};
|
|
|
|
|
|
|
|
JSObject *
|
|
|
|
js_InitExceptionClasses(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
|
|
|
int i;
|
1998-11-05 03:08:43 +03:00
|
|
|
JSObject *protos[JSEXN_LIMIT];
|
1998-10-14 14:22:38 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
/* Initialize the prototypes first. */
|
|
|
|
for (i = 0; exceptions[i].name != 0; i++) {
|
|
|
|
JSAtom *atom;
|
|
|
|
JSFunction *fun;
|
|
|
|
JSString *nameString;
|
|
|
|
int protoidx = exceptions[i].protoIndex;
|
|
|
|
|
|
|
|
/* Make the prototype for the current constructor name. */
|
1999-10-06 01:07:23 +04:00
|
|
|
protos[i] = js_NewObject(cx, &js_ErrorClass,
|
1998-11-05 03:08:43 +03:00
|
|
|
protoidx >= 0 ? protos[protoidx] : NULL,
|
|
|
|
obj);
|
|
|
|
if (!protos[i])
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
atom = js_Atomize(cx, exceptions[i].name, strlen(exceptions[i].name), 0);
|
|
|
|
|
1999-09-21 22:58:51 +04:00
|
|
|
/*
|
|
|
|
Now add a property to this prototype that can be used to
|
|
|
|
identify these kind of exceptions across multiple contexts.
|
|
|
|
This is a little less than satisfying, since other proto
|
|
|
|
chains may include objects with the same property but it'll
|
|
|
|
pass for now.
|
|
|
|
*/
|
|
|
|
if (!JS_DefineProperty(cx, protos[i], exceptions[i].name,
|
|
|
|
INT_TO_JSVAL(i),
|
|
|
|
NULL, NULL,
|
|
|
|
JSPROP_READONLY | JSPROP_PERMANENT))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
/* Make a constructor function for the current name. */
|
|
|
|
fun = js_DefineFunction(cx, obj, atom, Exception, 1, 0);
|
|
|
|
if (!fun)
|
|
|
|
return NULL; /* XXX also remove named property from obj... */
|
|
|
|
|
|
|
|
/* Make this constructor make objects of class Exception. */
|
1999-10-06 01:07:23 +04:00
|
|
|
fun->clasp = &js_ErrorClass;
|
1998-11-05 03:08:43 +03:00
|
|
|
|
|
|
|
/* Make the prototype and constructor links. */
|
1999-09-21 22:58:51 +04:00
|
|
|
if (!js_SetClassPrototype(cx, fun->object,
|
|
|
|
protos[i],
|
|
|
|
JSPROP_READONLY | JSPROP_PERMANENT))
|
1998-11-05 03:08:43 +03:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* proto bootstrap bit from JS_InitClass omitted. */
|
|
|
|
nameString = JS_NewStringCopyZ(cx, exceptions[i].name);
|
|
|
|
if (nameString == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Add the name property to the prototype. */
|
|
|
|
if (!JS_DefineProperty(cx, protos[i], js_name_str,
|
|
|
|
STRING_TO_JSVAL(nameString),
|
|
|
|
NULL, NULL,
|
|
|
|
JSPROP_ENUMERATE)) {
|
|
|
|
/* release it? */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* So finalize knows whether to. */
|
|
|
|
OBJ_SET_SLOT(cx, protos[i], JSSLOT_PRIVATE, JSVAL_NULL);
|
1998-10-14 14:22:38 +04:00
|
|
|
}
|
1998-11-05 03:08:43 +03:00
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
/*
|
1998-11-05 03:08:43 +03:00
|
|
|
* Add an empty message property. (To Exception.prototype only,
|
|
|
|
* because this property will be the same for all the exception
|
|
|
|
* protos.)
|
1998-10-14 14:22:38 +04:00
|
|
|
*/
|
1998-11-05 03:08:43 +03:00
|
|
|
if (!JS_DefineProperty(cx, protos[0], "message",
|
|
|
|
STRING_TO_JSVAL(cx->runtime->emptyString),
|
|
|
|
NULL, NULL, JSPROP_ENUMERATE))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add methods only to Exception.prototype, because ostensibly all
|
|
|
|
* exception types delegate to that.
|
|
|
|
*/
|
|
|
|
if (!JS_DefineFunctions(cx, protos[0], exception_methods))
|
|
|
|
return NULL;
|
1998-10-14 14:22:38 +04:00
|
|
|
|
|
|
|
return protos[0];
|
|
|
|
}
|
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
static JSExnType errorToExceptionNum[] = {
|
1998-10-14 14:22:38 +04:00
|
|
|
#define MSG_DEF(name, number, count, exception, format) \
|
|
|
|
exception,
|
|
|
|
#include "js.msg"
|
|
|
|
#undef MSG_DEF
|
|
|
|
};
|
|
|
|
|
|
|
|
#if defined ( DEBUG_mccabe ) && defined ( PRINTNAMES )
|
|
|
|
/* For use below... get character strings for error name and exception name */
|
|
|
|
static struct exnname { char *name; char *exception; } errortoexnname[] = {
|
|
|
|
#define MSG_DEF(name, number, count, exception, format) \
|
|
|
|
{#name, #exception},
|
|
|
|
#include "js.msg"
|
|
|
|
#undef MSG_DEF
|
|
|
|
};
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
JSBool
|
1998-11-05 03:08:43 +03:00
|
|
|
js_ErrorToException(JSContext *cx, const char *message, JSErrorReport *reportp)
|
1998-10-14 14:22:38 +04:00
|
|
|
{
|
|
|
|
JSErrNum errorNumber;
|
1998-11-05 03:08:43 +03:00
|
|
|
JSObject *errObject, *errProto;
|
1998-10-14 14:22:38 +04:00
|
|
|
JSExnType exn;
|
|
|
|
JSExnPrivate *privateData;
|
1998-11-05 03:08:43 +03:00
|
|
|
JSString *msgstr;
|
1998-10-14 14:22:38 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
/* Find the exception index associated with this error. */
|
1998-10-14 14:22:38 +04:00
|
|
|
JS_ASSERT(reportp);
|
|
|
|
errorNumber = reportp->errorNumber;
|
1998-11-05 03:08:43 +03:00
|
|
|
exn = errorToExceptionNum[errorNumber];
|
1998-10-14 14:22:38 +04:00
|
|
|
JS_ASSERT(exn < JSEXN_LIMIT);
|
|
|
|
|
|
|
|
#if defined( DEBUG_mccabe ) && defined ( PRINTNAMES )
|
|
|
|
/* Print the error name and the associated exception name to stderr */
|
|
|
|
fprintf(stderr, "%s\t%s\n",
|
|
|
|
errortoexnname[errorNumber].name,
|
|
|
|
errortoexnname[errorNumber].exception);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return false (no exception raised) if no exception is associated
|
|
|
|
* with the given error number.
|
|
|
|
*/
|
|
|
|
if (exn == JSEXN_NONE)
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
/*
|
1998-11-05 03:08:43 +03:00
|
|
|
* Try to get an appropriate prototype by looking up the corresponding
|
|
|
|
* exception constructor name in the current context. If the constructor
|
|
|
|
* has been deleted or overwritten, this may fail or return NULL, and
|
|
|
|
* js_NewObject will fall back to using Object.prototype.
|
1998-10-14 14:22:38 +04:00
|
|
|
*/
|
1998-11-05 03:08:43 +03:00
|
|
|
if (!js_GetClassPrototype(cx, exceptions[exn].name, &errProto))
|
|
|
|
errProto = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use js_NewObject instead of js_ConstructObject, because
|
|
|
|
* js_ConstructObject seems to require a frame.
|
|
|
|
*/
|
1999-10-06 01:07:23 +04:00
|
|
|
errObject = js_NewObject(cx, &js_ErrorClass, errProto, NULL);
|
1998-11-05 03:08:43 +03:00
|
|
|
|
|
|
|
/* Store 'message' as a javascript-visible value. */
|
|
|
|
msgstr = JS_NewStringCopyZ(cx, message);
|
|
|
|
if (!JS_DefineProperty(cx, errObject, "message", STRING_TO_JSVAL(msgstr),
|
|
|
|
NULL, NULL,
|
|
|
|
JSPROP_ENUMERATE))
|
|
|
|
return JS_FALSE;
|
1998-10-14 14:22:38 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct a new copy of the error report, and store it in the
|
|
|
|
* exception objects' private data. We can't use the error report
|
|
|
|
* handed in, because it's stack-allocated, and may point to transient
|
|
|
|
* data in the JSTokenStream.
|
|
|
|
*/
|
1998-11-05 03:08:43 +03:00
|
|
|
privateData = exn_initPrivate(cx, reportp);
|
|
|
|
OBJ_SET_SLOT(cx, errObject, JSSLOT_PRIVATE, PRIVATE_TO_JSVAL(privateData));
|
1998-10-14 14:22:38 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
/* Set the generated Exception object as the current exception. */
|
|
|
|
JS_SetPendingException(cx, OBJECT_TO_JSVAL(errObject));
|
1998-10-14 14:22:38 +04:00
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
/* Flag the error report passed in to indicate an exception was raised. */
|
1998-10-14 14:22:38 +04:00
|
|
|
reportp->flags |= JSREPORT_EXCEPTION;
|
1998-11-05 03:08:43 +03:00
|
|
|
|
1998-10-14 14:22:38 +04:00
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
#endif /* JS_HAS_ERROR_EXCEPTIONS */
|
|
|
|
|
1998-11-05 03:08:43 +03:00
|
|
|
#if JS_HAS_EXCEPTIONS
|
|
|
|
|
|
|
|
extern JSBool
|
|
|
|
js_ReportUncaughtException(JSContext *cx)
|
|
|
|
{
|
|
|
|
JSObject *exnObject;
|
|
|
|
JSString *str;
|
|
|
|
jsval exn;
|
|
|
|
JSErrorReport *reportp;
|
|
|
|
|
|
|
|
if (!JS_IsExceptionPending(cx))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
if (!JS_GetPendingException(cx, &exn))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because js_ValueToString below could error and an exception object
|
|
|
|
* could become unrooted, we root it here.
|
|
|
|
*/
|
1999-04-27 19:18:57 +04:00
|
|
|
if (JSVAL_IS_OBJECT(exn) && exn != JSVAL_NULL) {
|
1998-11-05 03:08:43 +03:00
|
|
|
exnObject = JSVAL_TO_OBJECT(exn);
|
1999-04-27 19:18:57 +04:00
|
|
|
if (!js_AddRoot(cx, &exnObject, "exn.report.root"))
|
1998-11-05 03:08:43 +03:00
|
|
|
return JS_FALSE;
|
|
|
|
} else {
|
|
|
|
exnObject = NULL;
|
|
|
|
}
|
|
|
|
str = js_ValueToString(cx, exn);
|
|
|
|
|
|
|
|
#if JS_HAS_ERROR_EXCEPTIONS
|
|
|
|
reportp = js_ErrorFromException(cx, exn);
|
|
|
|
#else
|
|
|
|
reportp = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (reportp == NULL) {
|
|
|
|
/*
|
|
|
|
* XXXmccabe todo: Instead of doing this, synthesize an error report
|
|
|
|
* struct that includes the filename, lineno where the exception was
|
|
|
|
* originally thrown.
|
|
|
|
*/
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_UNCAUGHT_EXCEPTION, js_GetStringBytes(str));
|
|
|
|
} else {
|
|
|
|
/* Flag the error as an exception. */
|
|
|
|
reportp->flags |= JSREPORT_EXCEPTION;
|
|
|
|
js_ReportErrorAgain(cx, js_GetStringBytes(str), reportp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (exnObject != NULL)
|
1999-06-23 18:18:56 +04:00
|
|
|
js_RemoveRoot(cx->runtime, &exnObject);
|
1998-11-05 03:08:43 +03:00
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* JS_HAS_EXCEPTIONS */
|