Remove trailing regexp from .js files.

src/string.js

 // Copyright 2006-2009 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 388 matching lines @@
   var scaled = index << 1;
   // Compute start and end.
   var start = matchInfo[CAPTURE(scaled)];
   var end = matchInfo[CAPTURE(scaled + 1)];
   // If either start or end is missing return.
   if (start < 0 || end <= start) return;
   builder.addSpecialSlice(start, end);
 };
 
 // TODO(lrn): This array will survive indefinitely if replace is never
-// called again. However, it will be empty, since the contents are cleared 
+// called again. However, it will be empty, since the contents are cleared
 // in the finally block.
 var reusableReplaceArray = $Array(16);
 
 // Helper function for replacing regular expressions with the result of a
 // function application in String.prototype.replace.
 function StringReplaceRegExpWithFunction(subject, regexp, replace) {
   if (regexp.global) {
     var resultArray = reusableReplaceArray;
     if (resultArray) {
       reusableReplaceArray = null;
     } else {
       // Inside a nested replace (replace called from the replacement function
       // of another replace) or we have failed to set the reusable array
       // back due to an exception in a replacement function. Create a new
       // array to use in the future, or until the original is written back.
       resultArray = $Array(16);
     }
     try {
       // Must handle exceptions thrown by the replace functions correctly,
       // including unregistering global regexps.
-      var res = %RegExpExecMultiple(regexp, 
-                                    subject, 
-                                    lastMatchInfo, 
+      var res = %RegExpExecMultiple(regexp,
+                                    subject,
+                                    lastMatchInfo,
                                     resultArray);
       regexp.lastIndex = 0;
       if (IS_NULL(res)) {
-        // No matches at all. 
-        return subject;  
-      }  
-      var len = res.length; 
+        // No matches at all.
+        return subject;
+      }
+      var len = res.length;
       var i = 0;
       if (NUMBER_OF_CAPTURES(lastMatchInfo) == 2) {
         var match_start = 0;
         while (i < len) {
           var elem = res[i];
           if (%_IsSmi(elem)) {
             if (elem > 0) {
               match_start = (elem >> 11) + (elem & 0x7ff);
             } else {
               match_start = res[++i] - elem;
             }
           } else {
             var func_result = replace.call(null, elem, match_start, subject);
             if (!IS_STRING(func_result)) {
               func_result = NonStringToString(func_result);
             }
             res[i] = func_result;
             match_start += elem.length;
           }
           i++;
-        }      
-      } else {      
+        }
+      } else {
         while (i < len) {
           var elem = res[i];
           if (!%_IsSmi(elem)) {
             // elem must be an Array.
             // Use the apply argument as backing for global RegExp properties.
             lastMatchInfoOverride = elem;
             var func_result = replace.apply(null, elem);
             if (!IS_STRING(func_result)) {
               func_result = NonStringToString(func_result);
             }
             res[i] = func_result;
           }
           i++;
         }
       }
       var result = new ReplaceResultBuilder(subject, res);
       return result.generate();
     } finally {
       lastMatchInfoOverride = null;
       resultArray.length = 0;
       reusableReplaceArray = resultArray;
     }
   } else { // Not a global regexp, no need to loop.
     var matchInfo = DoRegExpExec(regexp, subject, 0);
     if (IS_NULL(matchInfo)) return subject;
-    
+
     var result = new ReplaceResultBuilder(subject);
     result.addSpecialSlice(0, matchInfo[CAPTURE0]);
     var endOfMatch = matchInfo[CAPTURE1];
     result.add(ApplyReplacementFunction(replace, matchInfo, subject));
     // Can't use matchInfo any more from here, since the function could
     // overwrite it.
     result.addSpecialSlice(endOfMatch, subject.length);
     return result.generate();
   }
 }
@@ skipping 15 matching lines @@
   for (var j = 0; j < m; j++) {
     parameters[j] = CaptureString(subject, matchInfo, j);
   }
   parameters[j] = index;
   parameters[j + 1] = subject;
   return replace.apply(null, parameters);
 }
 
 
 // ECMA-262 section 15.5.4.12
-function StringSearch(re) { 
+function StringSearch(re) {
   var regexp = new $RegExp(re);
   var s = TO_STRING_INLINE(this);
   var match = DoRegExpExec(regexp, s, 0);
   if (match) {
     lastMatchInfo = match;
     return match[CAPTURE0];
   }
   return -1;
 }
 
@@ skipping 451 matching lines @@
     "small", StringSmall,
     "strike", StringStrike,
     "sub", StringSub,
     "sup", StringSup,
     "toJSON", StringToJSON
   ));
 }
 
 
 SetupString();