Use jsNontrivialString in more places if the string is guaranteed to be 2 or more...
[WebKit-https.git] / Source / JavaScriptCore / runtime / ExceptionHelpers.cpp
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 "JSGlobalObjectFunctions.h"
36 #include "JSNotAnObject.h"
37 #include "Interpreter.h"
38 #include "Nodes.h"
39 #include "JSCInlines.h"
40 #include "RuntimeType.h"
41 #include <wtf/text/StringBuilder.h>
42 #include <wtf/text/StringView.h>
43
44 namespace JSC {
45
46 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(TerminatedExecutionError);
47
48 const ClassInfo TerminatedExecutionError::s_info = { "TerminatedExecutionError", &Base::s_info, 0, CREATE_METHOD_TABLE(TerminatedExecutionError) };
49
50 JSValue TerminatedExecutionError::defaultValue(const JSObject*, ExecState* exec, PreferredPrimitiveType hint)
51 {
52     if (hint == PreferString)
53         return jsNontrivialString(exec, String(ASCIILiteral("JavaScript execution terminated.")));
54     return JSValue(PNaN);
55 }
56
57 JSObject* createTerminatedExecutionException(VM* vm)
58 {
59     return TerminatedExecutionError::create(*vm);
60 }
61
62 bool isTerminatedExecutionException(JSObject* object)
63 {
64     return object->inherits(TerminatedExecutionError::info());
65 }
66
67 bool isTerminatedExecutionException(JSValue value)
68 {
69     return value.inherits(TerminatedExecutionError::info());
70 }
71
72
73 JSObject* createStackOverflowError(ExecState* exec)
74 {
75     return createRangeError(exec, ASCIILiteral("Maximum call stack size exceeded."));
76 }
77
78 JSObject* createUndefinedVariableError(ExecState* exec, const Identifier& ident)
79 {
80     if (exec->propertyNames().isPrivateName(ident)) {
81         String message(makeString("Can't find private variable: @", exec->propertyNames().getPublicName(ident).string()));
82         return createReferenceError(exec, message);
83     }
84     String message(makeString("Can't find variable: ", ident.string()));
85     return createReferenceError(exec, message);
86 }
87     
88 JSString* errorDescriptionForValue(ExecState* exec, JSValue v)
89 {
90     VM& vm = exec->vm();
91     if (v.isNull())
92         return vm.smallStrings.nullString();
93     if (v.isUndefined())
94         return vm.smallStrings.undefinedString();
95     if (v.isInt32())
96         return jsString(&vm, vm.numericStrings.add(v.asInt32()));
97     if (v.isDouble())
98         return jsString(&vm, vm.numericStrings.add(v.asDouble()));
99     if (v.isTrue())
100         return vm.smallStrings.trueString();
101     if (v.isFalse())
102         return vm.smallStrings.falseString();
103     if (v.isString())
104         return jsNontrivialString(&vm, makeString('"',  asString(v)->value(exec), '"'));
105     if (v.isObject()) {
106         CallData callData;
107         JSObject* object = asObject(v);
108         if (object->methodTable()->getCallData(object, callData) != CallTypeNone)
109             return vm.smallStrings.functionString();
110         return jsString(exec, JSObject::calculatedClassName(object));
111     }
112     
113     // The JSValue should never be empty, so this point in the code should never be reached.
114     ASSERT_NOT_REACHED();
115     return vm.smallStrings.emptyString();
116 }
117     
118 static String defaultApproximateSourceError(const String& originalMessage, const String& sourceText)
119 {
120     return makeString(originalMessage, " (near '...", sourceText, "...')");
121 }
122
123 static String defaultSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
124 {
125     if (occurrence == ErrorInstance::FoundApproximateSource)
126         return defaultApproximateSourceError(originalMessage, sourceText);
127
128     ASSERT(occurrence == ErrorInstance::FoundExactSource);
129     return makeString(originalMessage, " (evaluating '", sourceText, "')");
130 }
131
132 static String functionCallBase(const String& sourceText)
133
134     // This function retrieves the 'foo.bar' substring from 'foo.bar(baz)'.
135     unsigned idx = sourceText.length() - 1;
136     if (sourceText[idx] != ')') {
137         // For function calls that have many new lines in between their open parenthesis
138         // and their closing parenthesis, the text range passed into the message appender 
139         // will not inlcude the text in between these parentheses, it will just be the desired
140         // text that precedes the parentheses.
141         return sourceText;
142     }
143
144     unsigned parenStack = 1;
145     bool isInMultiLineComment = false;
146     idx -= 1;
147     // Note that we're scanning text right to left instead of the more common left to right, 
148     // so syntax detection is backwards.
149     while (parenStack > 0) {
150         UChar curChar = sourceText[idx];
151         if (isInMultiLineComment)  {
152             if (curChar == '*' && sourceText[idx - 1] == '/') {
153                 isInMultiLineComment = false;
154                 idx -= 1;
155             }
156         } else if (curChar == '(')
157             parenStack -= 1;
158         else if (curChar == ')')
159             parenStack += 1;
160         else if (curChar == '/' && sourceText[idx - 1] == '*') {
161             isInMultiLineComment = true;
162             idx -= 1;
163         }
164
165         idx -= 1;
166     }
167
168     return sourceText.left(idx + 1);
169 }
170
171 static String notAFunctionSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
172 {
173     ASSERT(type != TypeFunction);
174
175     if (occurrence == ErrorInstance::FoundApproximateSource)
176         return defaultApproximateSourceError(originalMessage, sourceText);
177
178     ASSERT(occurrence == ErrorInstance::FoundExactSource);
179     auto notAFunctionIndex = originalMessage.reverseFind("is not a function");
180     RELEASE_ASSERT(notAFunctionIndex != notFound);
181     StringView displayValue;
182     if (originalMessage.is8Bit()) 
183         displayValue = StringView(originalMessage.characters8(), notAFunctionIndex - 1);
184     else
185         displayValue = StringView(originalMessage.characters16(), notAFunctionIndex - 1);
186
187     String base = functionCallBase(sourceText);
188     StringBuilder builder;
189     builder.append(base);
190     builder.appendLiteral(" is not a function. (In '");
191     builder.append(sourceText);
192     builder.appendLiteral("', '");
193     builder.append(base);
194     builder.appendLiteral("' is ");
195     if (type == TypeObject)
196         builder.appendLiteral("an instance of ");
197     builder.append(displayValue);
198     builder.appendLiteral(")");
199
200     return builder.toString();
201 }
202
203 static String invalidParameterInSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType type, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
204 {
205     ASSERT_UNUSED(type, type != TypeObject);
206
207     if (occurrence == ErrorInstance::FoundApproximateSource)
208         return defaultApproximateSourceError(originalMessage, sourceText);
209
210     ASSERT(occurrence == ErrorInstance::FoundExactSource);
211     auto inIndex = sourceText.reverseFind("in");
212     RELEASE_ASSERT(inIndex != notFound);
213     if (sourceText.find("in") != inIndex)
214         return makeString(originalMessage, " (evaluating '", sourceText, "')");
215
216     static const unsigned inLength = 2;
217     String rightHandSide = sourceText.substring(inIndex + inLength).simplifyWhiteSpace();
218     return makeString(rightHandSide, " is not an Object. (evaluating '", sourceText, "')");
219 }
220
221 static String invalidParameterInstanceofSourceAppender(const String& originalMessage, const String& sourceText, RuntimeType, ErrorInstance::SourceTextWhereErrorOccurred occurrence)
222 {
223     if (occurrence == ErrorInstance::FoundApproximateSource)
224         return defaultApproximateSourceError(originalMessage, sourceText);
225
226     ASSERT(occurrence == ErrorInstance::FoundExactSource);
227     auto instanceofIndex = sourceText.reverseFind("instanceof");
228     RELEASE_ASSERT(instanceofIndex != notFound);
229     if (sourceText.find("instanceof") != instanceofIndex)
230         return makeString(originalMessage, " (evaluating '", sourceText, "')");
231
232     static const unsigned instanceofLength = 10;
233     String rightHandSide = sourceText.substring(instanceofIndex + instanceofLength).simplifyWhiteSpace();
234     return makeString(rightHandSide, " is not a function. (evaluating '", sourceText, "')");
235 }
236
237 JSObject* createError(ExecState* exec, JSValue value, const String& message, ErrorInstance::SourceAppender appender)
238 {
239     String errorMessage = makeString(errorDescriptionForValue(exec, value)->value(exec), ' ', message);
240     JSObject* exception = createTypeError(exec, errorMessage, appender, runtimeTypeForValue(value));
241     ASSERT(exception->isErrorInstance());
242     return exception;
243 }
244
245 JSObject* createInvalidFunctionApplyParameterError(ExecState* exec, JSValue value)
246 {
247     JSObject* exception = createTypeError(exec, makeString("second argument to Function.prototype.apply must be an Array-like object"), defaultSourceAppender, runtimeTypeForValue(value));
248     ASSERT(exception->isErrorInstance());
249     return exception;
250 }
251
252 JSObject* createInvalidInParameterError(ExecState* exec, JSValue value)
253 {
254     return createError(exec, value, makeString("is not an Object."), invalidParameterInSourceAppender);
255 }
256
257 JSObject* createInvalidInstanceofParameterError(ExecState* exec, JSValue value)
258 {
259     return createError(exec, value, makeString("is not a function."), invalidParameterInstanceofSourceAppender);
260 }
261
262 JSObject* createNotAConstructorError(ExecState* exec, JSValue value)
263 {
264     return createError(exec, value, ASCIILiteral("is not a constructor"), defaultSourceAppender);
265 }
266
267 JSObject* createNotAFunctionError(ExecState* exec, JSValue value)
268 {
269     return createError(exec, value, ASCIILiteral("is not a function"), notAFunctionSourceAppender);
270 }
271
272 JSObject* createNotAnObjectError(ExecState* exec, JSValue value)
273 {
274     return createError(exec, value, ASCIILiteral("is not an object"), defaultSourceAppender);
275 }
276
277 JSObject* createErrorForInvalidGlobalAssignment(ExecState* exec, const String& propertyName)
278 {
279     return createReferenceError(exec, makeString("Strict mode forbids implicit creation of global property '", propertyName, '\''));
280 }
281
282 JSObject* throwOutOfMemoryError(ExecState* exec)
283 {
284     return exec->vm().throwException(exec, createOutOfMemoryError(exec));
285 }
286
287 JSObject* throwStackOverflowError(ExecState* exec)
288 {
289     VM& vm = exec->vm();
290     ErrorHandlingScope errorScope(vm);
291     return vm.throwException(exec, createStackOverflowError(exec));
292 }
293
294 JSObject* throwTerminatedExecutionException(ExecState* exec)
295 {
296     VM& vm = exec->vm();
297     ErrorHandlingScope errorScope(vm);
298     return vm.throwException(exec, createTerminatedExecutionException(&vm));
299 }
300
301 } // namespace JSC