Remove trailing regexp from .js files.

src/d8.js

 // Copyright 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 146 matching lines @@
       result += ' in ';
       result += body.invocationText;
       result += ', ';
       result += SourceInfo(body);
       result += '\n';
       result += SourceUnderline(body.sourceLineText, body.sourceColumn);
       Debug.State.currentSourceLine = body.sourceLine;
       Debug.State.currentFrame = 0;
       details.text = result;
       break;
-      
+
     case 'exception':
       if (body.uncaught) {
         result += 'Uncaught: ';
       } else {
         result += 'Exception: ';
       }
       result += '"';
       result += body.exception.text;
       result += '"';
       if (body.sourceLine >= 0) {
@@ skipping 27 matching lines @@
     default:
       details.text = 'Unknown debug event ' + response.event();
   }
 
   return details;
 };
 
 
 function SourceInfo(body) {
   var result = '';
-  
+
   if (body.script) {
     if (body.script.name) {
       result += body.script.name;
     } else {
       result += '[unnamed]';
     }
   }
   result += ' line ';
   result += body.sourceLine + 1;
   result += ' column ';
   result += body.sourceColumn + 1;
-  
+
   return result;
 }
 
 
 function SourceUnderline(source_text, position) {
   if (!source_text) {
     return;
   }
 
   // Create an underline with a caret pointing to the source position. If the
@@ skipping 52 matching lines @@
 
     case 'step':
     case 's':
       this.request_ = this.stepCommandToJSONRequest_(args);
       break;
 
     case 'backtrace':
     case 'bt':
       this.request_ = this.backtraceCommandToJSONRequest_(args);
       break;
-      
+
     case 'frame':
     case 'f':
       this.request_ = this.frameCommandToJSONRequest_(args);
       break;
-      
+
     case 'scopes':
       this.request_ = this.scopesCommandToJSONRequest_(args);
       break;
-      
+
     case 'scope':
       this.request_ = this.scopeCommandToJSONRequest_(args);
       break;
-      
+
     case 'print':
     case 'p':
       this.request_ = this.printCommandToJSONRequest_(args);
       break;
 
     case 'dir':
       this.request_ = this.dirCommandToJSONRequest_(args);
       break;
 
     case 'references':
       this.request_ = this.referencesCommandToJSONRequest_(args);
       break;
 
     case 'instances':
       this.request_ = this.instancesCommandToJSONRequest_(args);
       break;
 
     case 'source':
       this.request_ = this.sourceCommandToJSONRequest_(args);
       break;
-      
+
     case 'scripts':
       this.request_ = this.scriptsCommandToJSONRequest_(args);
       break;
-      
+
     case 'break':
     case 'b':
       this.request_ = this.breakCommandToJSONRequest_(args);
       break;
-      
+
     case 'clear':
       this.request_ = this.clearCommandToJSONRequest_(args);
       break;
 
     case 'threads':
       this.request_ = this.threadsCommandToJSONRequest_(args);
       break;
 
     case 'trace':
       // Return undefined to indicate command handled internally (no JSON).
       this.request_ = void 0;
       this.traceCommand_(args);
       break;
 
     case 'help':
     case '?':
       this.helpCommand_(args);
       // Return undefined to indicate command handled internally (no JSON).
       this.request_ = void 0;
       break;
 
     default:
       throw new Error('Unknown command "' + cmd + '"');
   }
-  
+
   last_cmd = cmd;
 }
 
 DebugRequest.prototype.JSONRequest = function() {
   return this.request_;
 }
 
 
 function RequestPacket(command) {
   this.seq = 0;
@@ skipping 104 matching lines @@
         }
         request.arguments.stepcount = stepcount;
       }
 
       // Get the step action.
       switch (args[0]) {
         case 'in':
         case 'i':
           request.arguments.stepaction = 'in';
           break;
-          
+
         case 'min':
         case 'm':
           request.arguments.stepaction = 'min';
           break;
-          
+
         case 'next':
         case 'n':
           request.arguments.stepaction = 'next';
           break;
-          
+
         case 'out':
         case 'o':
           request.arguments.stepaction = 'out';
           break;
-          
+
         default:
           throw new Error('Invalid step argument "' + args[0] + '".');
       }
     }
   } else {
     // Default is step next.
     request.arguments.stepaction = 'next';
   }
 
   return request.toJSONProtocol();
 };
 
 
 // Create a JSON request for the backtrace command.
 DebugRequest.prototype.backtraceCommandToJSONRequest_ = function(args) {
   // Build a backtrace request from the text command.
   var request = this.createRequest('backtrace');
-  
+
   // Default is to show top 10 frames.
   request.arguments = {};
   request.arguments.fromFrame = 0;
   request.arguments.toFrame = 10;
 
   args = args.split(/\s*[ ]+\s*/g);
   if (args.length == 1 && args[0].length > 0) {
     var frameCount = parseInt(args[0]);
     if (frameCount > 0) {
       // Show top frames.
@@ skipping 82 matching lines @@
   return this.makeEvaluateJSONRequest_(args);
 };
 
 
 // Create a JSON request for the references command.
 DebugRequest.prototype.referencesCommandToJSONRequest_ = function(args) {
   // Build an evaluate request from the text command.
   if (args.length == 0) {
     throw new Error('Missing object id.');
   }
-  
+
   return this.makeReferencesJSONRequest_(args, 'referencedBy');
 };
 
 
 // Create a JSON request for the instances command.
 DebugRequest.prototype.instancesCommandToJSONRequest_ = function(args) {
   // Build an evaluate request from the text command.
   if (args.length == 0) {
     throw new Error('Missing object id.');
   }
-  
+
   // Build a references request.
   return this.makeReferencesJSONRequest_(args, 'constructedBy');
 };
 
 
 // Create a JSON request for the source command.
 DebugRequest.prototype.sourceCommandToJSONRequest_ = function(args) {
   // Build a evaluate request from the text command.
   var request = this.createRequest('source');
 
@@ skipping 33 matching lines @@
 
     if (args.length > 1) {
       throw new Error('Invalid scripts arguments.');
     }
 
     request.arguments = {};
     switch (args[0]) {
       case 'natives':
         request.arguments.types = ScriptTypeFlag(Debug.ScriptType.Native);
         break;
-        
+
       case 'extensions':
         request.arguments.types = ScriptTypeFlag(Debug.ScriptType.Extension);
         break;
-        
+
       case 'all':
         request.arguments.types =
             ScriptTypeFlag(Debug.ScriptType.Normal) |
             ScriptTypeFlag(Debug.ScriptType.Native) |
             ScriptTypeFlag(Debug.ScriptType.Extension);
         break;
-        
+
       default:
         throw new Error('Invalid argument "' + args[0] + '".');
     }
   }
 
   return request.toJSONProtocol();
 };
 
 
 // Create a JSON request for the break command.
@@ skipping 17 matching lines @@
       condition = args.substring(pos + 1, args.length);
     }
 
     // Check for script breakpoint (name:line[:column]). If no ':' in break
     // specification it is considered a function break point.
     pos = target.indexOf(':');
     if (pos > 0) {
       type = 'script';
       var tmp = target.substring(pos + 1, target.length);
       target = target.substring(0, pos);
-      
+
       // Check for both line and column.
       pos = tmp.indexOf(':');
       if (pos > 0) {
         column = parseInt(tmp.substring(pos + 1, tmp.length)) - 1;
         line = parseInt(tmp.substring(0, pos)) - 1;
       } else {
         line = parseInt(tmp) - 1;
       }
     } else if (target[0] == '#' && target[target.length - 1] == '#') {
       type = 'handle';
       target = target.substring(1, target.length - 1);
     } else {
       type = 'function';
     }
-  
+
     request.arguments = {};
     request.arguments.type = type;
     request.arguments.target = target;
     request.arguments.line = line;
     request.arguments.column = column;
     request.arguments.condition = condition;
   } else {
     throw new Error('Invalid break arguments.');
   }
 
@@ skipping 160 matching lines @@
     details.running = response.running();
 
     var body = response.body();
     var result = '';
     switch (response.command()) {
       case 'setbreakpoint':
         result = 'set breakpoint #';
         result += body.breakpoint;
         details.text = result;
         break;
-        
+
       case 'clearbreakpoint':
         result = 'cleared breakpoint #';
         result += body.breakpoint;
         details.text = result;
         break;
-        
+
       case 'backtrace':
         if (body.totalFrames == 0) {
           result = '(empty stack)';
         } else {
           var result = 'Frames #' + body.fromFrame + ' to #' +
               (body.toFrame - 1) + ' of ' + body.totalFrames + '\n';
           for (i = 0; i < body.frames.length; i++) {
             if (i != 0) result += '\n';
             result += body.frames[i].text;
           }
         }
         details.text = result;
         break;
-        
+
       case 'frame':
         details.text = SourceUnderline(body.sourceLineText,
                                        body.column);
         Debug.State.currentSourceLine = body.line;
         Debug.State.currentFrame = body.index;
         break;
-        
+
       case 'scopes':
         if (body.totalScopes == 0) {
           result = '(no scopes)';
         } else {
           result = 'Scopes #' + body.fromScope + ' to #' +
                    (body.toScope - 1) + ' of ' + body.totalScopes + '\n';
           for (i = 0; i < body.scopes.length; i++) {
             if (i != 0) {
               result += '\n';
             }
             result += formatScope_(body.scopes[i]);
           }
         }
         details.text = result;
         break;
 
       case 'scope':
         result += formatScope_(body);
         result += '\n';
         var scope_object_value = response.lookup(body.object.ref);
         result += formatObject_(scope_object_value, true);
         details.text = result;
         break;
-      
+
       case 'evaluate':
       case 'lookup':
         if (last_cmd == 'p' || last_cmd == 'print') {
           result = body.text;
         } else {
           var value;
           if (lookup_handle) {
             value = response.bodyValue(lookup_handle);
           } else {
             value = response.bodyValue();
@@ skipping 23 matching lines @@
         var count = body.length;
         result += 'found ' + count + ' objects';
         result += '\n';
         for (var i = 0; i < count; i++) {
           var value = response.bodyValue(i);
           result += formatObject_(value, false);
           result += '\n';
         }
         details.text = result;
         break;
-        
+
       case 'source':
         // Get the source from the response.
         var source = body.source;
         var from_line = body.fromLine + 1;
         var lines = source.split('\n');
         var maxdigits = 1 + Math.floor(log10(from_line + lines.length));
         if (maxdigits < 3) {
           maxdigits = 3;
         }
         var result = '';
@@ skipping 14 matching lines @@
             for (var i = 0; i < spacer; i++) {
               result += ' ';
             }
             result += current_line + ': ';
           }
           result += lines[num];
           result += '\n';
         }
         details.text = result;
         break;
-        
+
       case 'scripts':
         var result = '';
         for (i = 0; i < body.length; i++) {
           if (i != 0) result += '\n';
           if (body[i].id) {
             result += body[i].id;
           } else {
             result += '[no id]';
           }
           result += ', ';
@@ skipping 41 matching lines @@
           result += ' ';
           result += body.threads[i].id;
           result += '\n';
         }
         details.text = result;
         break;
 
       case 'continue':
         details.text = "(running)";
         break;
-        
+
       default:
         details.text =
             'Response for unknown command \'' + response.command + '\'' +
             ' (' + json_response + ')';
     }
   } catch (e) {
     details.text = 'Error: "' + e + '" formatting response';
   }
-  
+
   return details;
 };
 
 
 /**
  * Protocol packages send from the debugger.
  * @param {string} json - raw protocol packet as JSON string.
  * @constructor
  */
 function ProtocolPackage(json) {
@@ skipping 96 matching lines @@
 /**
  * Get the value type.
  * @return {String} the value type
  */
 ProtocolValue.prototype.type = function() {
   return this.value_.type;
 }
 
 
 /**
- * Get a metadata field from a protocol value. 
+ * Get a metadata field from a protocol value.
  * @return {Object} the metadata field value
  */
 ProtocolValue.prototype.field = function(name) {
   return this.value_[name];
 }
 
 
 /**
  * Check is the value is a primitive value.
  * @return {boolean} true if the value is primitive
@@ skipping 160 matching lines @@
   return '{' + content.join(',') + '}';
 }
 
 
 function ArrayToJSONArray_(content) {
   return '[' + content.join(',') + ']';
 }
 
 
 function BooleanToJSON_(value) {
-  return String(value); 
+  return String(value);
 }
 
 
 function NumberToJSON_(value) {
-  return String(value); 
+  return String(value);
 }
 
 
 // Mapping of some control characters to avoid the \uXXXX syntax for most
 // commonly used control cahracters.
 const ctrlCharMap_ = {
   '\b': '\\b',
   '\t': '\\t',
   '\n': '\\n',
   '\f': '\\f',
@@ skipping 162 matching lines @@
       json += NumberToJSON_(elem);
     } else if (typeof(elem) === 'string')  {
       json += StringToJSON_(elem);
     } else {
       json += elem;
     }
   }
   json += ']';
   return json;
 }