Clean up JavaScript files to better follow coding standard.

src/mirror-debugger.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 207 matching lines @@
 //     - ScriptMirror
 
 
 /**
  * Base class for all mirror objects.
  * @param {string} type The type of the mirror
  * @constructor
  */
 function Mirror(type) {
   this.type_ = type;
-};
+}
 
 
 Mirror.prototype.type = function() {
   return this.type_;
 };
 
 
 /**
  * Check whether the mirror reflects a value.
  * @returns {boolean} True if the mirror reflects a value.
  */
 Mirror.prototype.isValue = function() {
   return this instanceof ValueMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects the undefined value.
  * @returns {boolean} True if the mirror reflects the undefined value.
  */
 Mirror.prototype.isUndefined = function() {
   return this instanceof UndefinedMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects the null value.
  * @returns {boolean} True if the mirror reflects the null value
  */
 Mirror.prototype.isNull = function() {
   return this instanceof NullMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a boolean value.
  * @returns {boolean} True if the mirror reflects a boolean value
  */
 Mirror.prototype.isBoolean = function() {
   return this instanceof BooleanMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a number value.
  * @returns {boolean} True if the mirror reflects a number value
  */
 Mirror.prototype.isNumber = function() {
   return this instanceof NumberMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a string value.
  * @returns {boolean} True if the mirror reflects a string value
  */
 Mirror.prototype.isString = function() {
   return this instanceof StringMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects an object.
  * @returns {boolean} True if the mirror reflects an object
  */
 Mirror.prototype.isObject = function() {
   return this instanceof ObjectMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a function.
  * @returns {boolean} True if the mirror reflects a function
  */
 Mirror.prototype.isFunction = function() {
   return this instanceof FunctionMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects an unresolved function.
  * @returns {boolean} True if the mirror reflects an unresolved function
  */
 Mirror.prototype.isUnresolvedFunction = function() {
   return this instanceof UnresolvedFunctionMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects an array.
  * @returns {boolean} True if the mirror reflects an array
  */
 Mirror.prototype.isArray = function() {
   return this instanceof ArrayMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a date.
  * @returns {boolean} True if the mirror reflects a date
  */
 Mirror.prototype.isDate = function() {
   return this instanceof DateMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a regular expression.
  * @returns {boolean} True if the mirror reflects a regular expression
  */
 Mirror.prototype.isRegExp = function() {
   return this instanceof RegExpMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects an error.
  * @returns {boolean} True if the mirror reflects an error
  */
 Mirror.prototype.isError = function() {
   return this instanceof ErrorMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a property.
  * @returns {boolean} True if the mirror reflects a property
  */
 Mirror.prototype.isProperty = function() {
   return this instanceof PropertyMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a stack frame.
  * @returns {boolean} True if the mirror reflects a stack frame
  */
 Mirror.prototype.isFrame = function() {
   return this instanceof FrameMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a script.
  * @returns {boolean} True if the mirror reflects a script
  */
 Mirror.prototype.isScript = function() {
   return this instanceof ScriptMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a context.
  * @returns {boolean} True if the mirror reflects a context
  */
 Mirror.prototype.isContext = function() {
   return this instanceof ContextMirror;
-}
+};
 
 
 /**
  * Check whether the mirror reflects a scope.
  * @returns {boolean} True if the mirror reflects a scope
  */
 Mirror.prototype.isScope = function() {
   return this instanceof ScopeMirror;
-}
+};
 
 
 /**
  * Allocate a handle id for this object.
  */
 Mirror.prototype.allocateHandle_ = function() {
   this.handle_ = next_handle_++;
-}
+};
 
 
 /**
  * Allocate a transient handle id for this object. Transient handles are
  * negative.
  */
 Mirror.prototype.allocateTransientHandle_ = function() {
   this.handle_ = next_transient_handle_--;
-}
+};
 
 
 Mirror.prototype.toText = function() {
   // Simpel to text which is used when on specialization in subclass.
   return "#<" + this.constructor.name + ">";
-}
+};
 
 
 /**
  * Base class for all value mirror objects.
  * @param {string} type The type of the mirror
  * @param {value} value The value reflected by this mirror
  * @param {boolean} transient indicate whether this object is transient with a
  *    transient handle
  * @constructor
  * @extends Mirror
@@ skipping 44 matching lines @@
  * @extends ValueMirror
  */
 function UndefinedMirror() {
   %_CallFunction(this, UNDEFINED_TYPE, void 0, ValueMirror);
 }
 inherits(UndefinedMirror, ValueMirror);
 
 
 UndefinedMirror.prototype.toText = function() {
   return 'undefined';
-}
+};
 
 
 /**
  * Mirror object for null.
  * @constructor
  * @extends ValueMirror
  */
 function NullMirror() {
   %_CallFunction(this, NULL_TYPE, null, ValueMirror);
 }
 inherits(NullMirror, ValueMirror);
 
 
 NullMirror.prototype.toText = function() {
   return 'null';
-}
+};
 
 
 /**
  * Mirror object for boolean values.
  * @param {boolean} value The boolean value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function BooleanMirror(value) {
   %_CallFunction(this, BOOLEAN_TYPE, value, ValueMirror);
 }
 inherits(BooleanMirror, ValueMirror);
 
 
 BooleanMirror.prototype.toText = function() {
   return this.value_ ? 'true' : 'false';
-}
+};
 
 
 /**
  * Mirror object for number values.
  * @param {number} value The number value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function NumberMirror(value) {
   %_CallFunction(this, NUMBER_TYPE, value, ValueMirror);
 }
 inherits(NumberMirror, ValueMirror);
 
 
 NumberMirror.prototype.toText = function() {
   return %NumberToString(this.value_);
-}
+};
 
 
 /**
  * Mirror object for string values.
  * @param {string} value The string value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function StringMirror(value) {
   %_CallFunction(this, STRING_TYPE, value, ValueMirror);
 }
 inherits(StringMirror, ValueMirror);
 
 
 StringMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 StringMirror.prototype.getTruncatedValue = function(maxLength) {
   if (maxLength != -1 && this.length() > maxLength) {
     return this.value_.substring(0, maxLength) +
            '... (length: ' + this.length() + ')';
   }
   return this.value_;
-}
+};
 
 StringMirror.prototype.toText = function() {
   return this.getTruncatedValue(kMaxProtocolStringLength);
-}
+};
 
 
 /**
  * Mirror object for objects.
  * @param {object} value The object reflected by this mirror
  * @param {boolean} transient indicate whether this object is transient with a
  *    transient handle
  * @constructor
  * @extends ValueMirror
  */
@@ skipping 318 matching lines @@
 
     return result;
   } else {
     return [];
   }
 };
 
 
 FunctionMirror.prototype.toText = function() {
   return this.source();
-}
+};
 
 
 /**
  * Mirror object for unresolved functions.
  * @param {string} value The name for the unresolved function reflected by this
  *     mirror.
  * @constructor
  * @extends ObjectMirror
  */
 function UnresolvedFunctionMirror(value) {
@@ skipping 32 matching lines @@
 };
 
 
 UnresolvedFunctionMirror.prototype.inferredName = function() {
   return undefined;
 };
 
 
 UnresolvedFunctionMirror.prototype.propertyNames = function(kind, limit) {
   return [];
-}
+};
 
 
 /**
  * Mirror object for arrays.
  * @param {Array} value The Array object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ArrayMirror(value) {
   %_CallFunction(this, value, ObjectMirror);
 }
 inherits(ArrayMirror, ObjectMirror);
 
 
 ArrayMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 
-ArrayMirror.prototype.indexedPropertiesFromRange = function(opt_from_index, opt_to_index) {
+ArrayMirror.prototype.indexedPropertiesFromRange = function(opt_from_index,
+                                                            opt_to_index) {
   var from_index = opt_from_index || 0;
   var to_index = opt_to_index || this.length() - 1;
   if (from_index > to_index) return new Array();
   var values = new Array(to_index - from_index + 1);
   for (var i = from_index; i <= to_index; i++) {
     var details = %DebugGetPropertyDetails(this.value_, %ToString(i));
     var value;
     if (details) {
       value = new PropertyMirror(this, i, details);
     } else {
       value = GetUndefinedMirror();
     }
     values[i - from_index] = value;
   }
   return values;
-}
+};
 
 
 /**
  * Mirror object for dates.
  * @param {Date} value The Date object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function DateMirror(value) {
   %_CallFunction(this, value, ObjectMirror);
 }
 inherits(DateMirror, ObjectMirror);
 
 
 DateMirror.prototype.toText = function() {
   var s = JSON.stringify(this.value_);
   return s.substring(1, s.length - 1);  // cut quotes
-}
+};
 
 
 /**
  * Mirror object for regular expressions.
  * @param {RegExp} value The RegExp object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function RegExpMirror(value) {
   %_CallFunction(this, value, REGEXP_TYPE, ObjectMirror);
@@ skipping 33 matching lines @@
  * @return {boolean} Value of the multiline flag
  */
 RegExpMirror.prototype.multiline = function() {
   return this.value_.multiline;
 };
 
 
 RegExpMirror.prototype.toText = function() {
   // Simpel to text which is used when on specialization in subclass.
   return "/" + this.source() + "/";
-}
+};
 
 
 /**
  * Mirror object for error objects.
  * @param {Error} value The error object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ErrorMirror(value) {
   %_CallFunction(this, value, ERROR_TYPE, ObjectMirror);
@@ skipping 12 matching lines @@
 
 ErrorMirror.prototype.toText = function() {
   // Use the same text representation as in messages.js.
   var text;
   try {
     str = %_CallFunction(this.value_, builtins.ErrorToString);
   } catch (e) {
     str = '#<Error>';
   }
   return str;
-}
+};
 
 
 /**
  * Base mirror object for properties.
  * @param {ObjectMirror} mirror The mirror object having this property
  * @param {string} name The name of the property
  * @param {Array} details Details about the property
  * @constructor
  * @extends Mirror
  */
 function PropertyMirror(mirror, name, details) {
   %_CallFunction(this, PROPERTY_TYPE, Mirror);
   this.mirror_ = mirror;
   this.name_ = name;
   this.value_ = details[0];
   this.details_ = details[1];
   if (details.length > 2) {
-    this.exception_ = details[2]
+    this.exception_ = details[2];
     this.getter_ = details[3];
     this.setter_ = details[4];
   }
 }
 inherits(PropertyMirror, Mirror);
 
 
 PropertyMirror.prototype.isReadOnly = function() {
   return (this.attributes() & PropertyAttribute.ReadOnly) != 0;
-}
+};
 
 
 PropertyMirror.prototype.isEnum = function() {
   return (this.attributes() & PropertyAttribute.DontEnum) == 0;
-}
+};
 
 
 PropertyMirror.prototype.canDelete = function() {
   return (this.attributes() & PropertyAttribute.DontDelete) == 0;
-}
+};
 
 
 PropertyMirror.prototype.name = function() {
   return this.name_;
-}
+};
 
 
 PropertyMirror.prototype.isIndexed = function() {
   for (var i = 0; i < this.name_.length; i++) {
     if (this.name_[i] < '0' || '9' < this.name_[i]) {
       return false;
     }
   }
   return true;
-}
+};
 
 
 PropertyMirror.prototype.value = function() {
   return MakeMirror(this.value_, false);
-}
+};
 
 
 /**
  * Returns whether this property value is an exception.
  * @return {booolean} True if this property value is an exception
  */
 PropertyMirror.prototype.isException = function() {
   return this.exception_ ? true : false;
-}
+};
 
 
 PropertyMirror.prototype.attributes = function() {
   return %DebugPropertyAttributesFromDetails(this.details_);
-}
+};
 
 
 PropertyMirror.prototype.propertyType = function() {
   return %DebugPropertyTypeFromDetails(this.details_);
-}
+};
 
 
 PropertyMirror.prototype.insertionIndex = function() {
   return %DebugPropertyIndexFromDetails(this.details_);
-}
+};
 
 
 /**
  * Returns whether this property has a getter defined through __defineGetter__.
  * @return {booolean} True if this property has a getter
  */
 PropertyMirror.prototype.hasGetter = function() {
   return this.getter_ ? true : false;
-}
+};
 
 
 /**
  * Returns whether this property has a setter defined through __defineSetter__.
  * @return {booolean} True if this property has a setter
  */
 PropertyMirror.prototype.hasSetter = function() {
   return this.setter_ ? true : false;
-}
+};
 
 
 /**
  * Returns the getter for this property defined through __defineGetter__.
  * @return {Mirror} FunctionMirror reflecting the getter function or
  *     UndefinedMirror if there is no getter for this property
  */
 PropertyMirror.prototype.getter = function() {
   if (this.hasGetter()) {
     return MakeMirror(this.getter_);
   } else {
     return GetUndefinedMirror();
   }
-}
+};
 
 
 /**
  * Returns the setter for this property defined through __defineSetter__.
  * @return {Mirror} FunctionMirror reflecting the setter function or
  *     UndefinedMirror if there is no setter for this property
  */
 PropertyMirror.prototype.setter = function() {
   if (this.hasSetter()) {
     return MakeMirror(this.setter_);
   } else {
     return GetUndefinedMirror();
   }
-}
+};
 
 
 /**
  * Returns whether this property is natively implemented by the host or a set
  * through JavaScript code.
  * @return {boolean} True if the property is
  *     UndefinedMirror if there is no setter for this property
  */
 PropertyMirror.prototype.isNative = function() {
   return (this.propertyType() == PropertyType.Interceptor) ||
          ((this.propertyType() == PropertyType.Callbacks) &&
           !this.hasGetter() && !this.hasSetter());
-}
+};
 
 
 const kFrameDetailsFrameIdIndex = 0;
 const kFrameDetailsReceiverIndex = 1;
 const kFrameDetailsFunctionIndex = 2;
 const kFrameDetailsArgumentCountIndex = 3;
 const kFrameDetailsLocalCountIndex = 4;
 const kFrameDetailsSourcePositionIndex = 5;
 const kFrameDetailsConstructCallIndex = 6;
 const kFrameDetailsAtReturnIndex = 7;
@@ skipping 30 matching lines @@
  */
 function FrameDetails(break_id, index) {
   this.break_id_ = break_id;
   this.details_ = %GetFrameDetails(break_id, index);
 }
 
 
 FrameDetails.prototype.frameId = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsFrameIdIndex];
-}
+};
 
 
 FrameDetails.prototype.receiver = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsReceiverIndex];
-}
+};
 
 
 FrameDetails.prototype.func = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsFunctionIndex];
-}
+};
 
 
 FrameDetails.prototype.isConstructCall = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsConstructCallIndex];
-}
+};
 
 
 FrameDetails.prototype.isAtReturn = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsAtReturnIndex];
-}
+};
 
 
 FrameDetails.prototype.isDebuggerFrame = function() {
   %CheckExecutionState(this.break_id_);
   var f = kFrameDetailsFlagDebuggerFrameMask;
   return (this.details_[kFrameDetailsFlagsIndex] & f) == f;
-}
+};
 
 
 FrameDetails.prototype.isOptimizedFrame = function() {
   %CheckExecutionState(this.break_id_);
   var f = kFrameDetailsFlagOptimizedFrameMask;
   return (this.details_[kFrameDetailsFlagsIndex] & f) == f;
-}
+};
 
 
 FrameDetails.prototype.isInlinedFrame = function() {
   return this.inlinedFrameIndex() > 0;
-}
+};
 
 
 FrameDetails.prototype.inlinedFrameIndex = function() {
   %CheckExecutionState(this.break_id_);
   var f = kFrameDetailsFlagInlinedFrameIndexMask;
-  return (this.details_[kFrameDetailsFlagsIndex] & f) >> 2
-}
+  return (this.details_[kFrameDetailsFlagsIndex] & f) >> 2;
+};
 
 
 FrameDetails.prototype.argumentCount = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsArgumentCountIndex];
-}
+};
 
 
 FrameDetails.prototype.argumentName = function(index) {
   %CheckExecutionState(this.break_id_);
   if (index >= 0 && index < this.argumentCount()) {
     return this.details_[kFrameDetailsFirstDynamicIndex +
                          index * kFrameDetailsNameValueSize +
-                         kFrameDetailsNameIndex]
+                         kFrameDetailsNameIndex];
   }
-}
+};
 
 
 FrameDetails.prototype.argumentValue = function(index) {
   %CheckExecutionState(this.break_id_);
   if (index >= 0 && index < this.argumentCount()) {
     return this.details_[kFrameDetailsFirstDynamicIndex +
                          index * kFrameDetailsNameValueSize +
-                         kFrameDetailsValueIndex]
+                         kFrameDetailsValueIndex];
   }
-}
+};
 
 
 FrameDetails.prototype.localCount = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsLocalCountIndex];
-}
+};
 
 
 FrameDetails.prototype.sourcePosition = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsSourcePositionIndex];
-}
+};
 
 
 FrameDetails.prototype.localName = function(index) {
   %CheckExecutionState(this.break_id_);
   if (index >= 0 && index < this.localCount()) {
     var locals_offset = kFrameDetailsFirstDynamicIndex +
-                        this.argumentCount() * kFrameDetailsNameValueSize
+                        this.argumentCount() * kFrameDetailsNameValueSize;
     return this.details_[locals_offset +
                          index * kFrameDetailsNameValueSize +
-                         kFrameDetailsNameIndex]
+                         kFrameDetailsNameIndex];
   }
-}
+};
 
 
 FrameDetails.prototype.localValue = function(index) {
   %CheckExecutionState(this.break_id_);
   if (index >= 0 && index < this.localCount()) {
     var locals_offset = kFrameDetailsFirstDynamicIndex +
-                        this.argumentCount() * kFrameDetailsNameValueSize
+                        this.argumentCount() * kFrameDetailsNameValueSize;
     return this.details_[locals_offset +
                          index * kFrameDetailsNameValueSize +
-                         kFrameDetailsValueIndex]
+                         kFrameDetailsValueIndex];
   }
-}
+};
 
 
 FrameDetails.prototype.returnValue = function() {
   %CheckExecutionState(this.break_id_);
   var return_value_offset =
       kFrameDetailsFirstDynamicIndex +
       (this.argumentCount() + this.localCount()) * kFrameDetailsNameValueSize;
   if (this.details_[kFrameDetailsAtReturnIndex]) {
     return this.details_[return_value_offset];
   }
-}
+};
 
 
 FrameDetails.prototype.scopeCount = function() {
   return %GetScopeCount(this.break_id_, this.frameId());
-}
+};
 
 
 /**
  * Mirror object for stack frames.
  * @param {number} break_id The break id in the VM for which this frame is
        valid
  * @param {number} index The frame index (top frame is index 0)
  * @constructor
  * @extends Mirror
  */
@@ skipping 142 matching lines @@
 FrameMirror.prototype.scopeCount = function() {
   return this.details_.scopeCount();
 };
 
 
 FrameMirror.prototype.scope = function(index) {
   return new ScopeMirror(this, index);
 };
 
 
-FrameMirror.prototype.evaluate = function(source, disable_break, opt_context_object) {
+FrameMirror.prototype.evaluate = function(source, disable_break,
+                                          opt_context_object) {
   var result = %DebugEvaluate(this.break_id_,
                               this.details_.frameId(),
                               this.details_.inlinedFrameIndex(),
                               source,
                               Boolean(disable_break),
                               opt_context_object);
   return MakeMirror(result);
 };
 
 
 FrameMirror.prototype.invocationText = function() {
   // Format frame invoaction (receiver, function and arguments).
   var result = '';
   var func = this.func();
   var receiver = this.receiver();
   if (this.isConstructCall()) {
     // For constructor frames display new followed by the function name.
     result += 'new ';
     result += func.name() ? func.name() : '[anonymous]';
   } else if (this.isDebuggerFrame()) {
     result += '[debugger]';
   } else {
     // If the receiver has a className which is 'global' don't display it.
-    var display_receiver = !receiver.className || receiver.className() != 'global';
+    var display_receiver =
+      !receiver.className || (receiver.className() != 'global');
     if (display_receiver) {
       result += receiver.toText();
     }
     // Try to find the function as a property in the receiver. Include the
     // prototype chain in the lookup.
     var property = GetUndefinedMirror();
     if (receiver.isObject()) {
       for (var r = receiver;
            !r.isNull() && property.isUndefined();
            r = r.protoObject()) {
@@ skipping 41 matching lines @@
     }
     result += ')';
   }
 
   if (this.isAtReturn()) {
     result += ' returning ';
     result += this.returnValue().toText();
   }
 
   return result;
-}
+};
 
 
 FrameMirror.prototype.sourceAndPositionText = function() {
   // Format source and position.
   var result = '';
   var func = this.func();
   if (func.resolved()) {
     if (func.script()) {
       if (func.script().name()) {
         result += func.script().name();
@@ skipping 11 matching lines @@
         }
       }
     } else {
       result += '[no source]';
     }
   } else {
     result += '[unresolved]';
   }
 
   return result;
-}
+};
 
 
 FrameMirror.prototype.localsText = function() {
   // Format local variables.
   var result = '';
-  var locals_count = this.localCount()
+  var locals_count = this.localCount();
   if (locals_count > 0) {
     for (var i = 0; i < locals_count; ++i) {
       result += '      var ';
       result += this.localName(i);
       result += ' = ';
       result += this.localValue(i).toText();
       if (i < locals_count - 1) result += '\n';
     }
   }
 
   return result;
-}
+};
 
 
 FrameMirror.prototype.toText = function(opt_locals) {
   var result = '';
   result += '#' + (this.index() <= 9 ? '0' : '') + this.index();
   result += ' ';
   result += this.invocationText();
   result += ' ';
   result += this.sourceAndPositionText();
   if (opt_locals) {
     result += '\n';
     result += this.localsText();
   }
   return result;
-}
+};
 
 
 const kScopeDetailsTypeIndex = 0;
 const kScopeDetailsObjectIndex = 1;
 
 function ScopeDetails(frame, index) {
   this.break_id_ = frame.break_id_;
   this.details_ = %GetScopeDetails(frame.break_id_,
                                    frame.details_.frameId(),
                                    frame.details_.inlinedFrameIndex(),
                                    index);
 }
 
 
 ScopeDetails.prototype.type = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kScopeDetailsTypeIndex];
-}
+};
 
 
 ScopeDetails.prototype.object = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kScopeDetailsObjectIndex];
-}
+};
 
 
 /**
  * Mirror object for scope.
  * @param {FrameMirror} frame The frame this scope is a part of
  * @param {number} index The scope index in the frame
  * @constructor
  * @extends Mirror
  */
 function ScopeMirror(frame, index) {
@@ skipping 91 matching lines @@
 
 
 ScriptMirror.prototype.lineCount = function() {
   return this.script_.lineCount();
 };
 
 
 ScriptMirror.prototype.locationFromPosition = function(
     position, include_resource_offset) {
   return this.script_.locationFromPosition(position, include_resource_offset);
-}
+};
 
 
 ScriptMirror.prototype.sourceSlice = function (opt_from_line, opt_to_line) {
   return this.script_.sourceSlice(opt_from_line, opt_to_line);
-}
+};
 
 
 ScriptMirror.prototype.context = function() {
   return this.context_;
 };
 
 
 ScriptMirror.prototype.evalFromScript = function() {
   return MakeMirror(this.script_.eval_from_script);
 };
@@ skipping 19 matching lines @@
   result += ' (lines: ';
   if (this.lineOffset() > 0) {
     result += this.lineOffset();
     result += '-';
     result += this.lineOffset() + this.lineCount() - 1;
   } else {
     result += this.lineCount();
   }
   result += ')';
   return result;
-}
+};
 
 
 /**
  * Mirror object for context.
  * @param {Object} data The context data
  * @constructor
  * @extends Mirror
  */
 function ContextMirror(data) {
   %_CallFunction(this, CONTEXT_TYPE, Mirror);
@@ skipping 37 matching lines @@
 
 /**
  * Returns a serialization of an object reference. The referenced object are
  * added to the serialization state.
  *
  * @param {Mirror} mirror The mirror to serialize
  * @returns {String} JSON serialization
  */
 JSONProtocolSerializer.prototype.serializeReference = function(mirror) {
   return this.serialize_(mirror, true, true);
-}
+};
 
 
 /**
  * Returns a serialization of an object value. The referenced objects are
  * added to the serialization state.
  *
  * @param {Mirror} mirror The mirror to serialize
  * @returns {String} JSON serialization
  */
 JSONProtocolSerializer.prototype.serializeValue = function(mirror) {
   var json = this.serialize_(mirror, false, true);
   return json;
-}
+};
 
 
 /**
  * Returns a serialization of all the objects referenced.
  *
  * @param {Mirror} mirror The mirror to serialize.
  * @returns {Array.<Object>} Array of the referenced objects converted to
  *     protcol objects.
  */
 JSONProtocolSerializer.prototype.serializeReferencedObjects = function() {
   // Collect the protocol representation of the referenced objects in an array.
   var content = [];
 
   // Get the number of referenced objects.
   var count = this.mirrors_.length;
 
   for (var i = 0; i < count; i++) {
     content.push(this.serialize_(this.mirrors_[i], false, false));
   }
 
   return content;
-}
+};
 
 
 JSONProtocolSerializer.prototype.includeSource_ = function() {
   return this.options_ && this.options_.includeSource;
-}
+};
 
 
 JSONProtocolSerializer.prototype.inlineRefs_ = function() {
   return this.options_ && this.options_.inlineRefs;
-}
+};
 
 
 JSONProtocolSerializer.prototype.maxStringLength_ = function() {
   if (IS_UNDEFINED(this.options_) ||
       IS_UNDEFINED(this.options_.maxStringLength)) {
     return kMaxProtocolStringLength;
   }
   return this.options_.maxStringLength;
-}
+};
 
 
 JSONProtocolSerializer.prototype.add_ = function(mirror) {
   // If this mirror is already in the list just return.
   for (var i = 0; i < this.mirrors_.length; i++) {
     if (this.mirrors_[i] === mirror) {
       return;
     }
   }
 
   // Add the mirror to the list of mirrors to be serialized.
   this.mirrors_.push(mirror);
-}
+};
 
 
 /**
  * Formats mirror object to protocol reference object with some data that can
  * be used to display the value in debugger.
  * @param {Mirror} mirror Mirror to serialize.
  * @return {Object} Protocol reference object.
  */
 JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_ =
     function(mirror) {
@@ skipping 86 matching lines @@
 
     case OBJECT_TYPE:
     case FUNCTION_TYPE:
     case ERROR_TYPE:
     case REGEXP_TYPE:
       // Add object representation.
       this.serializeObject_(mirror, content, details);
       break;
 
     case PROPERTY_TYPE:
-      throw new Error('PropertyMirror cannot be serialized independeltly')
+      throw new Error('PropertyMirror cannot be serialized independeltly');
       break;
 
     case FRAME_TYPE:
       // Add object representation.
       this.serializeFrame_(mirror, content);
       break;
 
     case SCOPE_TYPE:
       // Add object representation.
       this.serializeScope_(mirror, content);
@@ skipping 19 matching lines @@
       }
       content.sourceLength = mirror.source().length;
       content.scriptType = mirror.scriptType();
       content.compilationType = mirror.compilationType();
       // For compilation type eval emit information on the script from which
       // eval was called if a script is present.
       if (mirror.compilationType() == 1 &&
           mirror.evalFromScript()) {
         content.evalFromScript =
             this.serializeReference(mirror.evalFromScript());
-        var evalFromLocation = mirror.evalFromLocation()
+        var evalFromLocation = mirror.evalFromLocation();
         if (evalFromLocation) {
           content.evalFromLocation = { line: evalFromLocation.line,
                                        column: evalFromLocation.column };
         }
         if (mirror.evalFromFunctionName()) {
           content.evalFromFunctionName = mirror.evalFromFunctionName();
         }
       }
       if (mirror.context()) {
         content.context = this.serializeReference(mirror.context());
       }
       break;
 
     case CONTEXT_TYPE:
       content.data = mirror.data();
       break;
   }
 
   // Always add the text representation.
   content.text = mirror.toText();
 
   // Create and return the JSON string.
   return content;
-}
+};
 
 
 /**
  * Serialize object information to the following JSON format.
  *
  *   {"className":"<class name>",
  *    "constructorFunction":{"ref":<number>},
  *    "protoObject":{"ref":<number>},
  *    "prototypeObject":{"ref":<number>},
  *    "namedInterceptor":<boolean>,
@@ skipping 54 matching lines @@
     }
   }
   for (var i = 0; i < propertyIndexes.length; i++) {
     var propertyMirror = mirror.property(propertyIndexes[i]);
     p[propertyNames.length + i] = this.serializeProperty_(propertyMirror);
     if (details) {
       this.add_(propertyMirror.value());
     }
   }
   content.properties = p;
-}
+};
 
 
 /**
  * Serialize location information to the following JSON format:
  *
  *   "position":"<position>",
  *   "line":"<line>",
  *   "column":"<column>",
  *
  * @param {SourceLocation} location The location to serialize, may be undefined.
@@ skipping 43 matching lines @@
   } else {
     if (propertyMirror.attributes() != PropertyAttribute.None) {
       result.attributes = propertyMirror.attributes();
     }
     if (propertyMirror.propertyType() != PropertyType.Normal) {
       result.propertyType = propertyMirror.propertyType();
     }
     result.ref = propertyValue.handle();
   }
   return result;
-}
+};
 
 
 JSONProtocolSerializer.prototype.serializeFrame_ = function(mirror, content) {
   content.index = mirror.index();
   content.receiver = this.serializeReference(mirror.receiver());
   var func = mirror.func();
   content.func = this.serializeReference(func);
   if (func.script()) {
     content.script = this.serializeReference(func.script());
   }
   content.constructCall = mirror.isConstructCall();
   content.atReturn = mirror.isAtReturn();
   if (mirror.isAtReturn()) {
     content.returnValue = this.serializeReference(mirror.returnValue());
   }
   content.debuggerFrame = mirror.isDebuggerFrame();
   var x = new Array(mirror.argumentCount());
   for (var i = 0; i < mirror.argumentCount(); i++) {
     var arg = {};
-    var argument_name = mirror.argumentName(i)
+    var argument_name = mirror.argumentName(i);
     if (argument_name) {
       arg.name = argument_name;
     }
     arg.value = this.serializeReference(mirror.argumentValue(i));
     x[i] = arg;
   }
   content.arguments = x;
   var x = new Array(mirror.localCount());
   for (var i = 0; i < mirror.localCount(); i++) {
     var local = {};
     local.name = mirror.localName(i);
     local.value = this.serializeReference(mirror.localValue(i));
     x[i] = local;
   }
   content.locals = x;
   serializeLocationFields(mirror.sourceLocation(), content);
   var source_line_text = mirror.sourceLineText();
   if (!IS_UNDEFINED(source_line_text)) {
     content.sourceLineText = source_line_text;
   }
 
   content.scopes = [];
   for (var i = 0; i < mirror.scopeCount(); i++) {
     var scope = mirror.scope(i);
     content.scopes.push({
       type: scope.scopeType(),
       index: i
     });
   }
-}
+};
 
 
 JSONProtocolSerializer.prototype.serializeScope_ = function(mirror, content) {
   content.index = mirror.scopeIndex();
   content.frameIndex = mirror.frameIndex();
   content.type = mirror.scopeType();
   content.object = this.inlineRefs_() ?
                    this.serializeValue(mirror.scopeObject()) :
                    this.serializeReference(mirror.scopeObject());
-}
+};
 
 
 /**
  * Convert a number to a protocol value. For all finite numbers the number
  * itself is returned. For non finite numbers NaN, Infinite and
  * -Infinite the string representation "NaN", "Infinite" or "-Infinite"
  * (not including the quotes) is returned.
  *
  * @param {number} value The number value to convert to a protocol value.
  * @returns {number|string} Protocol value.
  */
 function NumberToJSON_(value) {
   if (isNaN(value)) {
     return 'NaN';
   }
   if (!NUMBER_IS_FINITE(value)) {
     if (value > 0) {
       return 'Infinity';
     } else {
       return '-Infinity';
     }
   }
   return value;
 }