Changeset 89895 in webkit

Timestamp:

Jun 27, 2011 10:55:45 PM (13 years ago)

Author:

barraclough@apple.com

Message:

Source/JavaScriptCore: Build fix attempt after r89885.

Patch by Ryosuke Niwa <​rniwa@webkit.org> on 2011-06-27

• JavaScriptCore.exp:
• jsc.cpp:

LayoutTests: ​https://bugs.webkit.org/show_bug.cgi?id=50554
RegExp.prototype.toString does not escape slashes

Reviewed by Darin Adler & Oliver Hunt.

The problem here is that we don't escape forwards slashes when converting
a RegExp to a string. This means that RegExp("/").toString() is "/",
which is not a valid RegExp literal. Also, we return an invalid literal
for RegExp.prototype.toString() ("", which is an empty single-line comment).

From ES5:
"NOTE: The returned String has the form of a RegularExpressionLiteral that
evaluates to another RegExp object with the same behaviour as this object."

Added test cases.

• fast/regex/script-tests/toString.js: Added.

(testFwdSlash):

• fast/regex/toString-expected.txt: Added.
• fast/regex/toString.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/regex/script-tests/toString.js (added)
• LayoutTests/fast/regex/toString-expected.txt (added)
• LayoutTests/fast/regex/toString.html (added)
• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/runtime/RegExpObject.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/RegExpPrototype.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2011-06-27  Gavin Barraclough  <barraclough@apple.com>
+
+        Reviewed by Darin Adler & Oliver Hunt.
+
+        https://bugs.webkit.org/show_bug.cgi?id=50554
+        RegExp.prototype.toString does not escape slashes
+
+        The problem here is that we don't escape forwards slashes when converting
+        a RegExp to a string. This means that RegExp("/").toString() is "///",
+        which is not a valid RegExp literal. Also, we return an invalid literal
+        for RegExp.prototype.toString() ("//", which is an empty single-line comment).
+
+        From ES5:
+        "NOTE: The returned String has the form of a RegularExpressionLiteral that
+        evaluates to another RegExp object with the same behaviour as this object."
+
+        Added test cases.
+
+        * fast/regex/script-tests/toString.js: Added.
+        (testFwdSlash):
+        * fast/regex/toString-expected.txt: Added.
+        * fast/regex/toString.html: Added.
+
 2011-06-27  Pavel Feldman  <pfeldman@chromium.org>
 

trunk/Source/JavaScriptCore/ChangeLog

@@ -52 +52 @@
         (JSC::SafeRecompiler::operator()):
         (JSC::JSGlobalData::releaseExecutableMemory):
+
+2011-06-27  Gavin Barraclough  <barraclough@apple.com>
+
+        Reviewed by Darin Adler & Oliver Hunt.
+
+        https://bugs.webkit.org/show_bug.cgi?id=50554
+        RegExp.prototype.toString does not escape slashes
+
+        The problem here is that we don't escape forwards slashes when converting
+        a RegExp to a string. This means that RegExp("/").toString() is "///",
+        which is not a valid RegExp literal. Also, we return an invalid literal
+        for RegExp.prototype.toString() ("//", which is an empty single-line comment).
+
+        From ES5:
+        "NOTE: The returned String has the form of a RegularExpressionLiteral that
+        evaluates to another RegExp object with the same behaviour as this object."
+
+        * runtime/RegExpObject.cpp:
+        (JSC::regExpObjectSource):
+            - Escape forward slashes when getting the source of a RegExp.
+        * runtime/RegExpPrototype.cpp:
+        (JSC::regExpProtoFuncToString):
+            - Remove unnecessary and erroneous hack to return "//" as the string
+            representation of RegExp.prototype. This is not a valid RegExp literal
+            (it is an empty single-line comment).
 
 2011-06-27  Gavin Barraclough  <barraclough@apple.com>

trunk/Source/JavaScriptCore/runtime/RegExpObject.cpp

@@ -30 +30 @@
 #include "RegExpConstructor.h"
 #include "RegExpPrototype.h"
+#include "UStringBuilder.h"
 #include "UStringConcatenate.h"
 #include <wtf/PassOwnPtr.h>
@@ -112 +113 @@
 JSValue regExpObjectSource(ExecState* exec, JSValue slotBase, const Identifier&)
 {
-    return jsString(exec, asRegExpObject(slotBase)->regExp()->pattern());
+    UString pattern = asRegExpObject(slotBase)->regExp()->pattern();
+
+    size_t forwardSlashPosition = pattern.find('/');
+    if (forwardSlashPosition == notFound)
+        return jsString(exec, pattern);
+
+    // 'completed' tracks the length of original pattern already copied
+    // into the result buffer.
+    size_t completed = 0;
+    UStringBuilder result;
+
+    do {
+        // 'slashesPosition' points to the first (of possibly zero) backslash
+        // prior to the forwards slash.
+        size_t slashesPosition = forwardSlashPosition;
+        while (slashesPosition && pattern[slashesPosition - 1] == '\\')
+            --slashesPosition;
+
+        // Check whether the number of backslashes is odd or even -
+        // if odd, the forwards slash is already escaped, so we mustn't
+        // double escape it.
+        if ((forwardSlashPosition - slashesPosition) & 1)
+            result.append(pattern.substringSharingImpl(completed, forwardSlashPosition + 1));
+        else {
+            result.append(pattern.substringSharingImpl(completed, forwardSlashPosition));
+            result.append("\\/");
+        }
+        completed = forwardSlashPosition + 1;
+
+        forwardSlashPosition = pattern.find('/', completed);
+    } while (forwardSlashPosition != notFound);
+
+    // Copy in the remainder of the pattern to the buffer.
+    result.append(pattern.substringSharingImpl(completed));
+    return jsString(exec, result.toUString());
 }
 

trunk/Source/JavaScriptCore/runtime/RegExpPrototype.cpp

@@ -137 +137 @@
 {
     JSValue thisValue = exec->hostThisValue();
-    if (!thisValue.inherits(&RegExpObject::s_info)) {
-        if (thisValue.inherits(&RegExpPrototype::s_info))
-            return JSValue::encode(jsNontrivialString(exec, "//"));
+    if (!thisValue.inherits(&RegExpObject::s_info))
         return throwVMTypeError(exec);
-    }
 
     RegExpObject* thisObject = asRegExpObject(thisValue);