- Changed fast case for computing object size based on usage histogram....

src/string.js

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 352 matching lines @@
 
 
 // Helper function for replacing regular expressions with the result of a
 // function application in String.prototype.replace.  The function application
 // must be interleaved with the regexp matching (contrary to ECMA-262
 // 15.5.4.11) to mimic SpiderMonkey and KJS behavior when the function uses
 // the static properties of the RegExp constructor.  Example:
 //     'abcd'.replace(/(.)/g, function() { return RegExp.$1; }
 // should be 'abcd' and not 'dddd' (or anything else).
 function StringReplaceRegExpWithFunction(subject, regexp, replace) {
-  var result = new ReplaceResultBuilder(subject);
   var lastMatchInfo = DoRegExpExec(regexp, subject, 0);
   if (IS_NULL(lastMatchInfo)) return subject;
 
+  var result = new ReplaceResultBuilder(subject);
   // There's at least one match.  If the regexp is global, we have to loop
   // over all matches.  The loop is not in C++ code here like the one in
   // RegExp.prototype.exec, because of the interleaved function application.
   // Unfortunately, that means this code is nearly duplicated, here and in
   // jsregexp.cc.
   if (regexp.global) {
     var previous = 0;
     do {
       result.addSpecialSlice(previous, lastMatchInfo[CAPTURE0]);
       var startOfMatch = lastMatchInfo[CAPTURE0];
@@ skipping 104 matching lines @@
   if (num_c < 0)
     num_c = 0;
 
   return SubString(s, start_i, start_i + num_c);
 }
 
 
 // ECMA-262 section 15.5.4.14
 function StringSplit(separator, limit) {
   var subject = ToString(this);
-  var result = [];
-  var lim = (limit === void 0) ? 0xffffffff : ToUint32(limit);
-
-  if (lim === 0) return result;
+  limit = (limit === void 0) ? 0xffffffff : ToUint32(limit);
+  if (limit === 0) return [];
 
   // ECMA-262 says that if separator is undefined, the result should
   // be an array of size 1 containing the entire string.  SpiderMonkey
   // and KJS have this behaviour only when no separator is given.  If
   // undefined is explicitly given, they convert it to a string and
   // use that.  We do as SpiderMonkey and KJS.
   if (%_ArgumentsLength() === 0) {
-    result[result.length] = subject;
-    return result;
+    return [subject];
   }
 
   var length = subject.length;
-  var currentIndex = 0;
-  var startIndex = 0;
-
-  var sep;
   if (IS_REGEXP(separator)) {
-    sep = separator;
-    %_Log('regexp', 'regexp-split,%0S,%1r', [subject, sep]);
+    %_Log('regexp', 'regexp-split,%0S,%1r', [subject, separator]);
   } else {
-    sep = ToString(separator);
+    separator = ToString(separator);
+    // If the separator string is empty then return the elements in the subject.
+    if (separator.length == 0) {
+      var result = $Array(length);
+      for (var i = 0; i < length; i++) result[i] = subject[i];
+      return result;
+    }
   }
 
   if (length === 0) {
-    if (splitMatch(sep, subject, 0, 0) != null) return result;
-    result[result.length] = subject;
-    return result;
+    if (splitMatch(separator, subject, 0, 0) != null) return [];
+    return [subject];
   }
 
+  var currentIndex = 0;
+  var startIndex = 0;
+  var result = [];
+
   while (true) {
 
     if (startIndex === length) {
       result[result.length] = subject.slice(currentIndex, length);
       return result;
     }
 
-    var lastMatchInfo = splitMatch(sep, subject, currentIndex, startIndex);
+    var lastMatchInfo = splitMatch(separator, subject, currentIndex, startIndex);
 
     if (IS_NULL(lastMatchInfo)) {
       result[result.length] = subject.slice(currentIndex, length);
       return result;
     }
 
     var endIndex = lastMatchInfo[CAPTURE1];
 
     // We ignore a zero-length match at the currentIndex.
     if (startIndex === endIndex && endIndex === currentIndex) {
       startIndex++;
       continue;
     }
 
-    result[result.length] =
-        SubString(subject, currentIndex, lastMatchInfo[CAPTURE0]);
-    if (result.length === lim) return result;
+    result[result.length] = SubString(subject, currentIndex, lastMatchInfo[CAPTURE0]);
+    if (result.length === limit) return result;
 
     for (var i = 2; i < NUMBER_OF_CAPTURES(lastMatchInfo); i += 2) {
       var start = lastMatchInfo[CAPTURE(i)];
       var end = lastMatchInfo[CAPTURE(i + 1)];
       if (start != -1 && end != -1) {
-        result[result.length] = SubString(subject,
-                                          lastMatchInfo[CAPTURE(i)],
-                                          lastMatchInfo[CAPTURE(i + 1)]);
+        result[result.length] = SubString(subject, start, end);
       } else {
         result[result.length] = void 0;
       }
-      if (result.length === lim) return result;
+      if (result.length === limit) return result;
     }
 
     startIndex = currentIndex = endIndex;
   }
 }
 
 
 // ECMA-262 section 15.5.4.14
 // Helper function used by split.  This version returns the lastMatchInfo
 // instead of allocating a new array with basically the same information.
@@ skipping 288 matching lines @@
     "small", StringSmall,
     "strike", StringStrike,
     "sub", StringSub,
     "sup", StringSup,
     "toJSON", StringToJSON
   ));
 }
 
 
 SetupString();