runtime/RegExpObject.cpp

   1 /*
   2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2003, 2007, 2008 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 "Error.h"
  25 #include "ExceptionHelpers.h"
  26 #include "JSArray.h"
  27 #include "JSGlobalObject.h"
  28 #include "JSString.h"
  29 #include "Lookup.h"
  30 #include "RegExpConstructor.h"
  31 #include "RegExpPrototype.h"
  32 #include "UStringConcatenate.h"
  33 #include <wtf/PassOwnPtr.h>
  34
  35 #include <wtf/PassOwnPtr.h>
  36
  37 namespace JSC {
  38
  39 static JSValue regExpObjectGlobal(ExecState*, JSValue, const Identifier&);
  40 static JSValue regExpObjectIgnoreCase(ExecState*, JSValue, const Identifier&);
  41 static JSValue regExpObjectMultiline(ExecState*, JSValue, const Identifier&);
  42 static JSValue regExpObjectSource(ExecState*, JSValue, const Identifier&);
  43 static JSValue regExpObjectLastIndex(ExecState*, JSValue, const Identifier&);
  44 static void setRegExpObjectLastIndex(ExecState*, JSObject*, JSValue);
  45
  46 } // namespace JSC
  47
  48 #include "RegExpObject.lut.h"
  49
  50 namespace JSC {
  51
  52 ASSERT_CLASS_FITS_IN_CELL(RegExpObject);
  53
  54 const ClassInfo RegExpObject::s_info = { "RegExp", &JSObjectWithGlobalObject::s_info, 0, ExecState::regExpTable };
  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     lastIndex     regExpObjectLastIndex    DontDelete|DontEnum
  63 @end
  64 */
  65
  66 RegExpObject::RegExpObject(JSGlobalObject* globalObject, Structure* structure, RegExp* regExp)
  67     : JSObjectWithGlobalObject(globalObject, structure)
  68     , d(adoptPtr(new RegExpObjectData(globalObject->globalData(), this, regExp)))
  69 {
  70     ASSERT(inherits(&s_info));
  71 }
  72
  73 RegExpObject::~RegExpObject()
  74 {
  75 }
  76
  77 void RegExpObject::visitChildren(SlotVisitor& visitor)
  78 {
  79     ASSERT_GC_OBJECT_INHERITS(this, &s_info);
  80     COMPILE_ASSERT(StructureFlags & OverridesVisitChildren, OverridesVisitChildrenWithoutSettingFlag);
  81     ASSERT(structure()->typeInfo().overridesVisitChildren());
  82     Base::visitChildren(visitor);
  83     if (d->regExp)
  84         visitor.append(&d->regExp);
  85     if (UNLIKELY(!d->lastIndex.get().isInt32()))
  86         visitor.append(&d->lastIndex);
  87 }
  88
  89 bool RegExpObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
  90 {
  91     return getStaticValueSlot<RegExpObject, JSObject>(exec, ExecState::regExpTable(exec), this, propertyName, slot);
  92 }
  93
  94 bool RegExpObject::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
  95 {
  96     return getStaticValueDescriptor<RegExpObject, JSObject>(exec, ExecState::regExpTable(exec), this, propertyName, descriptor);
  97 }
  98
  99 JSValue regExpObjectGlobal(ExecState*, JSValue slotBase, const Identifier&)
 100 {
 101     return jsBoolean(asRegExpObject(slotBase)->regExp()->global());
 102 }
 103
 104 JSValue regExpObjectIgnoreCase(ExecState*, JSValue slotBase, const Identifier&)
 105 {
 106     return jsBoolean(asRegExpObject(slotBase)->regExp()->ignoreCase());
 107 }
 108
 109 JSValue regExpObjectMultiline(ExecState*, JSValue slotBase, const Identifier&)
 110 {
 111     return jsBoolean(asRegExpObject(slotBase)->regExp()->multiline());
 112 }
 113
 114 JSValue regExpObjectSource(ExecState* exec, JSValue slotBase, const Identifier&)
 115 {
 116     return jsString(exec, asRegExpObject(slotBase)->regExp()->pattern());
 117 }
 118
 119 JSValue regExpObjectLastIndex(ExecState*, JSValue slotBase, const Identifier&)
 120 {
 121     return asRegExpObject(slotBase)->getLastIndex();
 122 }
 123
 124 void RegExpObject::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
 125 {
 126     lookupPut<RegExpObject, JSObject>(exec, propertyName, value, ExecState::regExpTable(exec), this, slot);
 127 }
 128
 129 void setRegExpObjectLastIndex(ExecState* exec, JSObject* baseObject, JSValue value)
 130 {
 131     asRegExpObject(baseObject)->setLastIndex(exec->globalData(), value);
 132 }
 133
 134 JSValue RegExpObject::test(ExecState* exec)
 135 {
 136     return jsBoolean(match(exec));
 137 }
 138
 139 JSValue RegExpObject::exec(ExecState* exec)
 140 {
 141     if (match(exec))
 142         return exec->lexicalGlobalObject()->regExpConstructor()->arrayOfMatches(exec);
 143     return jsNull();
 144 }
 145
 146 // Shared implementation used by test and exec.
 147 bool RegExpObject::match(ExecState* exec)
 148 {
 149     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
 150     UString input = exec->argument(0).toString(exec);
 151     JSGlobalData* globalData = &exec->globalData();
 152     if (!regExp()->global()) {
 153         int position;
 154         int length;
 155         regExpConstructor->performMatch(*globalData, d->regExp.get(), input, 0, position, length);
 156         return position >= 0;
 157     }
 158
 159     JSValue jsLastIndex = getLastIndex();
 160     unsigned lastIndex;
 161     if (LIKELY(jsLastIndex.isUInt32())) {
 162         lastIndex = jsLastIndex.asUInt32();
 163         if (lastIndex > input.length()) {
 164             setLastIndex(0);
 165             return false;
 166         }
 167     } else {
 168         double doubleLastIndex = jsLastIndex.toInteger(exec);
 169         if (doubleLastIndex < 0 || doubleLastIndex > input.length()) {
 170             setLastIndex(0);
 171             return false;
 172         }
 173         lastIndex = static_cast<unsigned>(doubleLastIndex);
 174     }
 175
 176     int position;
 177     int length = 0;
 178     regExpConstructor->performMatch(*globalData, d->regExp.get(), input, lastIndex, position, length);
 179     if (position < 0) {
 180         setLastIndex(0);
 181         return false;
 182     }
 183
 184     setLastIndex(position + length);
 185     return true;
 186 }
 187
 188 } // namespace JSC