Refactor static getter function prototype to include thisValue in addition to the...
[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 "Operations.h"
34 #include "RegExpConstructor.h"
35 #include "RegExpMatchesArray.h"
36 #include "RegExpPrototype.h"
37 #include <wtf/PassOwnPtr.h>
38 #include <wtf/text/StringBuilder.h>
39
40 namespace JSC {
41
42 static EncodedJSValue regExpObjectGlobal(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
43 static EncodedJSValue regExpObjectIgnoreCase(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
44 static EncodedJSValue regExpObjectMultiline(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
45 static EncodedJSValue regExpObjectSource(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
46
47 } // namespace JSC
48
49 #include "RegExpObject.lut.h"
50
51 namespace JSC {
52
53 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(RegExpObject);
54
55 const ClassInfo RegExpObject::s_info = { "RegExp", &Base::s_info, 0, ExecState::regExpTable, CREATE_METHOD_TABLE(RegExpObject) };
56
57 /* Source for RegExpObject.lut.h
58 @begin regExpTable
59     global        regExpObjectGlobal       DontDelete|ReadOnly|DontEnum
60     ignoreCase    regExpObjectIgnoreCase   DontDelete|ReadOnly|DontEnum
61     multiline     regExpObjectMultiline    DontDelete|ReadOnly|DontEnum
62     source        regExpObjectSource       DontDelete|ReadOnly|DontEnum
63 @end
64 */
65
66 RegExpObject::RegExpObject(VM& vm, Structure* structure, RegExp* regExp)
67     : JSNonFinalObject(vm, structure)
68     , m_regExp(vm, this, regExp)
69     , m_lastIndexIsWritable(true)
70 {
71     m_lastIndex.setWithoutWriteBarrier(jsNumber(0));
72 }
73
74 void RegExpObject::finishCreation(VM& vm)
75 {
76     Base::finishCreation(vm);
77     ASSERT(inherits(info()));
78 }
79
80 void RegExpObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
81 {
82     RegExpObject* thisObject = jsCast<RegExpObject*>(cell);
83     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
84     COMPILE_ASSERT(StructureFlags & OverridesVisitChildren, OverridesVisitChildrenWithoutSettingFlag);
85     ASSERT(thisObject->structure()->typeInfo().overridesVisitChildren());
86
87     Base::visitChildren(thisObject, visitor);
88     visitor.append(&thisObject->m_regExp);
89     visitor.append(&thisObject->m_lastIndex);
90 }
91
92 bool RegExpObject::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
93 {
94     if (propertyName == exec->propertyNames().lastIndex) {
95         RegExpObject* regExp = asRegExpObject(object);
96         unsigned attributes = regExp->m_lastIndexIsWritable ? DontDelete | DontEnum : DontDelete | DontEnum | ReadOnly;
97         slot.setValue(regExp, attributes, regExp->getLastIndex());
98         return true;
99     }
100     return getStaticValueSlot<RegExpObject, JSObject>(exec, ExecState::regExpTable(exec), jsCast<RegExpObject*>(object), propertyName, slot);
101 }
102
103 bool RegExpObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
104 {
105     if (propertyName == exec->propertyNames().lastIndex)
106         return false;
107     return Base::deleteProperty(cell, exec, propertyName);
108 }
109
110 void RegExpObject::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
111 {
112     if (mode == IncludeDontEnumProperties)
113         propertyNames.add(exec->propertyNames().lastIndex);
114     Base::getOwnNonIndexPropertyNames(object, exec, propertyNames, mode);
115 }
116
117 void RegExpObject::getPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
118 {
119     if (mode == IncludeDontEnumProperties)
120         propertyNames.add(exec->propertyNames().lastIndex);
121     Base::getPropertyNames(object, exec, propertyNames, mode);
122 }
123
124 static bool reject(ExecState* exec, bool throwException, const char* message)
125 {
126     if (throwException)
127         throwTypeError(exec, ASCIILiteral(message));
128     return false;
129 }
130
131 bool RegExpObject::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool shouldThrow)
132 {
133     if (propertyName == exec->propertyNames().lastIndex) {
134         RegExpObject* regExp = asRegExpObject(object);
135         if (descriptor.configurablePresent() && descriptor.configurable())
136             return reject(exec, shouldThrow, "Attempting to change configurable attribute of unconfigurable property.");
137         if (descriptor.enumerablePresent() && descriptor.enumerable())
138             return reject(exec, shouldThrow, "Attempting to change enumerable attribute of unconfigurable property.");
139         if (descriptor.isAccessorDescriptor())
140             return reject(exec, shouldThrow, "Attempting to change access mechanism for an unconfigurable property.");
141         if (!regExp->m_lastIndexIsWritable) {
142             if (descriptor.writablePresent() && descriptor.writable())
143                 return reject(exec, shouldThrow, "Attempting to change writable attribute of unconfigurable property.");
144             if (!sameValue(exec, regExp->getLastIndex(), descriptor.value()))
145                 return reject(exec, shouldThrow, "Attempting to change value of a readonly property.");
146             return true;
147         }
148         if (descriptor.writablePresent() && !descriptor.writable())
149             regExp->m_lastIndexIsWritable = false;
150         if (descriptor.value())
151             regExp->setLastIndex(exec, descriptor.value(), false);
152         return true;
153     }
154
155     return Base::defineOwnProperty(object, exec, propertyName, descriptor, shouldThrow);
156 }
157
158 static inline RegExpObject* asRegExpObject(EncodedJSValue value)
159 {
160     return jsCast<RegExpObject*>(JSValue::decode(value));
161 }
162
163 EncodedJSValue regExpObjectGlobal(ExecState*, EncodedJSValue slotBase, EncodedJSValue, PropertyName)
164 {
165     return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->global()));
166 }
167
168 EncodedJSValue regExpObjectIgnoreCase(ExecState*, EncodedJSValue slotBase, EncodedJSValue, PropertyName)
169 {
170     return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->ignoreCase()));
171 }
172  
173 EncodedJSValue regExpObjectMultiline(ExecState*, EncodedJSValue slotBase, EncodedJSValue, PropertyName)
174 {            
175     return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->multiline()));
176 }
177
178 template <typename CharacterType>
179 static inline void appendLineTerminatorEscape(StringBuilder&, CharacterType);
180
181 template <>
182 inline void appendLineTerminatorEscape<LChar>(StringBuilder& builder, LChar lineTerminator)
183 {
184     if (lineTerminator == '\n')
185         builder.append('n');
186     else
187         builder.append('r');
188 }
189
190 template <>
191 inline void appendLineTerminatorEscape<UChar>(StringBuilder& builder, UChar lineTerminator)
192 {
193     if (lineTerminator == '\n')
194         builder.append('n');
195     else if (lineTerminator == '\r')
196         builder.append('r');
197     else if (lineTerminator == 0x2028)
198         builder.appendLiteral("u2028");
199     else
200         builder.appendLiteral("u2029");
201 }
202
203 template <typename CharacterType>
204 static inline JSValue regExpObjectSourceInternal(ExecState* exec, String pattern, const CharacterType* characters, unsigned length)
205 {
206     bool previousCharacterWasBackslash = false;
207     bool inBrackets = false;
208     bool shouldEscape = false;
209
210     // 15.10.6.4 specifies that RegExp.prototype.toString must return '/' + source + '/',
211     // and also states that the result must be a valid RegularExpressionLiteral. '//' is
212     // not a valid RegularExpressionLiteral (since it is a single line comment), and hence
213     // source cannot ever validly be "". If the source is empty, return a different Pattern
214     // that would match the same thing.
215     if (!length)
216         return jsNontrivialString(exec, ASCIILiteral("(?:)"));
217
218     // early return for strings that don't contain a forwards slash and LineTerminator
219     for (unsigned i = 0; i < length; ++i) {
220         CharacterType ch = characters[i];
221         if (!previousCharacterWasBackslash) {
222             if (inBrackets) {
223                 if (ch == ']')
224                     inBrackets = false;
225             } else {
226                 if (ch == '/') {
227                     shouldEscape = true;
228                     break;
229                 }
230                 if (ch == '[')
231                     inBrackets = true;
232             }
233         }
234
235         if (Lexer<CharacterType>::isLineTerminator(ch)) {
236             shouldEscape = true;
237             break;
238         }
239
240         if (previousCharacterWasBackslash)
241             previousCharacterWasBackslash = false;
242         else
243             previousCharacterWasBackslash = ch == '\\';
244     }
245
246     if (!shouldEscape)
247         return jsString(exec, pattern);
248
249     previousCharacterWasBackslash = false;
250     inBrackets = false;
251     StringBuilder result;
252     for (unsigned i = 0; i < length; ++i) {
253         CharacterType ch = characters[i];
254         if (!previousCharacterWasBackslash) {
255             if (inBrackets) {
256                 if (ch == ']')
257                     inBrackets = false;
258             } else {
259                 if (ch == '/')
260                     result.append('\\');
261                 else if (ch == '[')
262                     inBrackets = true;
263             }
264         }
265
266         // escape LineTerminator
267         if (Lexer<CharacterType>::isLineTerminator(ch)) {
268             if (!previousCharacterWasBackslash)
269                 result.append('\\');
270
271             appendLineTerminatorEscape<CharacterType>(result, ch);
272         } else
273             result.append(ch);
274
275         if (previousCharacterWasBackslash)
276             previousCharacterWasBackslash = false;
277         else
278             previousCharacterWasBackslash = ch == '\\';
279     }
280
281     return jsString(exec, result.toString());
282 }
283
284     
285     
286 EncodedJSValue regExpObjectSource(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue, PropertyName)
287 {
288     String pattern = asRegExpObject(slotBase)->regExp()->pattern();
289     if (pattern.is8Bit())
290         return JSValue::encode(regExpObjectSourceInternal(exec, pattern, pattern.characters8(), pattern.length()));
291     return JSValue::encode(regExpObjectSourceInternal(exec, pattern, pattern.characters16(), pattern.length()));
292 }
293
294 void RegExpObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
295 {
296     if (propertyName == exec->propertyNames().lastIndex) {
297         asRegExpObject(cell)->setLastIndex(exec, value, slot.isStrictMode());
298         return;
299     }
300     lookupPut<RegExpObject, JSObject>(exec, propertyName, value, ExecState::regExpTable(exec), jsCast<RegExpObject*>(cell), slot);
301 }
302
303 JSValue RegExpObject::exec(ExecState* exec, JSString* string)
304 {
305     if (MatchResult result = match(exec, string))
306         return RegExpMatchesArray::create(exec, string, regExp(), result);
307     return jsNull();
308 }
309
310 // Shared implementation used by test and exec.
311 MatchResult RegExpObject::match(ExecState* exec, JSString* string)
312 {
313     RegExp* regExp = this->regExp();
314     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
315     String input = string->value(exec);
316     VM& vm = exec->vm();
317     if (!regExp->global())
318         return regExpConstructor->performMatch(vm, regExp, string, input, 0);
319
320     JSValue jsLastIndex = getLastIndex();
321     unsigned lastIndex;
322     if (LIKELY(jsLastIndex.isUInt32())) {
323         lastIndex = jsLastIndex.asUInt32();
324         if (lastIndex > input.length()) {
325             setLastIndex(exec, 0);
326             return MatchResult::failed();
327         }
328     } else {
329         double doubleLastIndex = jsLastIndex.toInteger(exec);
330         if (doubleLastIndex < 0 || doubleLastIndex > input.length()) {
331             setLastIndex(exec, 0);
332             return MatchResult::failed();
333         }
334         lastIndex = static_cast<unsigned>(doubleLastIndex);
335     }
336
337     MatchResult result = regExpConstructor->performMatch(vm, regExp, string, input, lastIndex);
338     setLastIndex(exec, result.end);
339     return result;
340 }
341
342 } // namespace JSC