1/*
2 * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1.  Redistributions of source code must retain the above copyright
9 *     notice, this list of conditions and the following disclaimer.
10 * 2.  Redistributions in binary form must reproduce the above copyright
11 *     notice, this list of conditions and the following disclaimer in the
12 *     documentation and/or other materials provided with the distribution.
13 * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14 *     its contributors may be used to endorse or promote products derived
15 *     from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include "config.h"
30#include "ExceptionHelpers.h"
31
32#include "CodeBlock.h"
33#include "CallFrame.h"
34#include "ErrorHandlingScope.h"
35#include "ErrorInstance.h"
36#include "JSGlobalObjectFunctions.h"
37#include "JSObject.h"
38#include "JSNotAnObject.h"
39#include "Interpreter.h"
40#include "Nodes.h"
41#include "JSCInlines.h"
42
43namespace JSC {
44
45STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(TerminatedExecutionError);
46
47const ClassInfo TerminatedExecutionError::s_info = { "TerminatedExecutionError", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(TerminatedExecutionError) };
48
49JSValue TerminatedExecutionError::defaultValue(const JSObject*, ExecState* exec, PreferredPrimitiveType hint)
50{
51    if (hint == PreferString)
52        return jsNontrivialString(exec, String(ASCIILiteral("JavaScript execution terminated.")));
53    return JSValue(PNaN);
54}
55
56JSObject* createTerminatedExecutionException(VM* vm)
57{
58    return TerminatedExecutionError::create(*vm);
59}
60
61bool isTerminatedExecutionException(JSObject* object)
62{
63    return object->inherits(TerminatedExecutionError::info());
64}
65
66bool isTerminatedExecutionException(JSValue value)
67{
68    return value.inherits(TerminatedExecutionError::info());
69}
70
71
72JSObject* createStackOverflowError(ExecState* exec)
73{
74    return createRangeError(exec, ASCIILiteral("Maximum call stack size exceeded."));
75}
76
77JSObject* createStackOverflowError(JSGlobalObject* globalObject)
78{
79    return createRangeError(globalObject, ASCIILiteral("Maximum call stack size exceeded."));
80}
81
82JSObject* createUndefinedVariableError(ExecState* exec, const Identifier& ident)
83{
84
85    if (ident.impl()->isEmptyUnique()) {
86        String message(makeString("Can't find private variable: @", exec->propertyNames().getPublicName(ident).string()));
87        return createReferenceError(exec, message);
88    }
89    String message(makeString("Can't find variable: ", ident.string()));
90    return createReferenceError(exec, message);
91}
92
93JSString* errorDescriptionForValue(ExecState* exec, JSValue v)
94{
95    VM& vm = exec->vm();
96    if (v.isNull())
97        return vm.smallStrings.nullString();
98    if (v.isUndefined())
99        return vm.smallStrings.undefinedString();
100    if (v.isInt32())
101        return jsString(&vm, vm.numericStrings.add(v.asInt32()));
102    if (v.isDouble())
103        return jsString(&vm, vm.numericStrings.add(v.asDouble()));
104    if (v.isTrue())
105        return vm.smallStrings.trueString();
106    if (v.isFalse())
107        return vm.smallStrings.falseString();
108    if (v.isString())
109        return jsCast<JSString*>(v.asCell());
110    if (v.isObject()) {
111        CallData callData;
112        JSObject* object = asObject(v);
113        if (object->methodTable()->getCallData(object, callData) != CallTypeNone)
114            return vm.smallStrings.functionString();
115        return jsString(exec, object->methodTable()->className(object));
116    }
117
118    // The JSValue should never be empty, so this point in the code should never be reached.
119    ASSERT_NOT_REACHED();
120    return vm.smallStrings.emptyString();
121}
122
123JSObject* createError(ExecState* exec, ErrorFactory errorFactory, JSValue value, const String& message)
124{
125    String errorMessage = makeString(errorDescriptionForValue(exec, value)->value(exec), " ", message);
126    JSObject* exception = errorFactory(exec, errorMessage);
127    ASSERT(exception->isErrorInstance());
128    static_cast<ErrorInstance*>(exception)->setAppendSourceToMessage();
129    return exception;
130}
131
132JSObject* createInvalidParameterError(ExecState* exec, const char* op, JSValue value)
133{
134    return createError(exec, createTypeError, value, makeString("is not a valid argument for '", op, "'"));
135}
136
137JSObject* createNotAConstructorError(ExecState* exec, JSValue value)
138{
139    return createError(exec, createTypeError, value, "is not a constructor");
140}
141
142JSObject* createNotAFunctionError(ExecState* exec, JSValue value)
143{
144    return createError(exec, createTypeError, value, "is not a function");
145}
146
147JSObject* createNotAnObjectError(ExecState* exec, JSValue value)
148{
149    return createError(exec, createTypeError, value, "is not an object");
150}
151
152JSObject* createErrorForInvalidGlobalAssignment(ExecState* exec, const String& propertyName)
153{
154    return createReferenceError(exec, makeString("Strict mode forbids implicit creation of global property '", propertyName, "'"));
155}
156
157JSObject* createOutOfMemoryError(JSGlobalObject* globalObject)
158{
159    return createError(globalObject, ASCIILiteral("Out of memory"));
160}
161
162JSObject* throwOutOfMemoryError(ExecState* exec)
163{
164    return exec->vm().throwException(exec, createOutOfMemoryError(exec->lexicalGlobalObject()));
165}
166
167JSObject* throwStackOverflowError(ExecState* exec)
168{
169    VM& vm = exec->vm();
170    ErrorHandlingScope errorScope(vm);
171    return vm.throwException(exec, createStackOverflowError(exec));
172}
173
174JSObject* throwTerminatedExecutionException(ExecState* exec)
175{
176    VM& vm = exec->vm();
177    ErrorHandlingScope errorScope(vm);
178    return vm.throwException(exec, createTerminatedExecutionException(&vm));
179}
180
181} // namespace JSC
182