JavaScriptCore-7600.1.4.11.8.tar.gz

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

diff --git a/runtime/Error.h b/runtime/Error.h
index e959cff6a573b2cd5bfd79fbd8fec99bfda7a3ab..50674eec862f8dadb343e3b46bf4c57f9fd3ad13 100644 (file)
--- a/runtime/Error.h
+++ b/runtime/Error.h
@@ -23,43 +23,109 @@
 #ifndef Error_h
 #define Error_h
 
+#include "InternalFunction.h"
+#include "Interpreter.h"
+#include "JSObject.h"
 #include <stdint.h>
 
 namespace JSC {
 
     class ExecState;
+    class VM;
+    class JSGlobalObject;
     class JSObject;
-    class UString;
-
-    /**
-     * Types of Native Errors available. For custom errors, GeneralError
-     * should be used.
-     */
-    enum ErrorType {
-        GeneralError   = 0,
-        EvalError      = 1,
-        RangeError     = 2,
-        ReferenceError = 3,
-        SyntaxError    = 4,
-        TypeError      = 5,
-        URIError       = 6
-    };
-    
-    extern const char* expressionBeginOffsetPropertyName;
-    extern const char* expressionCaretOffsetPropertyName;
-    extern const char* expressionEndOffsetPropertyName;
+    class SourceCode;
+    class Structure;
+
+    // Methods to create a range of internal errors.
+    JSObject* createError(JSGlobalObject*, const String&);
+    JSObject* createEvalError(JSGlobalObject*, const String&);
+    JSObject* createRangeError(JSGlobalObject*, const String&);
+    JSObject* createReferenceError(JSGlobalObject*, const String&);
+    JSObject* createSyntaxError(JSGlobalObject*, const String&);
+    JSObject* createTypeError(JSGlobalObject*, const String&);
+    JSObject* createNotEnoughArgumentsError(JSGlobalObject*);
+    JSObject* createURIError(JSGlobalObject*, const String&);
+    // ExecState wrappers.
+    JS_EXPORT_PRIVATE JSObject* createError(ExecState*, const String&);
+    JSObject* createEvalError(ExecState*, const String&);
+    JS_EXPORT_PRIVATE JSObject* createRangeError(ExecState*, const String&);
+    JS_EXPORT_PRIVATE JSObject* createReferenceError(ExecState*, const String&);
+    JS_EXPORT_PRIVATE JSObject* createSyntaxError(ExecState*, const String&);
+    JS_EXPORT_PRIVATE JSObject* createTypeError(ExecState*, const String&);
+    JS_EXPORT_PRIVATE JSObject* createNotEnoughArgumentsError(ExecState*);
+    JSObject* createURIError(ExecState*, const String&);
+
+    // Methods to add 
+    bool hasErrorInfo(ExecState*, JSObject* error);
+    // ExecState wrappers.
+    JSObject* addErrorInfo(ExecState*, JSObject* error, int line, const SourceCode&);
+
+    // Methods to throw Errors.
+
+    // Convenience wrappers, create an throw an exception with a default message.
+    JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*);
+    JS_EXPORT_PRIVATE JSObject* throwSyntaxError(ExecState*);
+
+    // Convenience wrappers, wrap result as an EncodedJSValue.
+    inline EncodedJSValue throwVMError(ExecState* exec, JSValue error) { return JSValue::encode(exec->vm().throwException(exec, error)); }
+    inline EncodedJSValue throwVMTypeError(ExecState* exec) { return JSValue::encode(throwTypeError(exec)); }
+    inline EncodedJSValue throwVMTypeError(ExecState* exec, const String& errorMessage) { return JSValue::encode(throwTypeError(exec, errorMessage)); }
     
-    class Error {
+    class StrictModeTypeErrorFunction : public InternalFunction {
+    private:
+        StrictModeTypeErrorFunction(VM& vm, Structure* structure, const String& message)
+            : InternalFunction(vm, structure)
+            , m_message(message)
+        {
+        }
+
+        static void destroy(JSCell*);
+
     public:
-        static JSObject* create(ExecState*, ErrorType, const UString& message, int lineNumber, intptr_t sourceID, const UString& sourceURL);
-        static JSObject* create(ExecState*, ErrorType, const char* message);
-    };
+        typedef InternalFunction Base;
+
+        static StrictModeTypeErrorFunction* create(VM& vm, Structure* structure, const String& message)
+        {
+            StrictModeTypeErrorFunction* function = new (NotNull, allocateCell<StrictModeTypeErrorFunction>(vm.heap)) StrictModeTypeErrorFunction(vm, structure, message);
+            function->finishCreation(vm, String());
+            return function;
+        }
+    
+        static EncodedJSValue JSC_HOST_CALL constructThrowTypeError(ExecState* exec)
+        {
+            throwTypeError(exec, static_cast<StrictModeTypeErrorFunction*>(exec->callee())->m_message);
+            return JSValue::encode(jsNull());
+        }
+    
+        static ConstructType getConstructData(JSCell*, 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());
+        }
 
-    JSObject* throwError(ExecState*, ErrorType, const UString& message, int lineNumber, intptr_t sourceID, const UString& sourceURL);
-    JSObject* throwError(ExecState*, ErrorType, const UString& message);
-    JSObject* throwError(ExecState*, ErrorType, const char* message);
-    JSObject* throwError(ExecState*, ErrorType);
-    JSObject* throwError(ExecState*, JSObject*);
+        static CallType getCallData(JSCell*, CallData& callData)
+        {
+            callData.native.function = callThrowTypeError;
+            return CallTypeHost;
+        }
+
+        DECLARE_INFO;
+
+        static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) 
+        { 
+            return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info()); 
+        }
+
+    private:
+        String m_message;
+    };
 
 } // namespace JSC