Experimental: port bleeding_edge r1276 (a grab bag of optimizations)...

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 44 matching lines @@
 // ECMA-262 section 15.5.4.3
 function StringValueOf() {
   if (!IS_STRING(this) && !%HasStringClass(this))
     throw new $TypeError('String.prototype.valueOf is not generic');
   return %_ValueOf(this);
 }
 
 
 // ECMA-262, section 15.5.4.4
 function StringCharAt(pos) {
-  var subject = ToString(this);
-  var index = TO_INTEGER(pos);
-  if (index >= subject.length || index < 0) return "";
-  return %CharFromCode(%StringCharCodeAt(subject, index));
+  var char_code = %_FastCharCodeAt(subject, index);
+  if (!%_IsSmi(char_code)) {
+    var subject = ToString(this);
+    var index = TO_INTEGER(pos);
+    if (index >= subject.length || index < 0) return "";
+    char_code = %StringCharCodeAt(subject, index);
+  }
+  return %CharFromCode(char_code);
 }
 
 
 // ECMA-262 section 15.5.4.5
 function StringCharCodeAt(pos) {
   var fast_answer = %_FastCharCodeAt(this, pos);
   if (%_IsSmi(fast_answer)) {
     return fast_answer;
   }
   var subject = ToString(this);
@@ skipping 89 matching lines @@
 
   return result;
 }
 
 
 // SubString is an internal function that returns the sub string of 'string'.
 // If resulting string is of length 1, we use the one character cache
 // otherwise we call the runtime system.
 function SubString(string, start, end) {
   // Use the one character string cache.
-  if (start + 1 == end) return %CharFromCode(%StringCharCodeAt(string, start));
+  if (start + 1 == end) {
+    var char_code = %_FastCharCodeAt(string, start);
+    if (!%_IsSmi(char_code)) {
+      char_code = %StringCharCodeAt(string, start);
+    }
+    return %CharFromCode(char_code);
+  }
   return %StringSlice(string, start, end);
 }
 
 
 // ECMA-262, section 15.5.4.11
 function StringReplace(search, replace) {
   var subject = ToString(this);
 
   // Delegate to one of the regular expression variants if necessary.
   if (IS_REGEXP(search)) {
@@ skipping 84 matching lines @@
   // Compute the number of captures; see ECMA-262, 15.5.4.11, p. 102.
   var m = captures.length >> 1;  // includes the match
 
   if (next > 0) builder.add(SubString(string, 0, next));
   var length = string.length;
 
   while (true) {
     var expansion = '$';
     var position = next + 1;
     if (position < length) {
-      var peek = %StringCharCodeAt(string, position);
+      var peek = %_FastCharCodeAt(string, position);
+      if (!%_IsSmi(peek)) {
+        peek = %StringCharCodeAt(string, position);
+      }
       if (peek == 36) {         // $$
         ++position;
         builder.add('$');
       } else if (peek == 38) {  // $& - match
         ++position;
         builder.addSpecialSlice(captures[0], captures[1]);
       } else if (peek == 96) {  // $` - prefix
         ++position;
         builder.addSpecialSlice(0, captures[0]);
       } else if (peek == 39) {  // $' - suffix
         ++position;
         builder.addSpecialSlice(captures[1], subject.length);
       } else if (peek >= 48 && peek <= 57) {  // $n, 0 <= n <= 9
         ++position;
         var n = peek - 48;
         if (position < length) {
-          peek = %StringCharCodeAt(string, position);
+          peek = %_FastCharCodeAt(string, position);
+          if (!%_IsSmi(peek)) {
+            peek = %StringCharCodeAt(string, position);
+          }
           // $nn, 01 <= nn <= 99
           if (n != 0 && peek == 48 || peek >= 49 && peek <= 57) {
             var nn = n * 10 + (peek - 48);
             if (nn < m) {
               // If the two digit capture reference is within range of
               // the captures, we use it instead of the single digit
               // one. Otherwise, we fall back to using the single
               // digit reference. This matches the behavior of
               // SpiderMonkey.
               ++position;
@@ skipping 48 matching lines @@
 
 
 // Add the string of a given PCRE capture to the ReplaceResultBuilder
 function addCaptureString(builder, captures, index) {
   // Scale the index.
   var scaled = index << 1;
   // Compute start and end.
   var start = captures[scaled];
   var end = captures[scaled + 1];
   // If either start or end is missing return.
-  if (start < 0 || end < 0) return;
+  if (start < 0 || end <= start) return;
   builder.addSpecialSlice(start, end);
 };
 
 
 // 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; }
@@ skipping 50 matching lines @@
 
 // Helper function to apply a string replacement function once.
 function ApplyReplacementFunction(replace, captures, subject) {
   // Compute the parameter list consisting of the match, captures, index,
   // and subject for the replace function invocation.
   var index = captures[0];
   // The number of captures plus one for the match.
   var m = captures.length >> 1;
   if (m == 1) {
     var s = CaptureString(subject, captures, 0);
+    // Don't call directly to avoid exposing the built-in global object.
     return ToString(replace.call(null, s, index, subject));
   }
   var parameters = $Array(m + 2);
   for (var j = 0; j < m; j++) {
     parameters[j] = CaptureString(subject, captures, j);
   }
   parameters[j] = index;
   parameters[j + 1] = subject;
   return ToString(replace.apply(null, parameters));
 }
@@ skipping 416 matching lines @@
     "italics", StringItalics,
     "small", StringSmall,
     "strike", StringStrike,
     "sub", StringSub,
     "sup", StringSup
   ));
 }
 
 
 SetupString();