therubyracer 0.6.3 → 0.7.0.pre

data/ext/v8/upstream/2.1.10/src/cpu-profiler.h

@@ -0,0 +1,277 @@
+// Copyright 2010 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.
+
+#ifndef V8_CPU_PROFILER_H_
+#define V8_CPU_PROFILER_H_
+
+#ifdef ENABLE_LOGGING_AND_PROFILING
+
+#include "circular-queue.h"
+
+namespace v8 {
+namespace internal {
+
+// Forward declarations.
+class CodeEntry;
+class CodeMap;
+class CpuProfile;
+class CpuProfilesCollection;
+class ProfileGenerator;
+
+
+#define CODE_EVENTS_TYPE_LIST(V)                \
+  V(CODE_CREATION, CodeCreateEventRecord)       \
+  V(CODE_MOVE,     CodeMoveEventRecord)         \
+  V(CODE_DELETE,   CodeDeleteEventRecord)       \
+  V(CODE_ALIAS,    CodeAliasEventRecord)
+
+
+class CodeEventRecord {
+ public:
+#define DECLARE_TYPE(type, ignore) type,
+  enum Type {
+    NONE = 0,
+    CODE_EVENTS_TYPE_LIST(DECLARE_TYPE)
+    NUMBER_OF_TYPES
+  };
+#undef DECLARE_TYPE
+
+  Type type;
+  unsigned order;
+};
+
+
+class CodeCreateEventRecord : public CodeEventRecord {
+ public:
+  Address start;
+  CodeEntry* entry;
+  unsigned size;
+
+  INLINE(void UpdateCodeMap(CodeMap* code_map));
+};
+
+
+class CodeMoveEventRecord : public CodeEventRecord {
+ public:
+  Address from;
+  Address to;
+
+  INLINE(void UpdateCodeMap(CodeMap* code_map));
+};
+
+
+class CodeDeleteEventRecord : public CodeEventRecord {
+ public:
+  Address start;
+
+  INLINE(void UpdateCodeMap(CodeMap* code_map));
+};
+
+
+class CodeAliasEventRecord : public CodeEventRecord {
+ public:
+  Address alias;
+  Address start;
+
+  INLINE(void UpdateCodeMap(CodeMap* code_map));
+};
+
+
+class TickSampleEventRecord BASE_EMBEDDED {
+ public:
+  // The first machine word of a TickSampleEventRecord must not ever
+  // become equal to SamplingCircularQueue::kClear.  As both order and
+  // TickSample's first field are not reliable in this sense (order
+  // can overflow, TickSample can have all fields reset), we are
+  // forced to use an artificial filler field.
+  int filler;
+  unsigned order;
+  TickSample sample;
+
+  static TickSampleEventRecord* cast(void* value) {
+    return reinterpret_cast<TickSampleEventRecord*>(value);
+  }
+
+  INLINE(static TickSampleEventRecord* init(void* value));
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(TickSampleEventRecord);
+};
+
+
+// This class implements both the profile events processor thread and
+// methods called by event producers: VM and stack sampler threads.
+class ProfilerEventsProcessor : public Thread {
+ public:
+  explicit ProfilerEventsProcessor(ProfileGenerator* generator);
+  virtual ~ProfilerEventsProcessor() { }
+
+  // Thread control.
+  virtual void Run();
+  inline void Stop() { running_ = false; }
+  INLINE(bool running()) { return running_; }
+
+  // Events adding methods. Called by VM threads.
+  void CallbackCreateEvent(Logger::LogEventsAndTags tag,
+                           const char* prefix, String* name,
+                           Address start);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       String* name,
+                       String* resource_name, int line_number,
+                       Address start, unsigned size);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       const char* name,
+                       Address start, unsigned size);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       int args_count,
+                       Address start, unsigned size);
+  void CodeMoveEvent(Address from, Address to);
+  void CodeDeleteEvent(Address from);
+  void FunctionCreateEvent(Address alias, Address start);
+  void FunctionMoveEvent(Address from, Address to);
+  void FunctionDeleteEvent(Address from);
+  void RegExpCodeCreateEvent(Logger::LogEventsAndTags tag,
+                             const char* prefix, String* name,
+                             Address start, unsigned size);
+
+  // Tick sample events are filled directly in the buffer of the circular
+  // queue (because the structure is of fixed width, but usually not all
+  // stack frame entries are filled.) This method returns a pointer to the
+  // next record of the buffer.
+  INLINE(TickSample* TickSampleEvent());
+
+ private:
+  union CodeEventsContainer {
+    CodeEventRecord generic;
+#define DECLARE_CLASS(ignore, type) type type##_;
+    CODE_EVENTS_TYPE_LIST(DECLARE_CLASS)
+#undef DECLARE_TYPE
+  };
+
+  // Called from events processing thread (Run() method.)
+  bool ProcessCodeEvent(unsigned* dequeue_order);
+  bool ProcessTicks(unsigned dequeue_order);
+
+  INLINE(static bool FilterOutCodeCreateEvent(Logger::LogEventsAndTags tag));
+
+  ProfileGenerator* generator_;
+  bool running_;
+  CircularQueue<CodeEventsContainer> events_buffer_;
+  SamplingCircularQueue ticks_buffer_;
+  unsigned enqueue_order_;
+};
+
+} }  // namespace v8::internal
+
+
+#define PROFILE(Call)                                  \
+  LOG(Call);                                           \
+  do {                                                 \
+    if (v8::internal::CpuProfiler::is_profiling()) {   \
+      v8::internal::CpuProfiler::Call;                 \
+    }                                                  \
+  } while (false)
+#else
+#define PROFILE(Call) LOG(Call)
+#endif  // ENABLE_LOGGING_AND_PROFILING
+
+
+namespace v8 {
+namespace internal {
+
+class CpuProfiler {
+ public:
+  static void Setup();
+  static void TearDown();
+
+#ifdef ENABLE_LOGGING_AND_PROFILING
+  static void StartProfiling(const char* title);
+  static void StartProfiling(String* title);
+  static CpuProfile* StopProfiling(const char* title);
+  static CpuProfile* StopProfiling(String* title);
+  static int GetProfilesCount();
+  static CpuProfile* GetProfile(int index);
+  static CpuProfile* FindProfile(unsigned uid);
+
+  // Invoked from stack sampler (thread or signal handler.)
+  static TickSample* TickSampleEvent();
+
+  // Must be called via PROFILE macro, otherwise will crash when
+  // profiling is not enabled.
+  static void CallbackEvent(String* name, Address entry_point);
+  static void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                              Code* code, const char* comment);
+  static void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                              Code* code, String* name);
+  static void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                              Code* code, String* name,
+                              String* source, int line);
+  static void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                              Code* code, int args_count);
+  static void CodeMoveEvent(Address from, Address to);
+  static void CodeDeleteEvent(Address from);
+  static void FunctionCreateEvent(JSFunction* function);
+  static void FunctionMoveEvent(Address from, Address to);
+  static void FunctionDeleteEvent(Address from);
+  static void GetterCallbackEvent(String* name, Address entry_point);
+  static void RegExpCodeCreateEvent(Code* code, String* source);
+  static void SetterCallbackEvent(String* name, Address entry_point);
+
+  static INLINE(bool is_profiling()) {
+    return singleton_ != NULL && singleton_->processor_ != NULL;
+  }
+
+ private:
+  CpuProfiler();
+  ~CpuProfiler();
+  void StartCollectingProfile(const char* title);
+  void StartCollectingProfile(String* title);
+  void StartProcessorIfNotStarted();
+  CpuProfile* StopCollectingProfile(const char* title);
+  CpuProfile* StopCollectingProfile(String* title);
+  void StopProcessorIfLastProfile();
+
+  CpuProfilesCollection* profiles_;
+  unsigned next_profile_uid_;
+  ProfileGenerator* generator_;
+  ProfilerEventsProcessor* processor_;
+  int saved_logging_nesting_;
+
+  static CpuProfiler* singleton_;
+
+#else
+  static INLINE(bool is_profiling()) { return false; }
+#endif  // ENABLE_LOGGING_AND_PROFILING
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CpuProfiler);
+};
+
+} }  // namespace v8::internal
+
+
+#endif  // V8_CPU_PROFILER_H_

data/ext/v8/upstream/{2.0.6 → 2.1.10}/src/d8-debug.cc

@@ -34,6 +34,11 @@
 
 namespace v8 {
 
+void PrintPrompt() {
+  printf("dbg> ");
+  fflush(stdout);
+}
+
 
 void HandleDebugEvent(DebugEvent event,
                       Handle<Object> exec_state,
@@ -86,7 +91,7 @@ void HandleDebugEvent(DebugEvent event,
   bool running = false;
   while (!running) {
     char command[kBufferSize];
-    printf("dbg> ");
+    PrintPrompt();
     char* str = fgets(command, kBufferSize, stdin);
     if (str == NULL) break;
 
@@ -178,6 +183,7 @@ void RemoteDebugger::Run() {
   // Start the keyboard thread.
   KeyboardThread keyboard(this);
   keyboard.Start();
+  PrintPrompt();
 
   // Process events received from debugged VM and from the keyboard.
   bool terminate = false;
@@ -264,7 +270,8 @@ void RemoteDebugger::HandleMessageReceived(char* message) {
   Handle<Object> details =
       Shell::DebugMessageDetails(Handle<String>::Cast(String::New(message)));
   if (try_catch.HasCaught()) {
-      Shell::ReportException(&try_catch);
+    Shell::ReportException(&try_catch);
+    PrintPrompt();
     return;
   }
   String::Utf8Value str(details->Get(String::New("text")));
@@ -277,7 +284,7 @@ void RemoteDebugger::HandleMessageReceived(char* message) {
   } else {
     printf("???\n");
   }
-  printf("dbg> ");
+  PrintPrompt();
 }
 
 
@@ -289,13 +296,17 @@ void RemoteDebugger::HandleKeyboardCommand(char* command) {
   Handle<Value> request =
       Shell::DebugCommandToJSONRequest(String::New(command));
   if (try_catch.HasCaught()) {
-    Shell::ReportException(&try_catch);
+    v8::String::Utf8Value exception(try_catch.Exception());
+    const char* exception_string = Shell::ToCString(exception);
+    printf("%s\n", exception_string);
+    PrintPrompt();
     return;
   }
 
   // If undefined is returned the command was handled internally and there is
   // no JSON to send.
   if (request->IsUndefined()) {
+    PrintPrompt();
     return;
   }
 

data/ext/v8/upstream/{2.0.6 → 2.1.10}/src/d8-posix.cc

@@ -663,10 +663,28 @@ Handle<Value> Shell::SetEnvironment(const Arguments& args) {
 }
 
 
+Handle<Value> Shell::UnsetEnvironment(const Arguments& args) {
+  if (args.Length() != 1) {
+    const char* message = "unsetenv() takes one argument";
+    return ThrowException(String::New(message));
+  }
+  String::Utf8Value var(args[0]);
+  if (*var == NULL) {
+    const char* message =
+        "os.setenv(): String conversion of variable name failed.";
+    return ThrowException(String::New(message));
+  }
+  unsetenv(*var);
+  return v8::Undefined();
+}
+
+
 void Shell::AddOSMethods(Handle<ObjectTemplate> os_templ) {
   os_templ->Set(String::New("system"), FunctionTemplate::New(System));
   os_templ->Set(String::New("chdir"), FunctionTemplate::New(ChangeDirectory));
   os_templ->Set(String::New("setenv"), FunctionTemplate::New(SetEnvironment));
+  os_templ->Set(String::New("unsetenv"),
+                FunctionTemplate::New(UnsetEnvironment));
   os_templ->Set(String::New("umask"), FunctionTemplate::New(SetUMask));
   os_templ->Set(String::New("mkdirp"), FunctionTemplate::New(MakeDirectory));
   os_templ->Set(String::New("rmdir"), FunctionTemplate::New(RemoveDirectory));

data/ext/v8/upstream/{2.0.6 → 2.1.10}/src/d8-readline.cc

@@ -27,8 +27,8 @@
 
 
 #include <cstdio>  // NOLINT
-#include <readline/readline.h>
-#include <readline/history.h>
+#include <readline/readline.h> // NOLINT
+#include <readline/history.h> // NOLINT
 
 
 #include "d8.h"

data/ext/v8/upstream/{2.0.6 → 2.1.10}/src/d8.cc

@@ -102,7 +102,7 @@ bool CounterMap::Match(void* key1, void* key2) {
 
 
 // Converts a V8 value to a C string.
-const char* ToCString(const v8::String::Utf8Value& value) {
+const char* Shell::ToCString(const v8::String::Utf8Value& value) {
   return *value ? *value : "<string conversion failed>";
 }
 
@@ -447,9 +447,10 @@ void Shell::Initialize() {
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Install the debugger object in the utility scope
   i::Debug::Load();
-  i::JSObject* debug = i::Debug::debug_context()->global();
+  i::Handle<i::JSObject> debug
+      = i::Handle<i::JSObject>(i::Debug::debug_context()->global());
   utility_context_->Global()->Set(String::New("$debug"),
-                                  Utils::ToLocal(&debug));
+                                  Utils::ToLocal(debug));
 #endif
 
   // Run the d8 shell utility script in the utility context
@@ -467,9 +468,12 @@ void Shell::Initialize() {
 
   // Mark the d8 shell script as native to avoid it showing up as normal source
   // in the debugger.
-  i::Handle<i::JSFunction> script_fun = Utils::OpenHandle(*script);
-  i::Handle<i::Script> script_object =
-      i::Handle<i::Script>(i::Script::cast(script_fun->shared()->script()));
+  i::Handle<i::Object> compiled_script = Utils::OpenHandle(*script);
+  i::Handle<i::Script> script_object = compiled_script->IsJSFunction()
+      ? i::Handle<i::Script>(i::Script::cast(
+          i::JSFunction::cast(*compiled_script)->shared()->script()))
+      : i::Handle<i::Script>(i::Script::cast(
+          i::SharedFunctionInfo::cast(*compiled_script)->script()));
   script_object->set_type(i::Smi::FromInt(i::Script::TYPE_NATIVE));
 
   // Create the evaluation context

data/ext/v8/upstream/{2.0.6 → 2.1.10}/src/d8.h

@@ -117,6 +117,7 @@ class Shell: public i::AllStatic {
                             Handle<Value> name,
                             bool print_result,
                             bool report_exceptions);
+  static const char* ToCString(const v8::String::Utf8Value& value);
   static void ReportException(TryCatch* try_catch);
   static void Initialize();
   static void OnExit();
@@ -175,6 +176,7 @@ class Shell: public i::AllStatic {
   static Handle<Value> System(const Arguments& args);
   static Handle<Value> ChangeDirectory(const Arguments& args);
   static Handle<Value> SetEnvironment(const Arguments& args);
+  static Handle<Value> UnsetEnvironment(const Arguments& args);
   static Handle<Value> SetUMask(const Arguments& args);
   static Handle<Value> MakeDirectory(const Arguments& args);
   static Handle<Value> RemoveDirectory(const Arguments& args);

data/ext/v8/upstream/{2.0.6 → 2.1.10}/src/d8.js

@@ -164,7 +164,7 @@ function DebugEventDetails(response) {
       Debug.State.currentFrame = 0;
       details.text = result;
       break;
-      
+
     case 'exception':
       if (body.uncaught) {
         result += 'Uncaught: ';
@@ -212,7 +212,7 @@ function DebugEventDetails(response) {
 
 function SourceInfo(body) {
   var result = '';
-  
+
   if (body.script) {
     if (body.script.name) {
       result += body.script.name;
@@ -224,7 +224,7 @@ function SourceInfo(body) {
   result += body.sourceLine + 1;
   result += ' column ';
   result += body.sourceColumn + 1;
-  
+
   return result;
 }
 
@@ -297,20 +297,20 @@ function DebugRequest(cmd_line) {
     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);
@@ -331,16 +331,16 @@ function DebugRequest(cmd_line) {
     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;
@@ -365,7 +365,7 @@ function DebugRequest(cmd_line) {
     default:
       throw new Error('Unknown command "' + cmd + '"');
   }
-  
+
   last_cmd = cmd;
 }
 
@@ -490,22 +490,22 @@ DebugRequest.prototype.stepCommandToJSONRequest_ = function(args) {
         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] + '".');
       }
@@ -523,7 +523,7 @@ DebugRequest.prototype.stepCommandToJSONRequest_ = function(args) {
 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;
@@ -626,7 +626,7 @@ DebugRequest.prototype.referencesCommandToJSONRequest_ = function(args) {
   if (args.length == 0) {
     throw new Error('Missing object id.');
   }
-  
+
   return this.makeReferencesJSONRequest_(args, 'referencedBy');
 };
 
@@ -637,7 +637,7 @@ DebugRequest.prototype.instancesCommandToJSONRequest_ = function(args) {
   if (args.length == 0) {
     throw new Error('Missing object id.');
   }
-  
+
   // Build a references request.
   return this.makeReferencesJSONRequest_(args, 'constructedBy');
 };
@@ -691,18 +691,18 @@ DebugRequest.prototype.scriptsCommandToJSONRequest_ = function(args) {
       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] + '".');
     }
@@ -715,8 +715,6 @@ DebugRequest.prototype.scriptsCommandToJSONRequest_ = function(args) {
 // Create a JSON request for the break command.
 DebugRequest.prototype.breakCommandToJSONRequest_ = function(args) {
   // Build a evaluate request from the text command.
-  var request = this.createRequest('setbreakpoint');
-
   // Process arguments if any.
   if (args && args.length > 0) {
     var target = args;
@@ -726,6 +724,8 @@ DebugRequest.prototype.breakCommandToJSONRequest_ = function(args) {
     var condition;
     var pos;
 
+    var request = this.createRequest('setbreakpoint');
+
     // Check for breakpoint condition.
     pos = args.indexOf(' ');
     if (pos > 0) {
@@ -740,7 +740,7 @@ DebugRequest.prototype.breakCommandToJSONRequest_ = function(args) {
       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) {
@@ -755,7 +755,7 @@ DebugRequest.prototype.breakCommandToJSONRequest_ = function(args) {
     } else {
       type = 'function';
     }
-  
+
     request.arguments = {};
     request.arguments.type = type;
     request.arguments.target = target;
@@ -763,7 +763,7 @@ DebugRequest.prototype.breakCommandToJSONRequest_ = function(args) {
     request.arguments.column = column;
     request.arguments.condition = condition;
   } else {
-    throw new Error('Invalid break arguments.');
+    var request = this.createRequest('suspend');
   }
 
   return request.toJSONProtocol();
@@ -817,6 +817,7 @@ DebugRequest.prototype.helpCommand_ = function(args) {
     print('warning: arguments to \'help\' are ignored');
   }
 
+  print('break');
   print('break location [condition]');
   print('  break on named function: location is a function name');
   print('  break on function: location is #<id>#');
@@ -931,18 +932,22 @@ function DebugResponseDetails(response) {
     var body = response.body();
     var result = '';
     switch (response.command()) {
+      case 'suspend':
+        details.text = 'stopped';
+        break;
+        
       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)';
@@ -956,14 +961,14 @@ function DebugResponseDetails(response) {
         }
         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)';
@@ -987,7 +992,7 @@ function DebugResponseDetails(response) {
         result += formatObject_(scope_object_value, true);
         details.text = result;
         break;
-      
+
       case 'evaluate':
       case 'lookup':
         if (last_cmd == 'p' || last_cmd == 'print') {
@@ -1031,7 +1036,7 @@ function DebugResponseDetails(response) {
         }
         details.text = result;
         break;
-        
+
       case 'source':
         // Get the source from the response.
         var source = body.source;
@@ -1066,7 +1071,7 @@ function DebugResponseDetails(response) {
         }
         details.text = result;
         break;
-        
+
       case 'scripts':
         var result = '';
         for (i = 0; i < body.length; i++) {
@@ -1128,7 +1133,7 @@ function DebugResponseDetails(response) {
       case 'continue':
         details.text = "(running)";
         break;
-        
+
       default:
         details.text =
             'Response for unknown command \'' + response.command + '\'' +
@@ -1137,7 +1142,7 @@ function DebugResponseDetails(response) {
   } catch (e) {
     details.text = 'Error: "' + e + '" formatting response';
   }
-  
+
   return details;
 };
 
@@ -1254,7 +1259,7 @@ ProtocolValue.prototype.type = function() {
 
 
 /**
- * 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) {
@@ -1435,12 +1440,12 @@ function ArrayToJSONArray_(content) {
 
 
 function BooleanToJSON_(value) {
-  return String(value); 
+  return String(value);
 }
 
 
 function NumberToJSON_(value) {
-  return String(value); 
+  return String(value);
 }