Clean up JavaScript files to better follow coding standard.

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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 String.prototype.startsWith = function (str) {
-  if (str.length > this.length)
+  if (str.length > this.length) {
     return false;
+  }
   return this.substr(0, str.length) == str;
-}
+};
 
 function log10(num) {
   return Math.log(num)/Math.log(10);
 }
 
 function ToInspectableObject(obj) {
   if (!obj && typeof obj === 'object') {
     return void 0;
   } else {
     return Object(obj);
   }
 }
 
 function GetCompletions(global, last, full) {
   var full_tokens = full.split();
   full = full_tokens.pop();
   var parts = full.split('.');
   parts.pop();
   var current = global;
   for (var i = 0; i < parts.length; i++) {
     var part = parts[i];
     var next = current[part];
-    if (!next)
+    if (!next) {
       return [];
+    }
     current = next;
   }
   var result = [];
   current = ToInspectableObject(current);
   while (typeof current !== 'undefined') {
     var mirror = new $debug.ObjectMirror(current);
     var properties = mirror.properties();
     for (var i = 0; i < properties.length; i++) {
       var name = properties[i].name();
-      if (typeof name === 'string' && name.startsWith(last))
+      if (typeof name === 'string' && name.startsWith(last)) {
         result.push(name);
+      }
     }
     current = ToInspectableObject(current.__proto__);
   }
   return result;
 }
 
 
 // Global object holding debugger related constants and state.
 const Debug = {};
 
@@ skipping 29 matching lines @@
                     Block: 5 };
 
 
 // Current debug state.
 const kNoFrame = -1;
 Debug.State = {
   currentFrame: kNoFrame,
   displaySourceStartLine: -1,
   displaySourceEndLine: -1,
   currentSourceLine: -1
-}
+};
 var trace_compile = false;  // Tracing all compile events?
 var trace_debug_json = false; // Tracing all debug json packets?
 var last_cmd_line = '';
 //var lol_is_enabled;  // Set to true in d8.cc if LIVE_OBJECT_LIST is defined.
 var lol_next_dump_index = 0;
 const kDefaultLolLinesToPrintAtATime = 10;
 const kMaxLolLinesToPrintAtATime = 1000;
 var repeat_cmd_line = '';
 var is_running = true;
 
@@ skipping 15 matching lines @@
   is_running = response.running();
 
   if (response.type() == 'event') {
     return DebugEventDetails(response);
   } else {
     return DebugResponseDetails(response);
   }
 }
 
 function DebugEventDetails(response) {
-  details = {text:'', running:false}
+  details = {text:'', running:false};
 
   // Get the running state.
   details.running = response.running();
 
   var body = response.body();
   var result = '';
   switch (response.event()) {
     case 'break':
       if (body.breakpoints) {
         result += 'breakpoint';
@@ skipping 46 matching lines @@
         Debug.State.currentSourceLine = -1;
         Debug.State.displaySourceStartLine = -1;
         Debug.State.displaySourceEndLine = -1;
         Debug.State.currentFrame = kNoFrame;
       }
       details.text = result;
       break;
 
     case 'afterCompile':
       if (trace_compile) {
-        result = 'Source ' + body.script.name + ' compiled:\n'
+        result = 'Source ' + body.script.name + ' compiled:\n';
         var source = body.script.source;
         if (!(source[source.length - 1] == '\n')) {
           result += source;
         } else {
           result += source.substring(0, source.length - 1);
         }
       }
       details.text = result;
       break;
 
     case 'scriptCollected':
       details.text = result;
       break;
 
     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]';
@@ skipping 21 matching lines @@
     if (source_text[i] == '\t') {
       underline += '\t';
     } else {
       underline += ' ';
     }
   }
   underline += '^';
 
   // Return the source line text with the underline beneath.
   return source_text + '\n' + underline;
-};
+}
 
 
 // Converts a text command to a JSON request.
 function DebugCommandToJSONRequest(cmd_line) {
   var result = new DebugRequest(cmd_line).JSONRequest();
   if (trace_debug_json && result) {
     print("sending: '" + result + "'");
   }
   return result;
-};
+}
 
 
 function DebugRequest(cmd_line) {
   // If the very first character is a { assume that a JSON request have been
   // entered as a command. Converting that to a JSON request is trivial.
   if (cmd_line && cmd_line.length > 0 && cmd_line.charAt(0) == '{') {
     this.request_ = cmd_line;
     return;
   }
 
@@ skipping 204 matching lines @@
         break;
       }
 
     default:
       throw new Error('Unknown command "' + cmd + '"');
   }
 }
 
 DebugRequest.prototype.JSONRequest = function() {
   return this.request_;
-}
+};
 
 
 function RequestPacket(command) {
   this.seq = 0;
   this.type = 'request';
   this.command = command;
 }
 
 
 RequestPacket.prototype.toJSONProtocol = function() {
   // Encode the protocol header.
   var json = '{';
   json += '"seq":' + this.seq;
   json += ',"type":"' + this.type + '"';
   if (this.command) {
     json += ',"command":' + StringToJSON_(this.command);
   }
   if (this.arguments) {
     json += ',"arguments":';
     // Encode the arguments part.
     if (this.arguments.toJSONProtocol) {
-      json += this.arguments.toJSONProtocol()
+      json += this.arguments.toJSONProtocol();
     } else {
       json += SimpleObjectToJSON_(this.arguments);
     }
   }
   json += '}';
   return json;
-}
+};
 
 
 DebugRequest.prototype.createRequest = function(command) {
   return new RequestPacket(command);
 };
 
 
 // Note: we use detected command repetition as a signal for continuation here.
 DebugRequest.prototype.createLOLRequest = function(command,
                                                    start_index,
@@ skipping 746 matching lines @@
     request.arguments.filter.type = type_filter;
   }
   if (space_filter) {
     request.arguments.filter.space = space_filter;
   }
   if (prop_filter) {
     request.arguments.filter.prop = prop_filter;
   }
 
   return request;
-}
+};
 
 
 function extractObjId(args) {
   var id = args;
   id = id.match(/^@([0-9]+)$/);
   if (id) {
     id = id[1];
   } else {
     throw new Error('Invalid obj id ' + args + '.');
   }
@@ skipping 168 matching lines @@
     } else if (args === 'debug json' || args === 'json' || args === 'packets') {
       trace_debug_json = !trace_debug_json;
       print('Tracing of debug json packets ' +
             (trace_debug_json ? 'on' : 'off'));
     } else {
       throw new Error('Invalid trace arguments.');
     }
   } else {
     throw new Error('Invalid trace arguments.');
   }
-}
+};
 
 // Handle the help command.
 DebugRequest.prototype.helpCommand_ = function(args) {
   // Help os quite simple.
   if (args && args.length > 0) {
     print('warning: arguments to \'help\' are ignored');
   }
 
   print('Note: <> denotes symbollic values to be replaced with real values.');
   print('Note: [] denotes optional parts of commands, or optional options / arguments.');
@@ skipping 88 matching lines @@
     print('     is specified, then a verbose dump will requested.  Else, a summary dump');
     print('     will be requested.');
     print('');
   }
 
   print('trace compile');
   // hidden command: trace debug json - toggles tracing of debug json packets
   print('');
   print('disconnect|exit|quit       - disconnects and quits the debugger');
   print('help                       - prints this help information');
-}
+};
 
 
 function formatHandleReference_(value) {
   if (value.handle() >= 0) {
     return '#' + value.handle() + '#';
   } else {
     return '#Transient#';
   }
 }
 
 
 function formatObject_(value, include_properties) {
   var result = '';
   result += formatHandleReference_(value);
-  result += ', type: object'
+  result += ', type: object';
   result += ', constructor ';
   var ctor = value.constructorFunctionValue();
   result += formatHandleReference_(ctor);
   result += ', __proto__ ';
   var proto = value.protoObjectValue();
   result += formatHandleReference_(proto);
   result += ', ';
   result += value.propertyCount();
   result +=  ' properties.';
   if (include_properties) {
@@ skipping 299 matching lines @@
 
 // Rounds number 'num' to 'length' decimal places.
 function roundNumber(num, length) {
   var factor = Math.pow(10, length);
   return Math.round(num * factor) / factor;
 }
 
 
 // Convert a JSON response to text for display in a text based debugger.
 function DebugResponseDetails(response) {
-  details = {text:'', running:false}
+  details = { text: '', running: false };
 
   try {
     if (!response.success()) {
       details.text = response.message();
       return details;
     }
 
     // Get the running state.
     details.running = response.running();
 
@@ skipping 344 matching lines @@
       default:
         details.text =
             'Response for unknown command \'' + response.command() + '\'' +
             ' (' + response.raw_json() + ')';
     }
   } 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) {
   this.raw_json_ = json;
   this.packet_ = JSON.parse(json);
   this.refs_ = [];
   if (this.packet_.refs) {
     for (var i = 0; i < this.packet_.refs.length; i++) {
       this.refs_[this.packet_.refs[i].handle] = this.packet_.refs[i];
     }
   }
 }
 
 
 /**
  * Get the packet type.
  * @return {String} the packet type
  */
 ProtocolPackage.prototype.type = function() {
   return this.packet_.type;
-}
+};
 
 
 /**
  * Get the packet event.
  * @return {Object} the packet event
  */
 ProtocolPackage.prototype.event = function() {
   return this.packet_.event;
-}
+};
 
 
 /**
  * Get the packet request sequence.
  * @return {number} the packet request sequence
  */
 ProtocolPackage.prototype.requestSeq = function() {
   return this.packet_.request_seq;
-}
+};
 
 
 /**
  * Get the packet request sequence.
  * @return {number} the packet request sequence
  */
 ProtocolPackage.prototype.running = function() {
   return this.packet_.running ? true : false;
-}
+};
 
 
 ProtocolPackage.prototype.success = function() {
   return this.packet_.success ? true : false;
-}
+};
 
 
 ProtocolPackage.prototype.message = function() {
   return this.packet_.message;
-}
+};
 
 
 ProtocolPackage.prototype.command = function() {
   return this.packet_.command;
-}
+};
 
 
 ProtocolPackage.prototype.body = function() {
   return this.packet_.body;
-}
+};
 
 
 ProtocolPackage.prototype.bodyValue = function(index) {
   if (index != null) {
     return new ProtocolValue(this.packet_.body[index], this);
   } else {
     return new ProtocolValue(this.packet_.body, this);
   }
-}
+};
 
 
 ProtocolPackage.prototype.body = function() {
   return this.packet_.body;
-}
+};
 
 
 ProtocolPackage.prototype.lookup = function(handle) {
   var value = this.refs_[handle];
   if (value) {
     return new ProtocolValue(value, this);
   } else {
     return new ProtocolReference(handle);
   }
-}
+};
 
 
 ProtocolPackage.prototype.raw_json = function() {
   return this.raw_json_;
-}
+};
 
 
 function ProtocolValue(value, packet) {
   this.value_ = value;
   this.packet_ = packet;
 }
 
 
 /**
  * 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.
  * @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
  */
 ProtocolValue.prototype.isPrimitive = function() {
   return this.isUndefined() || this.isNull() || this.isBoolean() ||
          this.isNumber() || this.isString();
-}
+};
 
 
 /**
  * Get the object handle.
  * @return {number} the value handle
  */
 ProtocolValue.prototype.handle = function() {
   return this.value_.handle;
-}
+};
 
 
 /**
  * Check is the value is undefined.
  * @return {boolean} true if the value is undefined
  */
 ProtocolValue.prototype.isUndefined = function() {
   return this.value_.type == 'undefined';
-}
+};
 
 
 /**
  * Check is the value is null.
  * @return {boolean} true if the value is null
  */
 ProtocolValue.prototype.isNull = function() {
   return this.value_.type == 'null';
-}
+};
 
 
 /**
  * Check is the value is a boolean.
  * @return {boolean} true if the value is a boolean
  */
 ProtocolValue.prototype.isBoolean = function() {
   return this.value_.type == 'boolean';
-}
+};
 
 
 /**
  * Check is the value is a number.
  * @return {boolean} true if the value is a number
  */
 ProtocolValue.prototype.isNumber = function() {
   return this.value_.type == 'number';
-}
+};
 
 
 /**
  * Check is the value is a string.
  * @return {boolean} true if the value is a string
  */
 ProtocolValue.prototype.isString = function() {
   return this.value_.type == 'string';
-}
+};
 
 
 /**
  * Check is the value is an object.
  * @return {boolean} true if the value is an object
  */
 ProtocolValue.prototype.isObject = function() {
   return this.value_.type == 'object' || this.value_.type == 'function' ||
          this.value_.type == 'error' || this.value_.type == 'regexp';
-}
+};
 
 
 /**
  * Get the constructor function
  * @return {ProtocolValue} constructor function
  */
 ProtocolValue.prototype.constructorFunctionValue = function() {
   var ctor = this.value_.constructorFunction;
   return this.packet_.lookup(ctor.ref);
-}
+};
 
 
 /**
  * Get the __proto__ value
  * @return {ProtocolValue} __proto__ value
  */
 ProtocolValue.prototype.protoObjectValue = function() {
   var proto = this.value_.protoObject;
   return this.packet_.lookup(proto.ref);
-}
+};
 
 
 /**
  * Get the number og properties.
  * @return {number} the number of properties
  */
 ProtocolValue.prototype.propertyCount = function() {
   return this.value_.properties ? this.value_.properties.length : 0;
-}
+};
 
 
 /**
  * Get the specified property name.
  * @return {string} property name
  */
 ProtocolValue.prototype.propertyName = function(index) {
   var property = this.value_.properties[index];
   return property.name;
-}
+};
 
 
 /**
  * Return index for the property name.
  * @param name The property name to look for
  * @return {number} index for the property name
  */
 ProtocolValue.prototype.propertyIndex = function(name) {
   for (var i = 0; i < this.propertyCount(); i++) {
     if (this.value_.properties[i].name == name) {
       return i;
     }
   }
   return null;
-}
+};
 
 
 /**
  * Get the specified property value.
  * @return {ProtocolValue} property value
  */
 ProtocolValue.prototype.propertyValue = function(index) {
   var property = this.value_.properties[index];
   return this.packet_.lookup(property.ref);
-}
+};
 
 
 /**
  * Check is the value is a string.
  * @return {boolean} true if the value is a string
  */
 ProtocolValue.prototype.value = function() {
   return this.value_.value;
-}
+};
 
 
 ProtocolValue.prototype.valueString = function() {
   return this.value_.text;
-}
+};
 
 
 function ProtocolReference(handle) {
   this.handle_ = handle;
 }
 
 
 ProtocolReference.prototype.handle = function() {
   return this.handle_;
-}
+};
 
 
 function MakeJSONPair_(name, value) {
   return '"' + name + '":' + value;
 }
 
 
 function ArrayToJSONObject_(content) {
   return '{' + content.join(',') + '}';
 }
@@ skipping 50 matching lines @@
     // Replace ", \ and control characters (0x00 - 0x1F).
     return '"' +
       value.replace(ctrlCharMatch_, function (char) {
         // Use charmap if possible.
         var mapped = ctrlCharMap_[char];
         if (mapped) return mapped;
         mapped = char.charCodeAt();
         // Convert control character to unicode escape sequence.
         return '\\u00' +
           '0' + // TODO %NumberToRadixString(Math.floor(mapped / 16), 16) +
-          '0' // TODO %NumberToRadixString(mapped % 16, 16);
+          '0'; // TODO %NumberToRadixString(mapped % 16, 16)
       })
     + '"';
   }
 
   // Simple string with no special characters.
   return '"' + value + '"';
 }
 
 
 /**
@@ skipping 50 matching lines @@
     if (typeof key == 'string') {
       var property_value = object[key];
 
       // Format the value based on its type.
       var property_value_json;
       switch (typeof property_value) {
         case 'object':
           if (property_value === null) {
             property_value_json = 'null';
           } else if (typeof property_value.toJSONProtocol == 'function') {
-            property_value_json = property_value.toJSONProtocol(true)
+            property_value_json = property_value.toJSONProtocol(true);
           } else if (property_value.constructor.name == 'Array'){
             property_value_json = SimpleArrayToJSON_(property_value);
           } else {
             property_value_json = SimpleObjectToJSON_(property_value);
           }
           break;
 
         case 'boolean':
           property_value_json = BooleanToJSON_(property_value);
           break;
@@ skipping 30 matching lines @@
  */
 function SimpleArrayToJSON_(array) {
   // Make JSON array representation.
   var json = '[';
   for (var i = 0; i < array.length; i++) {
     if (i != 0) {
       json += ',';
     }
     var elem = array[i];
     if (elem.toJSONProtocol) {
-      json += elem.toJSONProtocol(true)
+      json += elem.toJSONProtocol(true);
     } else if (typeof(elem) === 'object')  {
       json += SimpleObjectToJSON_(elem);
     } else if (typeof(elem) === 'boolean')  {
       json += BooleanToJSON_(elem);
     } else if (typeof(elem) === 'number')  {
       json += NumberToJSON_(elem);
     } else if (typeof(elem) === 'string')  {
       json += StringToJSON_(elem);
     } else {
       json += elem;
     }
   }
   json += ']';
   return json;
 }