/*
* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
- * Copyright (C) 2003, 2007, 2008 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2003, 2007, 2008, 2012 Apple Inc. All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include "config.h"
#include "RegExpObject.h"
+#include "ButterflyInlines.h"
+#include "CopiedSpaceInlines.h"
#include "Error.h"
+#include "ExceptionHelpers.h"
#include "JSArray.h"
#include "JSGlobalObject.h"
#include "JSString.h"
+#include "Lexer.h"
+#include "Lookup.h"
+#include "Operations.h"
#include "RegExpConstructor.h"
+#include "RegExpMatchesArray.h"
#include "RegExpPrototype.h"
+#include <wtf/PassOwnPtr.h>
+#include <wtf/text/StringBuilder.h>
+
+#if PLATFORM(IOS)
+#include <wtf/PassOwnPtr.h>
+#endif
namespace JSC {
-static JSValue regExpObjectGlobal(ExecState*, const Identifier&, const PropertySlot&);
-static JSValue regExpObjectIgnoreCase(ExecState*, const Identifier&, const PropertySlot&);
-static JSValue regExpObjectMultiline(ExecState*, const Identifier&, const PropertySlot&);
-static JSValue regExpObjectSource(ExecState*, const Identifier&, const PropertySlot&);
-static JSValue regExpObjectLastIndex(ExecState*, const Identifier&, const PropertySlot&);
-static void setRegExpObjectLastIndex(ExecState*, JSObject*, JSValue);
+static JSValue regExpObjectGlobal(ExecState*, JSValue, PropertyName);
+static JSValue regExpObjectIgnoreCase(ExecState*, JSValue, PropertyName);
+static JSValue regExpObjectMultiline(ExecState*, JSValue, PropertyName);
+static JSValue regExpObjectSource(ExecState*, JSValue, PropertyName);
} // namespace JSC
namespace JSC {
-ASSERT_CLASS_FITS_IN_CELL(RegExpObject);
+ASSERT_HAS_TRIVIAL_DESTRUCTOR(RegExpObject);
-const ClassInfo RegExpObject::info = { "RegExp", 0, 0, ExecState::regExpTable };
+const ClassInfo RegExpObject::s_info = { "RegExp", &Base::s_info, 0, ExecState::regExpTable, CREATE_METHOD_TABLE(RegExpObject) };
/* Source for RegExpObject.lut.h
@begin regExpTable
ignoreCase regExpObjectIgnoreCase DontDelete|ReadOnly|DontEnum
multiline regExpObjectMultiline DontDelete|ReadOnly|DontEnum
source regExpObjectSource DontDelete|ReadOnly|DontEnum
- lastIndex regExpObjectLastIndex DontDelete|DontEnum
@end
*/
-RegExpObject::RegExpObject(PassRefPtr<Structure> structure, PassRefPtr<RegExp> regExp)
- : JSObject(structure)
- , d(new RegExpObjectData(regExp, 0))
+RegExpObject::RegExpObject(JSGlobalObject* globalObject, Structure* structure, RegExp* regExp)
+ : JSNonFinalObject(globalObject->vm(), structure)
+ , m_regExp(globalObject->vm(), this, regExp)
+ , m_lastIndexIsWritable(true)
{
+ m_lastIndex.setWithoutWriteBarrier(jsNumber(0));
}
-RegExpObject::~RegExpObject()
+void RegExpObject::finishCreation(JSGlobalObject* globalObject)
{
+ Base::finishCreation(globalObject->vm());
+ ASSERT(inherits(&s_info));
}
-bool RegExpObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+void RegExpObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
{
- return getStaticValueSlot<RegExpObject, JSObject>(exec, ExecState::regExpTable(exec), this, propertyName, slot);
+ RegExpObject* thisObject = jsCast<RegExpObject*>(cell);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
+ COMPILE_ASSERT(StructureFlags & OverridesVisitChildren, OverridesVisitChildrenWithoutSettingFlag);
+ ASSERT(thisObject->structure()->typeInfo().overridesVisitChildren());
+
+ Base::visitChildren(thisObject, visitor);
+ visitor.append(&thisObject->m_regExp);
+ visitor.append(&thisObject->m_lastIndex);
}
-JSValue regExpObjectGlobal(ExecState*, const Identifier&, const PropertySlot& slot)
+bool RegExpObject::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
- return jsBoolean(asRegExpObject(slot.slotBase())->regExp()->global());
+ if (propertyName == exec->propertyNames().lastIndex) {
+ RegExpObject* regExp = asRegExpObject(cell);
+ slot.setValue(regExp, regExp->getLastIndex());
+ return true;
+ }
+ return getStaticValueSlot<RegExpObject, JSObject>(exec, ExecState::regExpTable(exec), jsCast<RegExpObject*>(cell), propertyName, slot);
}
-JSValue regExpObjectIgnoreCase(ExecState*, const Identifier&, const PropertySlot& slot)
+bool RegExpObject::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
{
- return jsBoolean(asRegExpObject(slot.slotBase())->regExp()->ignoreCase());
+ if (propertyName == exec->propertyNames().lastIndex) {
+ RegExpObject* regExp = asRegExpObject(object);
+ descriptor.setDescriptor(regExp->getLastIndex(), regExp->m_lastIndexIsWritable ? DontDelete | DontEnum : DontDelete | DontEnum | ReadOnly);
+ return true;
+ }
+ return getStaticValueDescriptor<RegExpObject, JSObject>(exec, ExecState::regExpTable(exec), jsCast<RegExpObject*>(object), propertyName, descriptor);
}
-
-JSValue regExpObjectMultiline(ExecState*, const Identifier&, const PropertySlot& slot)
-{
- return jsBoolean(asRegExpObject(slot.slotBase())->regExp()->multiline());
+
+bool RegExpObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
+{
+ if (propertyName == exec->propertyNames().lastIndex)
+ return false;
+ return Base::deleteProperty(cell, exec, propertyName);
}
-JSValue regExpObjectSource(ExecState* exec, const Identifier&, const PropertySlot& slot)
+void RegExpObject::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
{
- return jsString(exec, asRegExpObject(slot.slotBase())->regExp()->pattern());
+ if (mode == IncludeDontEnumProperties)
+ propertyNames.add(exec->propertyNames().lastIndex);
+ Base::getOwnNonIndexPropertyNames(object, exec, propertyNames, mode);
}
-JSValue regExpObjectLastIndex(ExecState* exec, const Identifier&, const PropertySlot& slot)
+void RegExpObject::getPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
{
- return jsNumber(exec, asRegExpObject(slot.slotBase())->lastIndex());
+ if (mode == IncludeDontEnumProperties)
+ propertyNames.add(exec->propertyNames().lastIndex);
+ Base::getPropertyNames(object, exec, propertyNames, mode);
}
-void RegExpObject::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
+static bool reject(ExecState* exec, bool throwException, const char* message)
{
- lookupPut<RegExpObject, JSObject>(exec, propertyName, value, ExecState::regExpTable(exec), this, slot);
+ if (throwException)
+ throwTypeError(exec, ASCIILiteral(message));
+ return false;
}
-void setRegExpObjectLastIndex(ExecState* exec, JSObject* baseObject, JSValue value)
+bool RegExpObject::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor, bool shouldThrow)
{
- asRegExpObject(baseObject)->setLastIndex(value.toInteger(exec));
+ if (propertyName == exec->propertyNames().lastIndex) {
+ RegExpObject* regExp = asRegExpObject(object);
+ if (descriptor.configurablePresent() && descriptor.configurable())
+ return reject(exec, shouldThrow, "Attempting to change configurable attribute of unconfigurable property.");
+ if (descriptor.enumerablePresent() && descriptor.enumerable())
+ return reject(exec, shouldThrow, "Attempting to change enumerable attribute of unconfigurable property.");
+ if (descriptor.isAccessorDescriptor())
+ return reject(exec, shouldThrow, "Attempting to change access mechanism for an unconfigurable property.");
+ if (!regExp->m_lastIndexIsWritable) {
+ if (descriptor.writablePresent() && descriptor.writable())
+ return reject(exec, shouldThrow, "Attempting to change writable attribute of unconfigurable property.");
+ if (!sameValue(exec, regExp->getLastIndex(), descriptor.value()))
+ return reject(exec, shouldThrow, "Attempting to change value of a readonly property.");
+ return true;
+ }
+ if (descriptor.writablePresent() && !descriptor.writable())
+ regExp->m_lastIndexIsWritable = false;
+ if (descriptor.value())
+ regExp->setLastIndex(exec, descriptor.value(), false);
+ return true;
+ }
+
+ return Base::defineOwnProperty(object, exec, propertyName, descriptor, shouldThrow);
}
-JSValue RegExpObject::test(ExecState* exec, const ArgList& args)
+JSValue regExpObjectGlobal(ExecState*, JSValue slotBase, PropertyName)
{
- return jsBoolean(match(exec, args));
+ return jsBoolean(asRegExpObject(slotBase)->regExp()->global());
}
-JSValue RegExpObject::exec(ExecState* exec, const ArgList& args)
+JSValue regExpObjectIgnoreCase(ExecState*, JSValue slotBase, PropertyName)
{
- if (match(exec, args))
- return exec->lexicalGlobalObject()->regExpConstructor()->arrayOfMatches(exec);
- return jsNull();
+ return jsBoolean(asRegExpObject(slotBase)->regExp()->ignoreCase());
+}
+
+JSValue regExpObjectMultiline(ExecState*, JSValue slotBase, PropertyName)
+{
+ return jsBoolean(asRegExpObject(slotBase)->regExp()->multiline());
}
-static JSValue JSC_HOST_CALL callRegExpObject(ExecState* exec, JSObject* function, JSValue, const ArgList& args)
+template <typename CharacterType>
+static inline void appendLineTerminatorEscape(StringBuilder&, CharacterType);
+
+template <>
+inline void appendLineTerminatorEscape<LChar>(StringBuilder& builder, LChar lineTerminator)
{
- return asRegExpObject(function)->exec(exec, args);
+ if (lineTerminator == '\n')
+ builder.append('n');
+ else
+ builder.append('r');
}
-CallType RegExpObject::getCallData(CallData& callData)
+template <>
+inline void appendLineTerminatorEscape<UChar>(StringBuilder& builder, UChar lineTerminator)
{
- callData.native.function = callRegExpObject;
- return CallTypeHost;
+ if (lineTerminator == '\n')
+ builder.append('n');
+ else if (lineTerminator == '\r')
+ builder.append('r');
+ else if (lineTerminator == 0x2028)
+ builder.appendLiteral("u2028");
+ else
+ builder.appendLiteral("u2029");
}
-// Shared implementation used by test and exec.
-bool RegExpObject::match(ExecState* exec, const ArgList& args)
+template <typename CharacterType>
+static inline JSValue regExpObjectSourceInternal(ExecState* exec, String pattern, const CharacterType* characters, unsigned length)
{
- RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
+ bool previousCharacterWasBackslash = false;
+ bool inBrackets = false;
+ bool shouldEscape = false;
- UString input = args.isEmpty() ? regExpConstructor->input() : args.at(0).toString(exec);
- if (input.isNull()) {
- throwError(exec, GeneralError, "No input to " + toString(exec) + ".");
- return false;
+ // 15.10.6.4 specifies that RegExp.prototype.toString must return '/' + source + '/',
+ // and also states that the result must be a valid RegularExpressionLiteral. '//' is
+ // not a valid RegularExpressionLiteral (since it is a single line comment), and hence
+ // source cannot ever validly be "". If the source is empty, return a different Pattern
+ // that would match the same thing.
+ if (!length)
+ return jsNontrivialString(exec, ASCIILiteral("(?:)"));
+
+ // early return for strings that don't contain a forwards slash and LineTerminator
+ for (unsigned i = 0; i < length; ++i) {
+ CharacterType ch = characters[i];
+ if (!previousCharacterWasBackslash) {
+ if (inBrackets) {
+ if (ch == ']')
+ inBrackets = false;
+ } else {
+ if (ch == '/') {
+ shouldEscape = true;
+ break;
+ }
+ if (ch == '[')
+ inBrackets = true;
+ }
+ }
+
+ if (Lexer<CharacterType>::isLineTerminator(ch)) {
+ shouldEscape = true;
+ break;
+ }
+
+ if (previousCharacterWasBackslash)
+ previousCharacterWasBackslash = false;
+ else
+ previousCharacterWasBackslash = ch == '\\';
}
- if (!regExp()->global()) {
- int position;
- int length;
- regExpConstructor->performMatch(d->regExp.get(), input, 0, position, length);
- return position >= 0;
+ if (!shouldEscape)
+ return jsString(exec, pattern);
+
+ previousCharacterWasBackslash = false;
+ inBrackets = false;
+ StringBuilder result;
+ for (unsigned i = 0; i < length; ++i) {
+ CharacterType ch = characters[i];
+ if (!previousCharacterWasBackslash) {
+ if (inBrackets) {
+ if (ch == ']')
+ inBrackets = false;
+ } else {
+ if (ch == '/')
+ result.append('\\');
+ else if (ch == '[')
+ inBrackets = true;
+ }
+ }
+
+ // escape LineTerminator
+ if (Lexer<CharacterType>::isLineTerminator(ch)) {
+ if (!previousCharacterWasBackslash)
+ result.append('\\');
+
+ appendLineTerminatorEscape<CharacterType>(result, ch);
+ } else
+ result.append(ch);
+
+ if (previousCharacterWasBackslash)
+ previousCharacterWasBackslash = false;
+ else
+ previousCharacterWasBackslash = ch == '\\';
}
- if (d->lastIndex < 0 || d->lastIndex > input.size()) {
- d->lastIndex = 0;
- return false;
+ return jsString(exec, result.toString());
+}
+
+JSValue regExpObjectSource(ExecState* exec, JSValue slotBase, PropertyName)
+{
+ String pattern = asRegExpObject(slotBase)->regExp()->pattern();
+ if (pattern.is8Bit())
+ return regExpObjectSourceInternal(exec, pattern, pattern.characters8(), pattern.length());
+ return regExpObjectSourceInternal(exec, pattern, pattern.characters16(), pattern.length());
+}
+
+void RegExpObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
+{
+ if (propertyName == exec->propertyNames().lastIndex) {
+ asRegExpObject(cell)->setLastIndex(exec, value, slot.isStrictMode());
+ return;
}
+ lookupPut<RegExpObject, JSObject>(exec, propertyName, value, ExecState::regExpTable(exec), jsCast<RegExpObject*>(cell), slot);
+}
- int position;
- int length;
- regExpConstructor->performMatch(d->regExp.get(), input, static_cast<int>(d->lastIndex), position, length);
- if (position < 0) {
- d->lastIndex = 0;
- return false;
+JSValue RegExpObject::exec(ExecState* exec, JSString* string)
+{
+ if (MatchResult result = match(exec, string))
+ return RegExpMatchesArray::create(exec, string, regExp(), result);
+ return jsNull();
+}
+
+// Shared implementation used by test and exec.
+MatchResult RegExpObject::match(ExecState* exec, JSString* string)
+{
+ RegExp* regExp = this->regExp();
+ RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
+ String input = string->value(exec);
+ VM& vm = exec->vm();
+ if (!regExp->global())
+ return regExpConstructor->performMatch(vm, regExp, string, input, 0);
+
+ JSValue jsLastIndex = getLastIndex();
+ unsigned lastIndex;
+ if (LIKELY(jsLastIndex.isUInt32())) {
+ lastIndex = jsLastIndex.asUInt32();
+ if (lastIndex > input.length()) {
+ setLastIndex(exec, 0);
+ return MatchResult::failed();
+ }
+ } else {
+ double doubleLastIndex = jsLastIndex.toInteger(exec);
+ if (doubleLastIndex < 0 || doubleLastIndex > input.length()) {
+ setLastIndex(exec, 0);
+ return MatchResult::failed();
+ }
+ lastIndex = static_cast<unsigned>(doubleLastIndex);
}
- d->lastIndex = position + length;
- return true;
+ MatchResult result = regExpConstructor->performMatch(vm, regExp, string, input, lastIndex);
+ setLastIndex(exec, result.end);
+ return result;
}
} // namespace JSC
projects / apple / javascriptcore.git / blobdiff