2011-01-30 Csaba Osztrogon√°c <ossy@webkit.org>
[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::info = { "Function", &InternalFunction::info, 0, ExecState::regExpConstructorTable };
71
72 /* Source for RegExpConstructor.lut.h
73 @begin regExpConstructorTable
74     input           regExpConstructorInput          None
75     $_              regExpConstructorInput          DontEnum
76     multiline       regExpConstructorMultiline      None
77     $*              regExpConstructorMultiline      DontEnum
78     lastMatch       regExpConstructorLastMatch      DontDelete|ReadOnly
79     $&              regExpConstructorLastMatch      DontDelete|ReadOnly|DontEnum
80     lastParen       regExpConstructorLastParen      DontDelete|ReadOnly
81     $+              regExpConstructorLastParen      DontDelete|ReadOnly|DontEnum
82     leftContext     regExpConstructorLeftContext    DontDelete|ReadOnly
83     $`              regExpConstructorLeftContext    DontDelete|ReadOnly|DontEnum
84     rightContext    regExpConstructorRightContext   DontDelete|ReadOnly
85     $'              regExpConstructorRightContext   DontDelete|ReadOnly|DontEnum
86     $1              regExpConstructorDollar1        DontDelete|ReadOnly
87     $2              regExpConstructorDollar2        DontDelete|ReadOnly
88     $3              regExpConstructorDollar3        DontDelete|ReadOnly
89     $4              regExpConstructorDollar4        DontDelete|ReadOnly
90     $5              regExpConstructorDollar5        DontDelete|ReadOnly
91     $6              regExpConstructorDollar6        DontDelete|ReadOnly
92     $7              regExpConstructorDollar7        DontDelete|ReadOnly
93     $8              regExpConstructorDollar8        DontDelete|ReadOnly
94     $9              regExpConstructorDollar9        DontDelete|ReadOnly
95 @end
96 */
97
98 RegExpConstructor::RegExpConstructor(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, RegExpPrototype* regExpPrototype)
99     : InternalFunction(&exec->globalData(), globalObject, structure, Identifier(exec, "RegExp"))
100     , d(adoptPtr(new RegExpConstructorPrivate))
101 {
102     // ECMA 15.10.5.1 RegExp.prototype
103     putDirectWithoutTransition(exec->propertyNames().prototype, regExpPrototype, DontEnum | DontDelete | ReadOnly);
104
105     // no. of arguments for constructor
106     putDirectWithoutTransition(exec->propertyNames().length, jsNumber(2), ReadOnly | DontDelete | DontEnum);
107 }
108
109 RegExpMatchesArray::RegExpMatchesArray(ExecState* exec, RegExpConstructorPrivate* data)
110     : JSArray(exec->lexicalGlobalObject()->regExpMatchesArrayStructure(), data->lastNumSubPatterns + 1, CreateInitialized)
111 {
112     RegExpConstructorPrivate* d = new RegExpConstructorPrivate;
113     d->input = data->lastInput;
114     d->lastInput = data->lastInput;
115     d->lastNumSubPatterns = data->lastNumSubPatterns;
116     unsigned offsetVectorSize = (data->lastNumSubPatterns + 1) * 2; // only copying the result part of the vector
117     d->lastOvector().resize(offsetVectorSize);
118     memcpy(d->lastOvector().data(), data->lastOvector().data(), offsetVectorSize * sizeof(int));
119     // d->multiline is not needed, and remains uninitialized
120
121     setSubclassData(d);
122 }
123
124 RegExpMatchesArray::~RegExpMatchesArray()
125 {
126     delete static_cast<RegExpConstructorPrivate*>(subclassData());
127 }
128
129 void RegExpMatchesArray::fillArrayInstance(ExecState* exec)
130 {
131     RegExpConstructorPrivate* d = static_cast<RegExpConstructorPrivate*>(subclassData());
132     ASSERT(d);
133
134     unsigned lastNumSubpatterns = d->lastNumSubPatterns;
135
136     for (unsigned i = 0; i <= lastNumSubpatterns; ++i) {
137         int start = d->lastOvector()[2 * i];
138         if (start >= 0)
139             JSArray::put(exec, i, jsSubstring(exec, d->lastInput, start, d->lastOvector()[2 * i + 1] - start));
140         else
141             JSArray::put(exec, i, jsUndefined());
142     }
143
144     PutPropertySlot slot;
145     JSArray::put(exec, exec->propertyNames().index, jsNumber(d->lastOvector()[0]), slot);
146     JSArray::put(exec, exec->propertyNames().input, jsString(exec, d->input), slot);
147
148     delete d;
149     setSubclassData(0);
150 }
151
152 JSObject* RegExpConstructor::arrayOfMatches(ExecState* exec) const
153 {
154     return new (exec) RegExpMatchesArray(exec, d.get());
155 }
156
157 JSValue RegExpConstructor::getBackref(ExecState* exec, unsigned i) const
158 {
159     if (!d->lastOvector().isEmpty() && i <= d->lastNumSubPatterns) {
160         int start = d->lastOvector()[2 * i];
161         if (start >= 0)
162             return jsSubstring(exec, d->lastInput, start, d->lastOvector()[2 * i + 1] - start);
163     }
164     return jsEmptyString(exec);
165 }
166
167 JSValue RegExpConstructor::getLastParen(ExecState* exec) const
168 {
169     unsigned i = d->lastNumSubPatterns;
170     if (i > 0) {
171         ASSERT(!d->lastOvector().isEmpty());
172         int start = d->lastOvector()[2 * i];
173         if (start >= 0)
174             return jsSubstring(exec, d->lastInput, start, d->lastOvector()[2 * i + 1] - start);
175     }
176     return jsEmptyString(exec);
177 }
178
179 JSValue RegExpConstructor::getLeftContext(ExecState* exec) const
180 {
181     if (!d->lastOvector().isEmpty())
182         return jsSubstring(exec, d->lastInput, 0, d->lastOvector()[0]);
183     return jsEmptyString(exec);
184 }
185
186 JSValue RegExpConstructor::getRightContext(ExecState* exec) const
187 {
188     if (!d->lastOvector().isEmpty())
189         return jsSubstring(exec, d->lastInput, d->lastOvector()[1], d->lastInput.length() - d->lastOvector()[1]);
190     return jsEmptyString(exec);
191 }
192     
193 bool RegExpConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
194 {
195     return getStaticValueSlot<RegExpConstructor, InternalFunction>(exec, ExecState::regExpConstructorTable(exec), this, propertyName, slot);
196 }
197
198 bool RegExpConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
199 {
200     return getStaticValueDescriptor<RegExpConstructor, InternalFunction>(exec, ExecState::regExpConstructorTable(exec), this, propertyName, descriptor);
201 }
202
203 JSValue regExpConstructorDollar1(ExecState* exec, JSValue slotBase, const Identifier&)
204 {
205     return asRegExpConstructor(slotBase)->getBackref(exec, 1);
206 }
207
208 JSValue regExpConstructorDollar2(ExecState* exec, JSValue slotBase, const Identifier&)
209 {
210     return asRegExpConstructor(slotBase)->getBackref(exec, 2);
211 }
212
213 JSValue regExpConstructorDollar3(ExecState* exec, JSValue slotBase, const Identifier&)
214 {
215     return asRegExpConstructor(slotBase)->getBackref(exec, 3);
216 }
217
218 JSValue regExpConstructorDollar4(ExecState* exec, JSValue slotBase, const Identifier&)
219 {
220     return asRegExpConstructor(slotBase)->getBackref(exec, 4);
221 }
222
223 JSValue regExpConstructorDollar5(ExecState* exec, JSValue slotBase, const Identifier&)
224 {
225     return asRegExpConstructor(slotBase)->getBackref(exec, 5);
226 }
227
228 JSValue regExpConstructorDollar6(ExecState* exec, JSValue slotBase, const Identifier&)
229 {
230     return asRegExpConstructor(slotBase)->getBackref(exec, 6);
231 }
232
233 JSValue regExpConstructorDollar7(ExecState* exec, JSValue slotBase, const Identifier&)
234 {
235     return asRegExpConstructor(slotBase)->getBackref(exec, 7);
236 }
237
238 JSValue regExpConstructorDollar8(ExecState* exec, JSValue slotBase, const Identifier&)
239 {
240     return asRegExpConstructor(slotBase)->getBackref(exec, 8);
241 }
242
243 JSValue regExpConstructorDollar9(ExecState* exec, JSValue slotBase, const Identifier&)
244 {
245     return asRegExpConstructor(slotBase)->getBackref(exec, 9);
246 }
247
248 JSValue regExpConstructorInput(ExecState* exec, JSValue slotBase, const Identifier&)
249 {
250     return jsString(exec, asRegExpConstructor(slotBase)->input());
251 }
252
253 JSValue regExpConstructorMultiline(ExecState*, JSValue slotBase, const Identifier&)
254 {
255     return jsBoolean(asRegExpConstructor(slotBase)->multiline());
256 }
257
258 JSValue regExpConstructorLastMatch(ExecState* exec, JSValue slotBase, const Identifier&)
259 {
260     return asRegExpConstructor(slotBase)->getBackref(exec, 0);
261 }
262
263 JSValue regExpConstructorLastParen(ExecState* exec, JSValue slotBase, const Identifier&)
264 {
265     return asRegExpConstructor(slotBase)->getLastParen(exec);
266 }
267
268 JSValue regExpConstructorLeftContext(ExecState* exec, JSValue slotBase, const Identifier&)
269 {
270     return asRegExpConstructor(slotBase)->getLeftContext(exec);
271 }
272
273 JSValue regExpConstructorRightContext(ExecState* exec, JSValue slotBase, const Identifier&)
274 {
275     return asRegExpConstructor(slotBase)->getRightContext(exec);
276 }
277
278 void RegExpConstructor::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
279 {
280     lookupPut<RegExpConstructor, InternalFunction>(exec, propertyName, value, ExecState::regExpConstructorTable(exec), this, slot);
281 }
282
283 void setRegExpConstructorInput(ExecState* exec, JSObject* baseObject, JSValue value)
284 {
285     asRegExpConstructor(baseObject)->setInput(value.toString(exec));
286 }
287
288 void setRegExpConstructorMultiline(ExecState* exec, JSObject* baseObject, JSValue value)
289 {
290     asRegExpConstructor(baseObject)->setMultiline(value.toBoolean(exec));
291 }
292   
293 // ECMA 15.10.4
294 JSObject* constructRegExp(ExecState* exec, const ArgList& args)
295 {
296     JSValue arg0 = args.at(0);
297     JSValue arg1 = args.at(1);
298
299     if (arg0.inherits(&RegExpObject::info)) {
300         if (!arg1.isUndefined())
301             return throwError(exec, createTypeError(exec, "Cannot supply flags when constructing one RegExp from another."));
302         return asObject(arg0);
303     }
304
305     UString pattern = arg0.isUndefined() ? UString("") : arg0.toString(exec);
306     UString flags = arg1.isUndefined() ? UString("") : arg1.toString(exec);
307
308     RefPtr<RegExp> regExp = exec->globalData().regExpCache()->lookupOrCreate(pattern, flags);
309     if (!regExp->isValid())
310         return throwError(exec, createSyntaxError(exec, regExp->errorMessage()));
311     return new (exec) RegExpObject(exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->regExpStructure(), regExp.release());
312 }
313
314 static EncodedJSValue JSC_HOST_CALL constructWithRegExpConstructor(ExecState* exec)
315 {
316     ArgList args(exec);
317     return JSValue::encode(constructRegExp(exec, args));
318 }
319
320 ConstructType RegExpConstructor::getConstructData(ConstructData& constructData)
321 {
322     constructData.native.function = constructWithRegExpConstructor;
323     return ConstructTypeHost;
324 }
325
326 // ECMA 15.10.3
327 static EncodedJSValue JSC_HOST_CALL callRegExpConstructor(ExecState* exec)
328 {
329     ArgList args(exec);
330     return JSValue::encode(constructRegExp(exec, args));
331 }
332
333 CallType RegExpConstructor::getCallData(CallData& callData)
334 {
335     callData.native.function = callRegExpConstructor;
336     return CallTypeHost;
337 }
338
339 void RegExpConstructor::setInput(const UString& input)
340 {
341     d->input = input;
342 }
343
344 const UString& RegExpConstructor::input() const
345 {
346     // Can detect a distinct initial state that is invisible to JavaScript, by checking for null
347     // state (since jsString turns null strings to empty strings).
348     return d->input;
349 }
350
351 void RegExpConstructor::setMultiline(bool multiline)
352 {
353     d->multiline = multiline;
354 }
355
356 bool RegExpConstructor::multiline() const
357 {
358     return d->multiline;
359 }
360
361 } // namespace JSC