JavaScriptCore-1218.35.tar.gz

[apple/javascriptcore.git] / runtime / Error.cpp

diff --git a/runtime/Error.cpp b/runtime/Error.cpp
index bae07448b3118892d933958864f3a48959fdaf3d..9cbe20b97393080493474544af67a13ffc11329d 100644 (file)
--- a/runtime/Error.cpp
+++ b/runtime/Error.cpp
@@ -34,6 +34,7 @@
 #include "JSObject.h"
 #include "JSString.h"
 #include "NativeErrorConstructor.h"
 #include "JSObject.h"
 #include "JSString.h"
 #include "NativeErrorConstructor.h"

+#include "Operations.h"

 #include "SourceCode.h"
 
 #include <wtf/text/StringBuilder.h>
 #include "SourceCode.h"
 
 #include <wtf/text/StringBuilder.h>


@@ -43,79 +44,79 @@ namespace JSC {
 static const char* linePropertyName = "line";
 static const char* sourceURLPropertyName = "sourceURL";
 
 static const char* linePropertyName = "line";
 static const char* sourceURLPropertyName = "sourceURL";
 

-JSObject* createError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->errorStructure(), message);

 }
 
 }
 

-JSObject* createEvalError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createEvalError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->evalErrorConstructor()->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->evalErrorConstructor()->errorStructure(), message);

 }
 
 }
 

-JSObject* createRangeError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createRangeError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->rangeErrorConstructor()->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->rangeErrorConstructor()->errorStructure(), message);

 }
 
 }
 

-JSObject* createReferenceError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createReferenceError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->referenceErrorConstructor()->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->referenceErrorConstructor()->errorStructure(), message);

 }
 
 }
 

-JSObject* createSyntaxError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createSyntaxError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->syntaxErrorConstructor()->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->syntaxErrorConstructor()->errorStructure(), message);

 }
 
 }
 

-JSObject* createTypeError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createTypeError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->typeErrorConstructor()->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->typeErrorConstructor()->errorStructure(), message);

 }
 
 JSObject* createNotEnoughArgumentsError(JSGlobalObject* globalObject)
 {
 }
 
 JSObject* createNotEnoughArgumentsError(JSGlobalObject* globalObject)
 {

-    return createTypeError(globalObject, "Not enough arguments");
+    return createTypeError(globalObject, ASCIILiteral("Not enough arguments"));

 }
 
 }
 

-JSObject* createURIError(JSGlobalObject* globalObject, const UString& message)
+JSObject* createURIError(JSGlobalObject* globalObject, const String& message)

 {
     ASSERT(!message.isEmpty());
 {
     ASSERT(!message.isEmpty());

-    return ErrorInstance::create(globalObject->globalData(), globalObject->URIErrorConstructor()->errorStructure(), message);
+    return ErrorInstance::create(globalObject->vm(), globalObject->URIErrorConstructor()->errorStructure(), message);

 }
 
 }
 

-JSObject* createError(ExecState* exec, const UString& message)
+JSObject* createError(ExecState* exec, const String& message)

 {
     return createError(exec->lexicalGlobalObject(), message);
 }
 
 {
     return createError(exec->lexicalGlobalObject(), message);
 }
 

-JSObject* createEvalError(ExecState* exec, const UString& message)
+JSObject* createEvalError(ExecState* exec, const String& message)

 {
     return createEvalError(exec->lexicalGlobalObject(), message);
 }
 
 {
     return createEvalError(exec->lexicalGlobalObject(), message);
 }
 

-JSObject* createRangeError(ExecState* exec, const UString& message)
+JSObject* createRangeError(ExecState* exec, const String& message)

 {
     return createRangeError(exec->lexicalGlobalObject(), message);
 }
 
 {
     return createRangeError(exec->lexicalGlobalObject(), message);
 }
 

-JSObject* createReferenceError(ExecState* exec, const UString& message)
+JSObject* createReferenceError(ExecState* exec, const String& message)

 {
     return createReferenceError(exec->lexicalGlobalObject(), message);
 }
 
 {
     return createReferenceError(exec->lexicalGlobalObject(), message);
 }
 

-JSObject* createSyntaxError(ExecState* exec, const UString& message)
+JSObject* createSyntaxError(ExecState* exec, const String& message)

 {
     return createSyntaxError(exec->lexicalGlobalObject(), message);
 }
 
 {
     return createSyntaxError(exec->lexicalGlobalObject(), message);
 }
 

-JSObject* createTypeError(ExecState* exec, const UString& message)
+JSObject* createTypeError(ExecState* exec, const String& message)

 {
     return createTypeError(exec->lexicalGlobalObject(), message);
 }
 {
     return createTypeError(exec->lexicalGlobalObject(), message);
 }


@@ -125,22 +126,22 @@ JSObject* createNotEnoughArgumentsError(ExecState* exec)
     return createNotEnoughArgumentsError(exec->lexicalGlobalObject());
 }
 
     return createNotEnoughArgumentsError(exec->lexicalGlobalObject());
 }
 

-JSObject* createURIError(ExecState* exec, const UString& message)
+JSObject* createURIError(ExecState* exec, const String& message)

 {
     return createURIError(exec->lexicalGlobalObject(), message);
 }
 
 JSObject* addErrorInfo(CallFrame* callFrame, JSObject* error, int line, const SourceCode& source)
 {
 {
     return createURIError(exec->lexicalGlobalObject(), message);
 }
 
 JSObject* addErrorInfo(CallFrame* callFrame, JSObject* error, int line, const SourceCode& source)
 {

-    JSGlobalData* globalData = &callFrame->globalData();
-    const UString& sourceURL = source.provider()->url();
+    VM* vm = &callFrame->vm();
+    const String& sourceURL = source.provider()->url();

 
     if (line != -1)
 
     if (line != -1)

-        error->putDirect(*globalData, Identifier(globalData, linePropertyName), jsNumber(line), ReadOnly | DontDelete);
+        error->putDirect(*vm, Identifier(vm, linePropertyName), jsNumber(line), ReadOnly | DontDelete);

     if (!sourceURL.isNull())
     if (!sourceURL.isNull())

-        error->putDirect(*globalData, Identifier(globalData, sourceURLPropertyName), jsString(globalData, sourceURL), ReadOnly | DontDelete);
+        error->putDirect(*vm, Identifier(vm, sourceURLPropertyName), jsString(vm, sourceURL), ReadOnly | DontDelete);

 
 

-    globalData->interpreter->addStackTraceIfNecessary(callFrame, error);
+    vm->interpreter->addStackTraceIfNecessary(callFrame, error);

 
     return error;
 }
 
     return error;
 }


@@ -154,36 +155,33 @@ bool hasErrorInfo(ExecState* exec, JSObject* error)
 
 JSValue throwError(ExecState* exec, JSValue error)
 {
 
 JSValue throwError(ExecState* exec, JSValue error)
 {

-    if (error.isObject())
-        return throwError(exec, asObject(error));
-    exec->globalData().exception = error;
+    Interpreter::addStackTraceIfNecessary(exec, error);
+    exec->vm().exception = error;

     return error;
 }
 
 JSObject* throwError(ExecState* exec, JSObject* error)
 {
     Interpreter::addStackTraceIfNecessary(exec, error);
     return error;
 }
 
 JSObject* throwError(ExecState* exec, JSObject* error)
 {
     Interpreter::addStackTraceIfNecessary(exec, error);

-    exec->globalData().exception = error;
+    exec->vm().exception = error;

     return error;
 }
 
 JSObject* throwTypeError(ExecState* exec)
 {
     return error;
 }
 
 JSObject* throwTypeError(ExecState* exec)
 {

-    return throwError(exec, createTypeError(exec, "Type error"));
+    return throwError(exec, createTypeError(exec, ASCIILiteral("Type error")));

 }
 
 JSObject* throwSyntaxError(ExecState* exec)
 {
 }
 
 JSObject* throwSyntaxError(ExecState* exec)
 {

-    return throwError(exec, createSyntaxError(exec, "Syntax error"));
+    return throwError(exec, createSyntaxError(exec, ASCIILiteral("Syntax error")));

 }
 
 }
 

-ASSERT_CLASS_FITS_IN_CELL(StrictModeTypeErrorFunction);
-

 const ClassInfo StrictModeTypeErrorFunction::s_info = { "Function", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(StrictModeTypeErrorFunction) };
 
 void StrictModeTypeErrorFunction::destroy(JSCell* cell)
 {
 const ClassInfo StrictModeTypeErrorFunction::s_info = { "Function", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(StrictModeTypeErrorFunction) };
 
 void StrictModeTypeErrorFunction::destroy(JSCell* cell)
 {

-    jsCast<StrictModeTypeErrorFunction*>(cell)->StrictModeTypeErrorFunction::~StrictModeTypeErrorFunction();
+    static_cast<StrictModeTypeErrorFunction*>(cell)->StrictModeTypeErrorFunction::~StrictModeTypeErrorFunction();

 }
 
 } // namespace JSC
 }
 
 } // namespace JSC