JavaScriptCore-1218.35.tar.gz

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

diff --git a/runtime/Error.cpp b/runtime/Error.cpp
index 7eda19f54bc650f021b760a641a9f216bead74f8..9cbe20b97393080493474544af67a13ffc11329d 100644 (file)
--- a/runtime/Error.cpp
+++ b/runtime/Error.cpp
@@ -26,186 +26,162 @@
 
 #include "ConstructData.h"
 #include "ErrorConstructor.h"
 
 #include "ConstructData.h"
 #include "ErrorConstructor.h"

+#include "ExceptionHelpers.h"
+#include "FunctionPrototype.h"
+#include "JSArray.h"

 #include "JSFunction.h"
 #include "JSGlobalObject.h"
 #include "JSObject.h"
 #include "JSString.h"
 #include "NativeErrorConstructor.h"
 #include "JSFunction.h"
 #include "JSGlobalObject.h"
 #include "JSObject.h"
 #include "JSString.h"
 #include "NativeErrorConstructor.h"

+#include "Operations.h"

 #include "SourceCode.h"
 
 #include "SourceCode.h"
 

+#include <wtf/text/StringBuilder.h>
+

 namespace JSC {
 
 static const char* linePropertyName = "line";
 namespace JSC {
 
 static const char* linePropertyName = "line";

-static const char* sourceIdPropertyName = "sourceId";

 static const char* sourceURLPropertyName = "sourceURL";
 
 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)
+{
+    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);
 }
 

-JSObject* createURIError(ExecState* exec, const UString& message)
+JSObject* createNotEnoughArgumentsError(ExecState* exec)
+{
+    return createNotEnoughArgumentsError(exec->lexicalGlobalObject());
+}
+
+JSObject* createURIError(ExecState* exec, const String& message)

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

-JSObject* addErrorInfo(JSGlobalData* globalData, JSObject* error, int line, const SourceCode& source)
+JSObject* addErrorInfo(CallFrame* callFrame, JSObject* error, int line, const SourceCode& source)

 {
 {

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

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

-        error->putWithAttributes(globalData, Identifier(globalData, linePropertyName), jsNumber(line), ReadOnly | DontDelete);
-    if (sourceID != -1)
-        error->putWithAttributes(globalData, Identifier(globalData, sourceIdPropertyName), jsNumber((double)sourceID), ReadOnly | DontDelete);
+        error->putDirect(*vm, Identifier(vm, linePropertyName), jsNumber(line), ReadOnly | DontDelete);

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

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

 
     return error;
 }
 
 
     return error;
 }
 

-JSObject* addErrorInfo(ExecState* exec, JSObject* error, int line, const SourceCode& source)
-{
-    return addErrorInfo(&exec->globalData(), error, line, source);
-}

 
 bool hasErrorInfo(ExecState* exec, JSObject* error)
 {
     return error->hasProperty(exec, Identifier(exec, linePropertyName))
 
 bool hasErrorInfo(ExecState* exec, JSObject* error)
 {
     return error->hasProperty(exec, Identifier(exec, linePropertyName))

-        || error->hasProperty(exec, Identifier(exec, sourceIdPropertyName))

         || error->hasProperty(exec, Identifier(exec, sourceURLPropertyName));
 }
 
 JSValue throwError(ExecState* exec, JSValue error)
 {
         || error->hasProperty(exec, Identifier(exec, sourceURLPropertyName));
 }
 
 JSValue throwError(ExecState* exec, JSValue error)
 {

-    exec->globalData().exception = error;
+    Interpreter::addStackTraceIfNecessary(exec, error);
+    exec->vm().exception = error;

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

-    exec->globalData().exception = error;
+    Interpreter::addStackTraceIfNecessary(exec, 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"));
-}
-
-class StrictModeTypeErrorFunction : public InternalFunction {
-public:
-    StrictModeTypeErrorFunction(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, const UString& message)
-        : InternalFunction(&exec->globalData(), globalObject, structure, exec->globalData().propertyNames->emptyIdentifier)
-        , m_message(message)
-    {
-    }
-    
-    static EncodedJSValue JSC_HOST_CALL constructThrowTypeError(ExecState* exec)
-    {
-        throwTypeError(exec, static_cast<StrictModeTypeErrorFunction*>(exec->callee())->m_message);
-        return JSValue::encode(jsNull());
-    }
-    
-    ConstructType getConstructData(ConstructData& constructData)
-    {
-        constructData.native.function = constructThrowTypeError;
-        return ConstructTypeHost;
-    }
-    
-    static EncodedJSValue JSC_HOST_CALL callThrowTypeError(ExecState* exec)
-    {
-        throwTypeError(exec, static_cast<StrictModeTypeErrorFunction*>(exec->callee())->m_message);
-        return JSValue::encode(jsNull());
-    }
-
-    CallType getCallData(CallData& callData)
-    {
-        callData.native.function = callThrowTypeError;
-        return CallTypeHost;
-    }
-
-private:
-    UString m_message;
-};
-
-ASSERT_CLASS_FITS_IN_CELL(StrictModeTypeErrorFunction);
-
-JSValue createTypeErrorFunction(ExecState* exec, const UString& message)
-{
-    return new (exec) StrictModeTypeErrorFunction(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->internalFunctionStructure(), message);
+    return throwError(exec, createSyntaxError(exec, ASCIILiteral("Syntax error")));
+}
+
+const ClassInfo StrictModeTypeErrorFunction::s_info = { "Function", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(StrictModeTypeErrorFunction) };
+
+void StrictModeTypeErrorFunction::destroy(JSCell* cell)
+{
+    static_cast<StrictModeTypeErrorFunction*>(cell)->StrictModeTypeErrorFunction::~StrictModeTypeErrorFunction();

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