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