putByIndex should throw in strict mode
[WebKit-https.git] / Source / JavaScriptCore / runtime / RegExpConstructor.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2003, 2007, 2008 Apple Inc. All Rights Reserved.
4  *  Copyright (C) 2009 Torch Mobile, Inc.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #include "config.h"
23 #include "RegExpConstructor.h"
24
25 #include "ArrayPrototype.h"
26 #include "Error.h"
27 #include "ExceptionHelpers.h"
28 #include "JSArray.h"
29 #include "JSFunction.h"
30 #include "JSString.h"
31 #include "Lookup.h"
32 #include "ObjectPrototype.h"
33 #include "RegExpMatchesArray.h"
34 #include "RegExpObject.h"
35 #include "RegExpPrototype.h"
36 #include "RegExp.h"
37 #include "RegExpCache.h"
38 #include "UStringConcatenate.h"
39 #include <wtf/PassOwnPtr.h>
40
41 namespace JSC {
42
43 static JSValue regExpConstructorInput(ExecState*, JSValue, const Identifier&);
44 static JSValue regExpConstructorMultiline(ExecState*, JSValue, const Identifier&);
45 static JSValue regExpConstructorLastMatch(ExecState*, JSValue, const Identifier&);
46 static JSValue regExpConstructorLastParen(ExecState*, JSValue, const Identifier&);
47 static JSValue regExpConstructorLeftContext(ExecState*, JSValue, const Identifier&);
48 static JSValue regExpConstructorRightContext(ExecState*, JSValue, const Identifier&);
49 static JSValue regExpConstructorDollar1(ExecState*, JSValue, const Identifier&);
50 static JSValue regExpConstructorDollar2(ExecState*, JSValue, const Identifier&);
51 static JSValue regExpConstructorDollar3(ExecState*, JSValue, const Identifier&);
52 static JSValue regExpConstructorDollar4(ExecState*, JSValue, const Identifier&);
53 static JSValue regExpConstructorDollar5(ExecState*, JSValue, const Identifier&);
54 static JSValue regExpConstructorDollar6(ExecState*, JSValue, const Identifier&);
55 static JSValue regExpConstructorDollar7(ExecState*, JSValue, const Identifier&);
56 static JSValue regExpConstructorDollar8(ExecState*, JSValue, const Identifier&);
57 static JSValue regExpConstructorDollar9(ExecState*, JSValue, const Identifier&);
58
59 static void setRegExpConstructorInput(ExecState*, JSObject*, JSValue);
60 static void setRegExpConstructorMultiline(ExecState*, JSObject*, JSValue);
61
62 } // namespace JSC
63
64 #include "RegExpConstructor.lut.h"
65
66 namespace JSC {
67
68 ASSERT_CLASS_FITS_IN_CELL(RegExpConstructor);
69
70 const ClassInfo RegExpConstructor::s_info = { "Function", &InternalFunction::s_info, 0, ExecState::regExpConstructorTable, CREATE_METHOD_TABLE(RegExpConstructor) };
71
72 const ClassInfo RegExpMatchesArray::s_info = {"Array", &JSArray::s_info, 0, 0, CREATE_METHOD_TABLE(RegExpMatchesArray)};
73
74 /* Source for RegExpConstructor.lut.h
75 @begin regExpConstructorTable
76     input           regExpConstructorInput          None
77     $_              regExpConstructorInput          DontEnum
78     multiline       regExpConstructorMultiline      None
79     $*              regExpConstructorMultiline      DontEnum
80     lastMatch       regExpConstructorLastMatch      DontDelete|ReadOnly
81     $&              regExpConstructorLastMatch      DontDelete|ReadOnly|DontEnum
82     lastParen       regExpConstructorLastParen      DontDelete|ReadOnly
83     $+              regExpConstructorLastParen      DontDelete|ReadOnly|DontEnum
84     leftContext     regExpConstructorLeftContext    DontDelete|ReadOnly
85     $`              regExpConstructorLeftContext    DontDelete|ReadOnly|DontEnum
86     rightContext    regExpConstructorRightContext   DontDelete|ReadOnly
87     $'              regExpConstructorRightContext   DontDelete|ReadOnly|DontEnum
88     $1              regExpConstructorDollar1        DontDelete|ReadOnly
89     $2              regExpConstructorDollar2        DontDelete|ReadOnly
90     $3              regExpConstructorDollar3        DontDelete|ReadOnly
91     $4              regExpConstructorDollar4        DontDelete|ReadOnly
92     $5              regExpConstructorDollar5        DontDelete|ReadOnly
93     $6              regExpConstructorDollar6        DontDelete|ReadOnly
94     $7              regExpConstructorDollar7        DontDelete|ReadOnly
95     $8              regExpConstructorDollar8        DontDelete|ReadOnly
96     $9              regExpConstructorDollar9        DontDelete|ReadOnly
97 @end
98 */
99
100 RegExpResult& RegExpResult::operator=(const RegExpConstructorPrivate& rhs)
101 {
102     this->input = rhs.input;
103     this->ovector = rhs.lastOvector();
104     this->lastNumSubPatterns = rhs.lastNumSubPatterns;
105     
106     return *this;            
107 }
108
109
110 RegExpConstructor::RegExpConstructor(JSGlobalObject* globalObject, Structure* structure)
111     : InternalFunction(globalObject, structure)
112 {
113 }
114
115 void RegExpConstructor::finishCreation(ExecState* exec, RegExpPrototype* regExpPrototype)
116 {
117     Base::finishCreation(exec->globalData(), Identifier(exec, "RegExp"));
118     ASSERT(inherits(&s_info));
119
120     // ECMA 15.10.5.1 RegExp.prototype
121     putDirectWithoutTransition(exec->globalData(), exec->propertyNames().prototype, regExpPrototype, DontEnum | DontDelete | ReadOnly);
122
123     // no. of arguments for constructor
124     putDirectWithoutTransition(exec->globalData(), exec->propertyNames().length, jsNumber(2), ReadOnly | DontDelete | DontEnum);
125 }
126
127 void RegExpConstructor::destroy(JSCell* cell)
128 {
129     jsCast<RegExpConstructor*>(cell)->RegExpConstructor::~RegExpConstructor();
130 }
131
132 RegExpMatchesArray::RegExpMatchesArray(ExecState* exec)
133     : JSArray(exec->globalData(), exec->lexicalGlobalObject()->regExpMatchesArrayStructure())
134     , m_didFillArrayInstance(false)
135 {
136 }
137
138 void RegExpMatchesArray::finishCreation(JSGlobalData& globalData, const RegExpConstructorPrivate& data)
139 {
140     Base::finishCreation(globalData, data.lastNumSubPatterns + 1);
141     m_regExpResult = data;
142 }
143
144 void RegExpMatchesArray::destroy(JSCell* cell)
145 {
146     jsCast<RegExpMatchesArray*>(cell)->RegExpMatchesArray::~RegExpMatchesArray();
147 }
148
149 void RegExpMatchesArray::fillArrayInstance(ExecState* exec)
150 {
151     unsigned lastNumSubpatterns = m_regExpResult.lastNumSubPatterns;
152
153     for (unsigned i = 0; i <= lastNumSubpatterns; ++i) {
154         int start = m_regExpResult.ovector[2 * i];
155         if (start >= 0)
156             putDirectIndex(exec, i, jsSubstring(exec, m_regExpResult.input, start, m_regExpResult.ovector[2 * i + 1] - start), false);
157         else
158             putDirectIndex(exec, i, jsUndefined(), false);
159     }
160
161     PutPropertySlot slot;
162     JSArray::put(this, exec, exec->propertyNames().index, jsNumber(m_regExpResult.ovector[0]), slot);
163     JSArray::put(this, exec, exec->propertyNames().input, jsString(exec, m_regExpResult.input), slot);
164
165     m_didFillArrayInstance = true;
166 }
167
168 JSObject* RegExpConstructor::arrayOfMatches(ExecState* exec) const
169 {
170     return RegExpMatchesArray::create(exec, d);
171 }
172
173 JSValue RegExpConstructor::getBackref(ExecState* exec, unsigned i) const
174 {
175     if (!d.lastOvector().isEmpty() && i <= d.lastNumSubPatterns) {
176         int start = d.lastOvector()[2 * i];
177         if (start >= 0)
178             return jsSubstring(exec, d.lastInput, start, d.lastOvector()[2 * i + 1] - start);
179     }
180     return jsEmptyString(exec);
181 }
182
183 JSValue RegExpConstructor::getLastParen(ExecState* exec) const
184 {
185     unsigned i = d.lastNumSubPatterns;
186     if (i > 0) {
187         ASSERT(!d.lastOvector().isEmpty());
188         int start = d.lastOvector()[2 * i];
189         if (start >= 0)
190             return jsSubstring(exec, d.lastInput, start, d.lastOvector()[2 * i + 1] - start);
191     }
192     return jsEmptyString(exec);
193 }
194
195 JSValue RegExpConstructor::getLeftContext(ExecState* exec) const
196 {
197     if (!d.lastOvector().isEmpty())
198         return jsSubstring(exec, d.lastInput, 0, d.lastOvector()[0]);
199     return jsEmptyString(exec);
200 }
201
202 JSValue RegExpConstructor::getRightContext(ExecState* exec) const
203 {
204     if (!d.lastOvector().isEmpty())
205         return jsSubstring(exec, d.lastInput, d.lastOvector()[1], d.lastInput.length() - d.lastOvector()[1]);
206     return jsEmptyString(exec);
207 }
208     
209 bool RegExpConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
210 {
211     return getStaticValueSlot<RegExpConstructor, InternalFunction>(exec, ExecState::regExpConstructorTable(exec), jsCast<RegExpConstructor*>(cell), propertyName, slot);
212 }
213
214 bool RegExpConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
215 {
216     return getStaticValueDescriptor<RegExpConstructor, InternalFunction>(exec, ExecState::regExpConstructorTable(exec), jsCast<RegExpConstructor*>(object), propertyName, descriptor);
217 }
218
219 JSValue regExpConstructorDollar1(ExecState* exec, JSValue slotBase, const Identifier&)
220 {
221     return asRegExpConstructor(slotBase)->getBackref(exec, 1);
222 }
223
224 JSValue regExpConstructorDollar2(ExecState* exec, JSValue slotBase, const Identifier&)
225 {
226     return asRegExpConstructor(slotBase)->getBackref(exec, 2);
227 }
228
229 JSValue regExpConstructorDollar3(ExecState* exec, JSValue slotBase, const Identifier&)
230 {
231     return asRegExpConstructor(slotBase)->getBackref(exec, 3);
232 }
233
234 JSValue regExpConstructorDollar4(ExecState* exec, JSValue slotBase, const Identifier&)
235 {
236     return asRegExpConstructor(slotBase)->getBackref(exec, 4);
237 }
238
239 JSValue regExpConstructorDollar5(ExecState* exec, JSValue slotBase, const Identifier&)
240 {
241     return asRegExpConstructor(slotBase)->getBackref(exec, 5);
242 }
243
244 JSValue regExpConstructorDollar6(ExecState* exec, JSValue slotBase, const Identifier&)
245 {
246     return asRegExpConstructor(slotBase)->getBackref(exec, 6);
247 }
248
249 JSValue regExpConstructorDollar7(ExecState* exec, JSValue slotBase, const Identifier&)
250 {
251     return asRegExpConstructor(slotBase)->getBackref(exec, 7);
252 }
253
254 JSValue regExpConstructorDollar8(ExecState* exec, JSValue slotBase, const Identifier&)
255 {
256     return asRegExpConstructor(slotBase)->getBackref(exec, 8);
257 }
258
259 JSValue regExpConstructorDollar9(ExecState* exec, JSValue slotBase, const Identifier&)
260 {
261     return asRegExpConstructor(slotBase)->getBackref(exec, 9);
262 }
263
264 JSValue regExpConstructorInput(ExecState* exec, JSValue slotBase, const Identifier&)
265 {
266     return jsString(exec, asRegExpConstructor(slotBase)->input());
267 }
268
269 JSValue regExpConstructorMultiline(ExecState*, JSValue slotBase, const Identifier&)
270 {
271     return jsBoolean(asRegExpConstructor(slotBase)->multiline());
272 }
273
274 JSValue regExpConstructorLastMatch(ExecState* exec, JSValue slotBase, const Identifier&)
275 {
276     return asRegExpConstructor(slotBase)->getBackref(exec, 0);
277 }
278
279 JSValue regExpConstructorLastParen(ExecState* exec, JSValue slotBase, const Identifier&)
280 {
281     return asRegExpConstructor(slotBase)->getLastParen(exec);
282 }
283
284 JSValue regExpConstructorLeftContext(ExecState* exec, JSValue slotBase, const Identifier&)
285 {
286     return asRegExpConstructor(slotBase)->getLeftContext(exec);
287 }
288
289 JSValue regExpConstructorRightContext(ExecState* exec, JSValue slotBase, const Identifier&)
290 {
291     return asRegExpConstructor(slotBase)->getRightContext(exec);
292 }
293
294 void RegExpConstructor::put(JSCell* cell, ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
295 {
296     lookupPut<RegExpConstructor, InternalFunction>(exec, propertyName, value, ExecState::regExpConstructorTable(exec), jsCast<RegExpConstructor*>(cell), slot);
297 }
298
299 void setRegExpConstructorInput(ExecState* exec, JSObject* baseObject, JSValue value)
300 {
301     asRegExpConstructor(baseObject)->setInput(value.toString(exec)->value(exec));
302 }
303
304 void setRegExpConstructorMultiline(ExecState* exec, JSObject* baseObject, JSValue value)
305 {
306     asRegExpConstructor(baseObject)->setMultiline(value.toBoolean(exec));
307 }
308
309 // ECMA 15.10.4
310 JSObject* constructRegExp(ExecState* exec, JSGlobalObject* globalObject, const ArgList& args, bool callAsConstructor)
311 {
312     JSValue arg0 = args.at(0);
313     JSValue arg1 = args.at(1);
314
315     if (arg0.inherits(&RegExpObject::s_info)) {
316         if (!arg1.isUndefined())
317             return throwError(exec, createTypeError(exec, "Cannot supply flags when constructing one RegExp from another."));
318         // If called as a function, this just returns the first argument (see 15.10.3.1).
319         if (callAsConstructor) {
320             RegExp* regExp = static_cast<RegExpObject*>(asObject(arg0))->regExp();
321             return RegExpObject::create(exec, globalObject, globalObject->regExpStructure(), regExp);
322         }
323         return asObject(arg0);
324     }
325
326     UString pattern = arg0.isUndefined() ? UString("") : arg0.toString(exec)->value(exec);
327     if (exec->hadException())
328         return 0;
329
330     RegExpFlags flags = NoFlags;
331     if (!arg1.isUndefined()) {
332         flags = regExpFlags(arg1.toString(exec)->value(exec));
333         if (exec->hadException())
334             return 0;
335         if (flags == InvalidFlags)
336             return throwError(exec, createSyntaxError(exec, "Invalid flags supplied to RegExp constructor."));
337     }
338
339     RegExp* regExp = RegExp::create(exec->globalData(), pattern, flags);
340     if (!regExp->isValid())
341         return throwError(exec, createSyntaxError(exec, regExp->errorMessage()));
342     return RegExpObject::create(exec, exec->lexicalGlobalObject(), globalObject->regExpStructure(), regExp);
343 }
344
345 static EncodedJSValue JSC_HOST_CALL constructWithRegExpConstructor(ExecState* exec)
346 {
347     ArgList args(exec);
348     return JSValue::encode(constructRegExp(exec, asInternalFunction(exec->callee())->globalObject(), args, true));
349 }
350
351 ConstructType RegExpConstructor::getConstructData(JSCell*, ConstructData& constructData)
352 {
353     constructData.native.function = constructWithRegExpConstructor;
354     return ConstructTypeHost;
355 }
356
357 // ECMA 15.10.3
358 static EncodedJSValue JSC_HOST_CALL callRegExpConstructor(ExecState* exec)
359 {
360     ArgList args(exec);
361     return JSValue::encode(constructRegExp(exec, asInternalFunction(exec->callee())->globalObject(), args));
362 }
363
364 CallType RegExpConstructor::getCallData(JSCell*, CallData& callData)
365 {
366     callData.native.function = callRegExpConstructor;
367     return CallTypeHost;
368 }
369
370 void RegExpConstructor::setInput(const UString& input)
371 {
372     d.input = input;
373 }
374
375 const UString& RegExpConstructor::input() const
376 {
377     // Can detect a distinct initial state that is invisible to JavaScript, by checking for null
378     // state (since jsString turns null strings to empty strings).
379     return d.input;
380 }
381
382 void RegExpConstructor::setMultiline(bool multiline)
383 {
384     d.multiline = multiline;
385 }
386
387 bool RegExpConstructor::multiline() const
388 {
389     return d.multiline;
390 }
391
392 } // namespace JSC