Pass String as reference in more places
[WebKit-https.git] / Source / JavaScriptCore / runtime / RegExpObject.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2003, 2007, 2008, 2012 Apple Inc. All Rights Reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #include "config.h"
22 #include "RegExpObject.h"
23
24 #include "ButterflyInlines.h"
25 #include "CopiedSpaceInlines.h"
26 #include "Error.h"
27 #include "ExceptionHelpers.h"
28 #include "JSArray.h"
29 #include "JSGlobalObject.h"
30 #include "JSString.h"
31 #include "Lexer.h"
32 #include "Lookup.h"
33 #include "JSCInlines.h"
34 #include "RegExpConstructor.h"
35 #include "RegExpMatchesArray.h"
36 #include "RegExpPrototype.h"
37 #include <wtf/text/StringBuilder.h>
38
39 namespace JSC {
40
41 static EncodedJSValue regExpObjectGlobal(ExecState*, JSObject*, EncodedJSValue, PropertyName);
42 static EncodedJSValue regExpObjectIgnoreCase(ExecState*, JSObject*, EncodedJSValue, PropertyName);
43 static EncodedJSValue regExpObjectMultiline(ExecState*, JSObject*, EncodedJSValue, PropertyName);
44 static EncodedJSValue regExpObjectSource(ExecState*, JSObject*, EncodedJSValue, PropertyName);
45
46 } // namespace JSC
47
48 #include "RegExpObject.lut.h"
49
50 namespace JSC {
51
52 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(RegExpObject);
53
54 const ClassInfo RegExpObject::s_info = { "RegExp", &Base::s_info, &regExpTable, CREATE_METHOD_TABLE(RegExpObject) };
55
56 /* Source for RegExpObject.lut.h
57 @begin regExpTable
58     global        regExpObjectGlobal       DontDelete|ReadOnly|DontEnum
59     ignoreCase    regExpObjectIgnoreCase   DontDelete|ReadOnly|DontEnum
60     multiline     regExpObjectMultiline    DontDelete|ReadOnly|DontEnum
61     source        regExpObjectSource       DontDelete|ReadOnly|DontEnum
62 @end
63 */
64
65 RegExpObject::RegExpObject(VM& vm, Structure* structure, RegExp* regExp)
66     : JSNonFinalObject(vm, structure)
67     , m_regExp(vm, this, regExp)
68     , m_lastIndexIsWritable(true)
69 {
70     m_lastIndex.setWithoutWriteBarrier(jsNumber(0));
71 }
72
73 void RegExpObject::finishCreation(VM& vm)
74 {
75     Base::finishCreation(vm);
76     ASSERT(inherits(info()));
77 }
78
79 void RegExpObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
80 {
81     RegExpObject* thisObject = jsCast<RegExpObject*>(cell);
82     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
83     Base::visitChildren(thisObject, visitor);
84     visitor.append(&thisObject->m_regExp);
85     visitor.append(&thisObject->m_lastIndex);
86 }
87
88 bool RegExpObject::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
89 {
90     if (propertyName == exec->propertyNames().lastIndex) {
91         RegExpObject* regExp = asRegExpObject(object);
92         unsigned attributes = regExp->m_lastIndexIsWritable ? DontDelete | DontEnum : DontDelete | DontEnum | ReadOnly;
93         slot.setValue(regExp, attributes, regExp->getLastIndex());
94         return true;
95     }
96     return getStaticValueSlot<RegExpObject, JSObject>(exec, regExpTable, jsCast<RegExpObject*>(object), propertyName, slot);
97 }
98
99 bool RegExpObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
100 {
101     if (propertyName == exec->propertyNames().lastIndex)
102         return false;
103     return Base::deleteProperty(cell, exec, propertyName);
104 }
105
106 void RegExpObject::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
107 {
108     if (mode.includeDontEnumProperties())
109         propertyNames.add(exec->propertyNames().lastIndex);
110     Base::getOwnNonIndexPropertyNames(object, exec, propertyNames, mode);
111 }
112
113 void RegExpObject::getPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
114 {
115     if (mode.includeDontEnumProperties())
116         propertyNames.add(exec->propertyNames().lastIndex);
117     Base::getPropertyNames(object, exec, propertyNames, mode);
118 }
119
120 void RegExpObject::getGenericPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
121 {
122     if (mode.includeDontEnumProperties())
123         propertyNames.add(exec->propertyNames().lastIndex);
124     Base::getGenericPropertyNames(object, exec, propertyNames, mode);
125 }
126
127 static bool reject(ExecState* exec, bool throwException, const char* message)
128 {
129     if (throwException)
130         throwTypeError(exec, ASCIILiteral(message));
131     return false;
132 }
133
134 bool RegExpObject::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool shouldThrow)
135 {
136     if (propertyName == exec->propertyNames().lastIndex) {
137         RegExpObject* regExp = asRegExpObject(object);
138         if (descriptor.configurablePresent() && descriptor.configurable())
139             return reject(exec, shouldThrow, "Attempting to change configurable attribute of unconfigurable property.");
140         if (descriptor.enumerablePresent() && descriptor.enumerable())
141             return reject(exec, shouldThrow, "Attempting to change enumerable attribute of unconfigurable property.");
142         if (descriptor.isAccessorDescriptor())
143             return reject(exec, shouldThrow, "Attempting to change access mechanism for an unconfigurable property.");
144         if (!regExp->m_lastIndexIsWritable) {
145             if (descriptor.writablePresent() && descriptor.writable())
146                 return reject(exec, shouldThrow, "Attempting to change writable attribute of unconfigurable property.");
147             if (!sameValue(exec, regExp->getLastIndex(), descriptor.value()))
148                 return reject(exec, shouldThrow, "Attempting to change value of a readonly property.");
149             return true;
150         }
151         if (descriptor.writablePresent() && !descriptor.writable())
152             regExp->m_lastIndexIsWritable = false;
153         if (descriptor.value())
154             regExp->setLastIndex(exec, descriptor.value(), false);
155         return true;
156     }
157
158     return Base::defineOwnProperty(object, exec, propertyName, descriptor, shouldThrow);
159 }
160
161 EncodedJSValue regExpObjectGlobal(ExecState*, JSObject* slotBase, EncodedJSValue, PropertyName)
162 {
163     return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->global()));
164 }
165
166 EncodedJSValue regExpObjectIgnoreCase(ExecState*, JSObject* slotBase, EncodedJSValue, PropertyName)
167 {
168     return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->ignoreCase()));
169 }
170  
171 EncodedJSValue regExpObjectMultiline(ExecState*, JSObject* slotBase, EncodedJSValue, PropertyName)
172 {            
173     return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->multiline()));
174 }
175
176 template <typename CharacterType>
177 static inline void appendLineTerminatorEscape(StringBuilder&, CharacterType);
178
179 template <>
180 inline void appendLineTerminatorEscape<LChar>(StringBuilder& builder, LChar lineTerminator)
181 {
182     if (lineTerminator == '\n')
183         builder.append('n');
184     else
185         builder.append('r');
186 }
187
188 template <>
189 inline void appendLineTerminatorEscape<UChar>(StringBuilder& builder, UChar lineTerminator)
190 {
191     if (lineTerminator == '\n')
192         builder.append('n');
193     else if (lineTerminator == '\r')
194         builder.append('r');
195     else if (lineTerminator == 0x2028)
196         builder.appendLiteral("u2028");
197     else
198         builder.appendLiteral("u2029");
199 }
200
201 template <typename CharacterType>
202 static inline JSValue regExpObjectSourceInternal(ExecState* exec, const String& pattern, const CharacterType* characters, unsigned length)
203 {
204     bool previousCharacterWasBackslash = false;
205     bool inBrackets = false;
206     bool shouldEscape = false;
207
208     // 15.10.6.4 specifies that RegExp.prototype.toString must return '/' + source + '/',
209     // and also states that the result must be a valid RegularExpressionLiteral. '//' is
210     // not a valid RegularExpressionLiteral (since it is a single line comment), and hence
211     // source cannot ever validly be "". If the source is empty, return a different Pattern
212     // that would match the same thing.
213     if (!length)
214         return jsNontrivialString(exec, ASCIILiteral("(?:)"));
215
216     // early return for strings that don't contain a forwards slash and LineTerminator
217     for (unsigned i = 0; i < length; ++i) {
218         CharacterType ch = characters[i];
219         if (!previousCharacterWasBackslash) {
220             if (inBrackets) {
221                 if (ch == ']')
222                     inBrackets = false;
223             } else {
224                 if (ch == '/') {
225                     shouldEscape = true;
226                     break;
227                 }
228                 if (ch == '[')
229                     inBrackets = true;
230             }
231         }
232
233         if (Lexer<CharacterType>::isLineTerminator(ch)) {
234             shouldEscape = true;
235             break;
236         }
237
238         if (previousCharacterWasBackslash)
239             previousCharacterWasBackslash = false;
240         else
241             previousCharacterWasBackslash = ch == '\\';
242     }
243
244     if (!shouldEscape)
245         return jsString(exec, pattern);
246
247     previousCharacterWasBackslash = false;
248     inBrackets = false;
249     StringBuilder result;
250     for (unsigned i = 0; i < length; ++i) {
251         CharacterType ch = characters[i];
252         if (!previousCharacterWasBackslash) {
253             if (inBrackets) {
254                 if (ch == ']')
255                     inBrackets = false;
256             } else {
257                 if (ch == '/')
258                     result.append('\\');
259                 else if (ch == '[')
260                     inBrackets = true;
261             }
262         }
263
264         // escape LineTerminator
265         if (Lexer<CharacterType>::isLineTerminator(ch)) {
266             if (!previousCharacterWasBackslash)
267                 result.append('\\');
268
269             appendLineTerminatorEscape<CharacterType>(result, ch);
270         } else
271             result.append(ch);
272
273         if (previousCharacterWasBackslash)
274             previousCharacterWasBackslash = false;
275         else
276             previousCharacterWasBackslash = ch == '\\';
277     }
278
279     return jsString(exec, result.toString());
280 }
281
282     
283     
284 EncodedJSValue regExpObjectSource(ExecState* exec, JSObject* slotBase, EncodedJSValue, PropertyName)
285 {
286     String pattern = asRegExpObject(slotBase)->regExp()->pattern();
287     if (pattern.is8Bit())
288         return JSValue::encode(regExpObjectSourceInternal(exec, pattern, pattern.characters8(), pattern.length()));
289     return JSValue::encode(regExpObjectSourceInternal(exec, pattern, pattern.characters16(), pattern.length()));
290 }
291
292 static void regExpObjectSetLastIndexStrict(ExecState* exec, JSObject* slotBase, EncodedJSValue, EncodedJSValue value)
293 {
294     asRegExpObject(slotBase)->setLastIndex(exec, JSValue::decode(value), true);
295 }
296
297 static void regExpObjectSetLastIndexNonStrict(ExecState* exec, JSObject* slotBase, EncodedJSValue, EncodedJSValue value)
298 {
299     asRegExpObject(slotBase)->setLastIndex(exec, JSValue::decode(value), false);
300 }
301
302 void RegExpObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
303 {
304     if (propertyName == exec->propertyNames().lastIndex) {
305         asRegExpObject(cell)->setLastIndex(exec, value, slot.isStrictMode());
306         slot.setCustomProperty(asRegExpObject(cell), slot.isStrictMode()
307             ? regExpObjectSetLastIndexStrict
308             : regExpObjectSetLastIndexNonStrict);
309         return;
310     }
311     Base::put(cell, exec, propertyName, value, slot);
312 }
313
314 JSValue RegExpObject::exec(ExecState* exec, JSString* string)
315 {
316     if (MatchResult result = match(exec, string))
317         return createRegExpMatchesArray(exec, string, regExp(), result);
318     return jsNull();
319 }
320
321 // Shared implementation used by test and exec.
322 MatchResult RegExpObject::match(ExecState* exec, JSString* string)
323 {
324     RegExp* regExp = this->regExp();
325     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
326     String input = string->value(exec);
327     VM& vm = exec->vm();
328     if (!regExp->global())
329         return regExpConstructor->performMatch(vm, regExp, string, input, 0);
330
331     JSValue jsLastIndex = getLastIndex();
332     unsigned lastIndex;
333     if (LIKELY(jsLastIndex.isUInt32())) {
334         lastIndex = jsLastIndex.asUInt32();
335         if (lastIndex > input.length()) {
336             setLastIndex(exec, 0);
337             return MatchResult::failed();
338         }
339     } else {
340         double doubleLastIndex = jsLastIndex.toInteger(exec);
341         if (doubleLastIndex < 0 || doubleLastIndex > input.length()) {
342             setLastIndex(exec, 0);
343             return MatchResult::failed();
344         }
345         lastIndex = static_cast<unsigned>(doubleLastIndex);
346     }
347
348     MatchResult result = regExpConstructor->performMatch(vm, regExp, string, input, lastIndex);
349     setLastIndex(exec, result.end);
350     return result;
351 }
352
353 } // namespace JSC