#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 "JSCInlines.h"
+#include "SourceCode.h"
+
+#include <wtf/text/StringBuilder.h>
namespace JSC {
-const char* expressionBeginOffsetPropertyName = "expressionBeginOffset";
-const char* expressionCaretOffsetPropertyName = "expressionCaretOffset";
-const char* expressionEndOffsetPropertyName = "expressionEndOffset";
-
-JSObject* Error::create(ExecState* exec, ErrorType type, const UString& message, int lineNumber, intptr_t sourceID, const UString& sourceURL)
-{
- JSObject* constructor;
- const char* name;
- switch (type) {
- case EvalError:
- constructor = exec->lexicalGlobalObject()->evalErrorConstructor();
- name = "Evaluation error";
- break;
- case RangeError:
- constructor = exec->lexicalGlobalObject()->rangeErrorConstructor();
- name = "Range error";
- break;
- case ReferenceError:
- constructor = exec->lexicalGlobalObject()->referenceErrorConstructor();
- name = "Reference error";
- break;
- case SyntaxError:
- constructor = exec->lexicalGlobalObject()->syntaxErrorConstructor();
- name = "Syntax error";
- break;
- case TypeError:
- constructor = exec->lexicalGlobalObject()->typeErrorConstructor();
- name = "Type error";
- break;
- case URIError:
- constructor = exec->lexicalGlobalObject()->URIErrorConstructor();
- name = "URI error";
- break;
- default:
- constructor = exec->lexicalGlobalObject()->errorConstructor();
- name = "Error";
- break;
+static const char* linePropertyName = "line";
+static const char* sourceURLPropertyName = "sourceURL";
+
+JSObject* createError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->errorStructure(), message, appender, TypeNothing, true);
+}
+
+JSObject* createEvalError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->evalErrorConstructor()->errorStructure(), message, appender, TypeNothing, true);
+}
+
+JSObject* createRangeError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->rangeErrorConstructor()->errorStructure(), message, appender, TypeNothing, true);
+}
+
+JSObject* createReferenceError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->referenceErrorConstructor()->errorStructure(), message, appender, TypeNothing, true);
+}
+
+JSObject* createSyntaxError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->syntaxErrorConstructor()->errorStructure(), message, appender, TypeNothing, true);
+}
+
+JSObject* createTypeError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender, RuntimeType type)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->typeErrorConstructor()->errorStructure(), message, appender, type, true);
+}
+
+JSObject* createNotEnoughArgumentsError(ExecState* exec, ErrorInstance::SourceAppender appender)
+{
+ return createTypeError(exec, ASCIILiteral("Not enough arguments"), appender, TypeNothing);
+}
+
+JSObject* createURIError(ExecState* exec, const String& message, ErrorInstance::SourceAppender appender)
+{
+ ASSERT(!message.isEmpty());
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ return ErrorInstance::create(exec, globalObject->vm(), globalObject->URIErrorConstructor()->errorStructure(), message, appender, TypeNothing, true);
+}
+
+JSObject* createOutOfMemoryError(ExecState* exec, ErrorInstance::SourceAppender appender)
+{
+ return createError(exec, ASCIILiteral("Out of memory"), appender);
+}
+
+
+class FindFirstCallerFrameWithCodeblockFunctor {
+public:
+ FindFirstCallerFrameWithCodeblockFunctor(CallFrame* startCallFrame)
+ : m_startCallFrame(startCallFrame)
+ , m_foundCallFrame(nullptr)
+ , m_foundStartCallFrame(false)
+ , m_index(0)
+ { }
+
+ StackVisitor::Status operator()(StackVisitor& visitor)
+ {
+ if (!m_foundStartCallFrame && (visitor->callFrame() == m_startCallFrame))
+ m_foundStartCallFrame = true;
+
+ if (m_foundStartCallFrame) {
+ if (visitor->callFrame()->codeBlock()) {
+ m_foundCallFrame = visitor->callFrame();
+ return StackVisitor::Done;
+ }
+ m_index++;
+ }
+
+ return StackVisitor::Continue;
}
- MarkedArgumentBuffer args;
- if (message.isEmpty())
- args.append(jsString(exec, name));
- else
- args.append(jsString(exec, message));
- ConstructData constructData;
- ConstructType constructType = constructor->getConstructData(constructData);
- JSObject* error = construct(exec, constructor, constructType, constructData, args);
-
- if (lineNumber != -1)
- error->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, lineNumber), ReadOnly | DontDelete);
- if (sourceID != -1)
- error->putWithAttributes(exec, Identifier(exec, "sourceId"), jsNumber(exec, sourceID), ReadOnly | DontDelete);
- if (!sourceURL.isNull())
- error->putWithAttributes(exec, Identifier(exec, "sourceURL"), jsString(exec, sourceURL), ReadOnly | DontDelete);
+ CallFrame* foundCallFrame() const { return m_foundCallFrame; }
+ unsigned index() const { return m_index; }
- return error;
+private:
+ CallFrame* m_startCallFrame;
+ CallFrame* m_foundCallFrame;
+ bool m_foundStartCallFrame;
+ unsigned m_index;
+};
+
+bool addErrorInfoAndGetBytecodeOffset(ExecState* exec, VM& vm, JSObject* obj, bool useCurrentFrame, CallFrame*& callFrame, unsigned &bytecodeOffset)
+{
+ Vector<StackFrame> stackTrace = Vector<StackFrame>();
+
+ if (exec && stackTrace.isEmpty())
+ vm.interpreter->getStackTrace(stackTrace);
+
+ if (!stackTrace.isEmpty()) {
+
+ ASSERT(exec == vm.topCallFrame || exec == exec->lexicalGlobalObject()->globalExec() || exec == exec->vmEntryGlobalObject()->globalExec());
+
+ StackFrame* stackFrame;
+ for (unsigned i = 0 ; i < stackTrace.size(); ++i) {
+ stackFrame = &stackTrace.at(i);
+ if (stackFrame->bytecodeOffset)
+ break;
+ }
+
+ if (bytecodeOffset) {
+ FindFirstCallerFrameWithCodeblockFunctor functor(exec);
+ vm.topCallFrame->iterate(functor);
+ callFrame = functor.foundCallFrame();
+ unsigned stackIndex = functor.index();
+ bytecodeOffset = stackTrace.at(stackIndex).bytecodeOffset;
+ }
+
+ unsigned line;
+ unsigned column;
+ stackFrame->computeLineAndColumn(line, column);
+ obj->putDirect(vm, vm.propertyNames->line, jsNumber(line), ReadOnly | DontDelete);
+ obj->putDirect(vm, vm.propertyNames->column, jsNumber(column), ReadOnly | DontDelete);
+
+ if (!stackFrame->sourceURL.isEmpty())
+ obj->putDirect(vm, vm.propertyNames->sourceURL, jsString(&vm, stackFrame->sourceURL), ReadOnly | DontDelete);
+
+ if (!useCurrentFrame)
+ stackTrace.remove(0);
+ obj->putDirect(vm, vm.propertyNames->stack, vm.interpreter->stackTraceAsString(vm.topCallFrame, stackTrace), DontEnum);
+
+ return true;
+ }
+ return false;
}
-JSObject* Error::create(ExecState* exec, ErrorType type, const char* message)
+void addErrorInfo(ExecState* exec, JSObject* obj, bool useCurrentFrame)
{
- return create(exec, type, message, -1, -1, NULL);
+ CallFrame* callFrame = nullptr;
+ unsigned bytecodeOffset = 0;
+ addErrorInfoAndGetBytecodeOffset(exec, exec->vm(), obj, useCurrentFrame, callFrame, bytecodeOffset);
}
-JSObject* throwError(ExecState* exec, ErrorType type)
+JSObject* addErrorInfo(CallFrame* callFrame, JSObject* error, int line, const SourceCode& source)
{
- JSObject* error = Error::create(exec, type, UString(), -1, -1, NULL);
- exec->setException(error);
+ VM* vm = &callFrame->vm();
+ const String& sourceURL = source.provider()->url();
+
+ if (line != -1)
+ error->putDirect(*vm, Identifier::fromString(vm, linePropertyName), jsNumber(line), ReadOnly | DontDelete);
+ if (!sourceURL.isNull())
+ error->putDirect(*vm, Identifier::fromString(vm, sourceURLPropertyName), jsString(vm, sourceURL), ReadOnly | DontDelete);
return error;
}
-JSObject* throwError(ExecState* exec, ErrorType type, const UString& message)
+
+bool hasErrorInfo(ExecState* exec, JSObject* error)
{
- JSObject* error = Error::create(exec, type, message, -1, -1, NULL);
- exec->setException(error);
- return error;
+ return error->hasProperty(exec, Identifier::fromString(exec, linePropertyName))
+ || error->hasProperty(exec, Identifier::fromString(exec, sourceURLPropertyName));
}
-JSObject* throwError(ExecState* exec, ErrorType type, const char* message)
+JSObject* throwTypeError(ExecState* exec)
{
- JSObject* error = Error::create(exec, type, message, -1, -1, NULL);
- exec->setException(error);
- return error;
+ return exec->vm().throwException(exec, createTypeError(exec));
}
-JSObject* throwError(ExecState* exec, ErrorType type, const UString& message, int line, intptr_t sourceID, const UString& sourceURL)
+JSObject* throwSyntaxError(ExecState* exec)
{
- JSObject* error = Error::create(exec, type, message, line, sourceID, sourceURL);
- exec->setException(error);
- return error;
+ return exec->vm().throwException(exec, createSyntaxError(exec, ASCIILiteral("Syntax error")));
+}
+
+
+JSObject* createError(ExecState* exec, const String& message)
+{
+ return createError(exec, message, nullptr);
+}
+
+JSObject* createEvalError(ExecState* exec, const String& message)
+{
+ return createEvalError(exec, message, nullptr);
+}
+
+JSObject* createRangeError(ExecState* exec, const String& message)
+{
+ return createRangeError(exec, message, nullptr);
+}
+
+JSObject* createReferenceError(ExecState* exec, const String& message)
+{
+ return createReferenceError(exec, message, nullptr);
+}
+
+JSObject* createSyntaxError(ExecState* exec, const String& message)
+{
+ return createSyntaxError(exec, message, nullptr);
+}
+
+JSObject* createTypeError(ExecState* exec)
+{
+ return createTypeError(exec, ASCIILiteral("Type error"));
+}
+
+JSObject* createTypeError(ExecState* exec, const String& message)
+{
+ return createTypeError(exec, message, nullptr, TypeNothing);
+}
+
+JSObject* createNotEnoughArgumentsError(ExecState* exec)
+{
+ return createNotEnoughArgumentsError(exec, nullptr);
+}
+
+JSObject* createURIError(ExecState* exec, const String& message)
+{
+ return createURIError(exec, message, nullptr);
+}
+
+JSObject* createOutOfMemoryError(ExecState* exec)
+{
+ return createOutOfMemoryError(exec, nullptr);
+}
+
+
+const ClassInfo StrictModeTypeErrorFunction::s_info = { "Function", &Base::s_info, 0, CREATE_METHOD_TABLE(StrictModeTypeErrorFunction) };
+
+void StrictModeTypeErrorFunction::destroy(JSCell* cell)
+{
+ static_cast<StrictModeTypeErrorFunction*>(cell)->StrictModeTypeErrorFunction::~StrictModeTypeErrorFunction();
}
} // namespace JSC
projects / apple / javascriptcore.git / blobdiff