CSE2410 Fall 2014 Bounce

// Copyright 2012 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.

// Defined when linking against shared lib on Windows.

#if defined(USING_V8_SHARED) && !defined(V8_SHARED)

#define V8_SHARED

#endif

#ifdef COMPRESS_STARTUP_DATA_BZ2

#include <bzlib.h>

#endif

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#ifdef V8_SHARED

#include <assert.h>

#endif  // V8_SHARED

#ifndef V8_SHARED

#include <algorithm>

#endif  // !V8_SHARED

#ifdef V8_SHARED

#include "../include/v8-defaults.h"

#include "../include/v8-testing.h"

#endif  // V8_SHARED

#ifdef ENABLE_VTUNE_JIT_INTERFACE

#include "third_party/vtune/v8-vtune.h"

#endif

#include "d8.h"

#ifndef V8_SHARED

#include "api.h"

#include "checks.h"

#include "d8-debug.h"

#include "debug.h"

#include "natives.h"

#include "platform.h"

#include "v8.h"

#include "v8-defaults.h"

#endif  // V8_SHARED

#if !defined(_WIN32) && !defined(_WIN64)

#include <unistd.h>  // NOLINT

#endif

#ifndef ASSERT

#define ASSERT(condition) assert(condition)

#endif

namespace v8 {

static Handle<Value> Throw(const char* message) {

  return ThrowException(String::New(message));

}

class PerIsolateData {

 public:

  explicit PerIsolateData(Isolate* isolate) : isolate_(isolate), realms_(NULL) {

    HandleScope scope(isolate);

    isolate->SetData(this);

  }

  ~PerIsolateData() {

    isolate_->SetData(NULL);  // Not really needed, just to be sure...

  }

  inline static PerIsolateData* Get(Isolate* isolate) {

    return reinterpret_cast<PerIsolateData*>(isolate->GetData());

  }

  class RealmScope {

   public:

    explicit RealmScope(PerIsolateData* data);

    ~RealmScope();

   private:

    PerIsolateData* data_;

  };

 private:

  friend class Shell;

  friend class RealmScope;

  Isolate* isolate_;

  int realm_count_;

  int realm_current_;

  int realm_switch_;

  Persistent<Context>* realms_;

  Persistent<Value> realm_shared_;

  int RealmFind(Handle<Context> context);

};

LineEditor *LineEditor::current_ = NULL;

LineEditor::LineEditor(Type type, const char* name)

    : type_(type), name_(name) {

  if (current_ == NULL || current_->type_ < type) current_ = this;

}

class DumbLineEditor: public LineEditor {

 public:

  explicit DumbLineEditor(Isolate* isolate)

      : LineEditor(LineEditor::DUMB, "dumb"), isolate_(isolate) { }

  virtual Handle<String> Prompt(const char* prompt);

 private:

  Isolate* isolate_;

};

Handle<String> DumbLineEditor::Prompt(const char* prompt) {

  printf("%s", prompt);

#if defined(__native_client__)

  // Native Client libc is used to being embedded in Chrome and

  // has trouble recognizing when to flush.

  fflush(stdout);

#endif

  return Shell::ReadFromStdin(isolate_);

}

#ifndef V8_SHARED

CounterMap* Shell::counter_map_;

i::OS::MemoryMappedFile* Shell::counters_file_ = NULL;

CounterCollection Shell::local_counters_;

CounterCollection* Shell::counters_ = &local_counters_;

i::Mutex Shell::context_mutex_;

const i::TimeTicks Shell::kInitialTicks = i::TimeTicks::HighResolutionNow();

Persistent<Context> Shell::utility_context_;

#endif  // V8_SHARED

Persistent<Context> Shell::evaluation_context_;

ShellOptions Shell::options;

const char* Shell::kPrompt = "d8> ";

const int MB = 1024 * 1024;

#ifndef V8_SHARED

bool CounterMap::Match(void* key1, void* key2) {

  const char* name1 = reinterpret_cast<const char*>(key1);

  const char* name2 = reinterpret_cast<const char*>(key2);

  return strcmp(name1, name2) == 0;

}

#endif  // V8_SHARED

// Converts a V8 value to a C string.

const char* Shell::ToCString(const v8::String::Utf8Value& value) {

  return *value ? *value : "<string conversion failed>";

}

// Executes a string within the current v8 context.

bool Shell::ExecuteString(Isolate* isolate,

                          Handle<String> source,

                          Handle<Value> name,

                          bool print_result,

                          bool report_exceptions) {

#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)

  bool FLAG_debugger = i::FLAG_debugger;

#else

  bool FLAG_debugger = false;

#endif  // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT

  HandleScope handle_scope(isolate);

  TryCatch try_catch;

  options.script_executed = true;

  if (FLAG_debugger) {

    // When debugging make exceptions appear to be uncaught.

    try_catch.SetVerbose(true);

  }

  Handle<Script> script = Script::New(source, name);

  if (script.IsEmpty()) {

    // Print errors that happened during compilation.

    if (report_exceptions && !FLAG_debugger)

      ReportException(isolate, &try_catch);

    return false;

  } else {

    PerIsolateData* data = PerIsolateData::Get(isolate);

    Local<Context> realm =

        Local<Context>::New(isolate, data->realms_[data->realm_current_]);

    realm->Enter();

    Handle<Value> result = script->Run();

    realm->Exit();

    data->realm_current_ = data->realm_switch_;

    if (result.IsEmpty()) {

      ASSERT(try_catch.HasCaught());

      // Print errors that happened during execution.

      if (report_exceptions && !FLAG_debugger)

        ReportException(isolate, &try_catch);

      return false;

    } else {

      ASSERT(!try_catch.HasCaught());

      if (print_result) {

#if !defined(V8_SHARED)

        if (options.test_shell) {

#endif

          if (!result->IsUndefined()) {

            // If all went well and the result wasn't undefined then print

            // the returned value.

            v8::String::Utf8Value str(result);

            fwrite(*str, sizeof(**str), str.length(), stdout);

            printf("\n");

          }

#if !defined(V8_SHARED)

        } else {

          v8::TryCatch try_catch;

          v8::Local<v8::Context> context =

              v8::Local<v8::Context>::New(isolate, utility_context_);

          v8::Context::Scope context_scope(context);

          Handle<Object> global = context->Global();

          Handle<Value> fun = global->Get(String::New("Stringify"));

          Handle<Value> argv[1] = { result };

          Handle<Value> s = Handle<Function>::Cast(fun)->Call(global, 1, argv);

          if (try_catch.HasCaught()) return true;

          v8::String::Utf8Value str(s);

          fwrite(*str, sizeof(**str), str.length(), stdout);

          printf("\n");

        }

#endif

      }

      return true;

    }

  }

}

PerIsolateData::RealmScope::RealmScope(PerIsolateData* data) : data_(data) {

  data_->realm_count_ = 1;

  data_->realm_current_ = 0;

  data_->realm_switch_ = 0;

  data_->realms_ = new Persistent<Context>[1];

  data_->realms_[0].Reset(data_->isolate_,

                          data_->isolate_->GetEnteredContext());

  data_->realm_shared_.Clear();

}

PerIsolateData::RealmScope::~RealmScope() {

  // Drop realms to avoid keeping them alive.

  for (int i = 0; i < data_->realm_count_; ++i)

    data_->realms_[i].Dispose();

  delete[] data_->realms_;

  if (!data_->realm_shared_.IsEmpty())

    data_->realm_shared_.Dispose();

}

int PerIsolateData::RealmFind(Handle<Context> context) {

  for (int i = 0; i < realm_count_; ++i) {

    if (realms_[i] == context) return i;

  }

  return -1;

}

#ifndef V8_SHARED

// performance.now() returns a time stamp as double, measured in milliseconds.

void Shell::PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args) {

  i::TimeDelta delta = i::TimeTicks::HighResolutionNow() - kInitialTicks;

  args.GetReturnValue().Set(delta.InMillisecondsF());

}

#endif  // V8_SHARED

// Realm.current() returns the index of the currently active realm.

void Shell::RealmCurrent(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Isolate* isolate = args.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  int index = data->RealmFind(isolate->GetEnteredContext());

  if (index == -1) return;

  args.GetReturnValue().Set(index);

}

// Realm.owner(o) returns the index of the realm that created o.

void Shell::RealmOwner(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Isolate* isolate = args.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  if (args.Length() < 1 || !args[0]->IsObject()) {

    Throw("Invalid argument");

    return;

  }

  int index = data->RealmFind(args[0]->ToObject()->CreationContext());

  if (index == -1) return;

  args.GetReturnValue().Set(index);

}

// Realm.global(i) returns the global object of realm i.

// (Note that properties of global objects cannot be read/written cross-realm.)

void Shell::RealmGlobal(const v8::FunctionCallbackInfo<v8::Value>& args) {

  PerIsolateData* data = PerIsolateData::Get(args.GetIsolate());

  if (args.Length() < 1 || !args[0]->IsNumber()) {

    Throw("Invalid argument");

    return;

  }

  int index = args[0]->Uint32Value();

  if (index >= data->realm_count_ || data->realms_[index].IsEmpty()) {

    Throw("Invalid realm index");

    return;

  }

  args.GetReturnValue().Set(

      Local<Context>::New(args.GetIsolate(), data->realms_[index])->Global());

}

// Realm.create() creates a new realm and returns its index.

void Shell::RealmCreate(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Isolate* isolate = args.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  Persistent<Context>* old_realms = data->realms_;

  int index = data->realm_count_;

  data->realms_ = new Persistent<Context>[++data->realm_count_];

  for (int i = 0; i < index; ++i) {

    data->realms_[i].Reset(isolate, old_realms[i]);

  }

  delete[] old_realms;

  Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);

  data->realms_[index].Reset(

      isolate, Context::New(isolate, NULL, global_template));

  args.GetReturnValue().Set(index);

}

// Realm.dispose(i) disposes the reference to the realm i.

void Shell::RealmDispose(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Isolate* isolate = args.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  if (args.Length() < 1 || !args[0]->IsNumber()) {

    Throw("Invalid argument");

    return;

  }

  int index = args[0]->Uint32Value();

  if (index >= data->realm_count_ || data->realms_[index].IsEmpty() ||

      index == 0 ||

      index == data->realm_current_ || index == data->realm_switch_) {

    Throw("Invalid realm index");

    return;

  }

  data->realms_[index].Dispose();

  data->realms_[index].Clear();

}

// Realm.switch(i) switches to the realm i for consecutive interactive inputs.

void Shell::RealmSwitch(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Isolate* isolate = args.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  if (args.Length() < 1 || !args[0]->IsNumber()) {

    Throw("Invalid argument");

    return;

  }

  int index = args[0]->Uint32Value();

  if (index >= data->realm_count_ || data->realms_[index].IsEmpty()) {

    Throw("Invalid realm index");

    return;

  }

  data->realm_switch_ = index;

}

// Realm.eval(i, s) evaluates s in realm i and returns the result.

void Shell::RealmEval(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Isolate* isolate = args.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  if (args.Length() < 2 || !args[0]->IsNumber() || !args[1]->IsString()) {

    Throw("Invalid argument");

    return;

  }

  int index = args[0]->Uint32Value();

  if (index >= data->realm_count_ || data->realms_[index].IsEmpty()) {

    Throw("Invalid realm index");

    return;

  }

  Handle<Script> script = Script::New(args[1]->ToString());

  if (script.IsEmpty()) return;

  Local<Context> realm = Local<Context>::New(isolate, data->realms_[index]);

  realm->Enter();

  Handle<Value> result = script->Run();

  realm->Exit();

  args.GetReturnValue().Set(result);

}

// Realm.shared is an accessor for a single shared value across realms.

void Shell::RealmSharedGet(Local<String> property,

                           const PropertyCallbackInfo<Value>& info) {

  Isolate* isolate = info.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  if (data->realm_shared_.IsEmpty()) return;

  info.GetReturnValue().Set(data->realm_shared_);

}

void Shell::RealmSharedSet(Local<String> property,

                           Local<Value> value,

                           const PropertyCallbackInfo<void>& info) {

  Isolate* isolate = info.GetIsolate();

  PerIsolateData* data = PerIsolateData::Get(isolate);

  if (!data->realm_shared_.IsEmpty()) data->realm_shared_.Dispose();

  data->realm_shared_.Reset(isolate, value);

}

void Shell::Print(const v8::FunctionCallbackInfo<v8::Value>& args) {

  Write(args);

  printf("\n");

  fflush(stdout);

}

void Shell::Write(const v8::FunctionCallbackInfo<v8::Value>& args) {

  for (int i = 0; i < args.Length(); i++) {

    HandleScope handle_scope(args.GetIsolate());

    if (i != 0) {

      printf(" ");

    }

    // Explicitly catch potential exceptions in toString().

    v8::TryCatch try_catch;

    Handle<String> str_obj = args[i]->ToString();

    if (try_catch.HasCaught()) {

      try_catch.ReThrow();

      return;

    }

    v8::String::Utf8Value str(str_obj);

    int n = static_cast<int>(fwrite(*str, sizeof(**str), str.length(), stdout));

    if (n != str.length()) {

      printf("Error in fwrite\n");

      Exit(1);

    }

  }

}

void Shell::Read(const v8::FunctionCallbackInfo<v8::Value>& args) {

  String::Utf8Value file(args[0]);

  if (*file == NULL) {

    Throw("Error loading file");

    return;

  }

  Handle<String> source = ReadFile(args.GetIsolate(), *file);

  if (source.IsEmpty()) {

    Throw("Error loading file");

    return;

  }

  args.GetReturnValue().Set(source);

}

Handle<String> Shell::ReadFromStdin(Isolate* isolate) {

  static const int kBufferSize = 256;

  char buffer[kBufferSize];

  Handle<String> accumulator = String::New("");

  int length;

  while (true) {

    // Continue reading if the line ends with an escape '\\' or the line has

    // not been fully read into the buffer yet (does not end with '\n').

    // If fgets gets an error, just give up.

    char* input = NULL;

    {  // Release lock for blocking input.

      Unlocker unlock(isolate);

      input = fgets(buffer, kBufferSize, stdin);

    }

    if (input == NULL) return Handle<String>();

    length = static_cast<int>(strlen(buffer));

    if (length == 0) {

      return accumulator;

    } else if (buffer[length-1] != '\n') {

      accumulator = String::Concat(accumulator, String::New(buffer, length));

    } else if (length > 1 && buffer[length-2] == '\\') {

      buffer[length-2] = '\n';

      accumulator = String::Concat(accumulator, String::New(buffer, length-1));

    } else {

      return String::Concat(accumulator, String::New(buffer, length-1));

    }

  }

}

void Shell::Load(const v8::FunctionCallbackInfo<v8::Value>& args) {

  for (int i = 0; i < args.Length(); i++) {

    HandleScope handle_scope(args.GetIsolate());

    String::Utf8Value file(args[i]);

    if (*file == NULL) {

      Throw("Error loading file");

      return;

    }

    Handle<String> source = ReadFile(args.GetIsolate(), *file);

    if (source.IsEmpty()) {

      Throw("Error loading file");

      return;

    }

    if (!ExecuteString(args.GetIsolate(),

                       source,

                       String::New(*file),

                       false,

                       true)) {

      Throw("Error executing file");

      return;

    }

  }

}

void Shell::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {

  int exit_code = args[0]->Int32Value();

  OnExit();

  exit(exit_code);

}

void Shell::Version(const v8::FunctionCallbackInfo<v8::Value>& args) {

  args.GetReturnValue().Set(String::New(V8::GetVersion()));

}

void Shell::ReportException(Isolate* isolate, v8::TryCatch* try_catch) {

  HandleScope handle_scope(isolate);

#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)

  Handle<Context> utility_context;

  bool enter_context = !Context::InContext();

  if (enter_context) {

    utility_context = Local<Context>::New(isolate, utility_context_);

    utility_context->Enter();

  }

#endif  // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT

  v8::String::Utf8Value exception(try_catch->Exception());

  const char* exception_string = ToCString(exception);

  Handle<Message> message = try_catch->Message();

  if (message.IsEmpty()) {

    // V8 didn't provide any extra information about this error; just

    // print the exception.

    printf("%s\n", exception_string);

  } else {

    // Print (filename):(line number): (message).

    v8::String::Utf8Value filename(message->GetScriptResourceName());

    const char* filename_string = ToCString(filename);

    int linenum = message->GetLineNumber();

    printf("%s:%i: %s\n", filename_string, linenum, exception_string);

    // Print line of source code.

    v8::String::Utf8Value sourceline(message->GetSourceLine());

    const char* sourceline_string = ToCString(sourceline);

    printf("%s\n", sourceline_string);

    // Print wavy underline (GetUnderline is deprecated).

    int start = message->GetStartColumn();

    for (int i = 0; i < start; i++) {

      printf(" ");

    }

    int end = message->GetEndColumn();

    for (int i = start; i < end; i++) {

      printf("^");

    }

    printf("\n");

    v8::String::Utf8Value stack_trace(try_catch->StackTrace());

    if (stack_trace.length() > 0) {

      const char* stack_trace_string = ToCString(stack_trace);

      printf("%s\n", stack_trace_string);

    }

  }

  printf("\n");

#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)

  if (enter_context) utility_context->Exit();

#endif  // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT

}

#ifndef V8_SHARED

Handle<Array> Shell::GetCompletions(Isolate* isolate,

                                    Handle<String> text,

                                    Handle<String> full) {

  HandleScope handle_scope(isolate);

  v8::Local<v8::Context> utility_context =

      v8::Local<v8::Context>::New(isolate, utility_context_);

  v8::Context::Scope context_scope(utility_context);

  Handle<Object> global = utility_context->Global();

  Handle<Value> fun = global->Get(String::New("GetCompletions"));

  static const int kArgc = 3;

  v8::Local<v8::Context> evaluation_context =

      v8::Local<v8::Context>::New(isolate, evaluation_context_);

  Handle<Value> argv[kArgc] = { evaluation_context->Global(), text, full };

  Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);

  return handle_scope.Close(Handle<Array>::Cast(val));

}

#ifdef ENABLE_DEBUGGER_SUPPORT

Handle<Object> Shell::DebugMessageDetails(Isolate* isolate,

                                          Handle<String> message) {

  HandleScope handle_scope(isolate);

  v8::Local<v8::Context> context =

      v8::Local<v8::Context>::New(isolate, utility_context_);

  v8::Context::Scope context_scope(context);

  Handle<Object> global = context->Global();

  Handle<Value> fun = global->Get(String::New("DebugMessageDetails"));

  static const int kArgc = 1;

  Handle<Value> argv[kArgc] = { message };

  Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);

  return Handle<Object>::Cast(val);

}

Handle<Value> Shell::DebugCommandToJSONRequest(Isolate* isolate,

                                               Handle<String> command) {

  HandleScope handle_scope(isolate);

  v8::Local<v8::Context> context =

      v8::Local<v8::Context>::New(isolate, utility_context_);

  v8::Context::Scope context_scope(context);

  Handle<Object> global = context->Global();

  Handle<Value> fun = global->Get(String::New("DebugCommandToJSONRequest"));

  static const int kArgc = 1;

  Handle<Value> argv[kArgc] = { command };

  Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);

  return val;

}

void Shell::DispatchDebugMessages() {

  Isolate* isolate = v8::Isolate::GetCurrent();

  HandleScope handle_scope(isolate);

  v8::Local<v8::Context> context =

      v8::Local<v8::Context>::New(isolate, Shell::evaluation_context_);

  v8::Context::Scope context_scope(context);

  v8::Debug::ProcessDebugMessages();

}

#endif  // ENABLE_DEBUGGER_SUPPORT

#endif  // V8_SHARED

#ifndef V8_SHARED

int32_t* Counter::Bind(const char* name, bool is_histogram) {

  int i;

  for (i = 0; i < kMaxNameSize - 1 && name[i]; i++)

    name_[i] = static_cast<char>(name[i]);

  name_[i] = '\0';

  is_histogram_ = is_histogram;

  return ptr();

}

void Counter::AddSample(int32_t sample) {

  count_++;

  sample_total_ += sample;

}

CounterCollection::CounterCollection() {

  magic_number_ = 0xDEADFACE;

  max_counters_ = kMaxCounters;

  max_name_size_ = Counter::kMaxNameSize;

  counters_in_use_ = 0;

}

Counter* CounterCollection::GetNextCounter() {

  if (counters_in_use_ == kMaxCounters) return NULL;

  return &counters_[counters_in_use_++];

}

void Shell::MapCounters(const char* name) {

  counters_file_ = i::OS::MemoryMappedFile::create(

      name, sizeof(CounterCollection), &local_counters_);

  void* memory = (counters_file_ == NULL) ?

      NULL : counters_file_->memory();

  if (memory == NULL) {

    printf("Could not map counters file %s\n", name);

    Exit(1);

  }

  counters_ = static_cast<CounterCollection*>(memory);

  V8::SetCounterFunction(LookupCounter);

  V8::SetCreateHistogramFunction(CreateHistogram);

  V8::SetAddHistogramSampleFunction(AddHistogramSample);

}

int CounterMap::Hash(const char* name) {

  int h = 0;

  int c;

  while ((c = *name++) != 0) {

    h += h << 5;

    h += c;

  }

  return h;

}

Counter* Shell::GetCounter(const char* name, bool is_histogram) {

  Counter* counter = counter_map_->Lookup(name);

  if (counter == NULL) {

    counter = counters_->GetNextCounter();

    if (counter != NULL) {

      counter_map_->Set(name, counter);

      counter->Bind(name, is_histogram);

    }

  } else {

    ASSERT(counter->is_histogram() == is_histogram);

  }

  return counter;

}

int* Shell::LookupCounter(const char* name) {

  Counter* counter = GetCounter(name, false);

  if (counter != NULL) {

    return counter->ptr();

  } else {

    return NULL;

  }

}

void* Shell::CreateHistogram(const char* name,

                             int min,

                             int max,

                             size_t buckets) {

  return GetCounter(name, true);

}

void Shell::AddHistogramSample(void* histogram, int sample) {

  Counter* counter = reinterpret_cast<Counter*>(histogram);

  counter->AddSample(sample);

}

void Shell::InstallUtilityScript(Isolate* isolate) {

  Locker lock(isolate);

  HandleScope scope(isolate);

  // If we use the utility context, we have to set the security tokens so that

  // utility, evaluation and debug context can all access each other.

  v8::Local<v8::Context> utility_context =

      v8::Local<v8::Context>::New(isolate, utility_context_);

  v8::Local<v8::Context> evaluation_context =

      v8::Local<v8::Context>::New(isolate, evaluation_context_);

  utility_context->SetSecurityToken(Undefined(isolate));

  evaluation_context->SetSecurityToken(Undefined(isolate));

  v8::Context::Scope context_scope(utility_context);

#ifdef ENABLE_DEBUGGER_SUPPORT

  if (i::FLAG_debugger) printf("JavaScript debugger enabled\n");

  // Install the debugger object in the utility scope

  i::Debug* debug = reinterpret_cast<i::Isolate*>(isolate)->debug();

  debug->Load();

  i::Handle<i::JSObject> js_debug

      = i::Handle<i::JSObject>(debug->debug_context()->global_object());

  utility_context->Global()->Set(String::New("$debug"),

                                  Utils::ToLocal(js_debug));

  debug->debug_context()->set_security_token(

      reinterpret_cast<i::Isolate*>(isolate)->heap()->undefined_value());

#endif  // ENABLE_DEBUGGER_SUPPORT

  // Run the d8 shell utility script in the utility context

  int source_index = i::NativesCollection<i::D8>::GetIndex("d8");

  i::Vector<const char> shell_source =

      i::NativesCollection<i::D8>::GetRawScriptSource(source_index);

  i::Vector<const char> shell_source_name =

      i::NativesCollection<i::D8>::GetScriptName(source_index);

  Handle<String> source = String::New(shell_source.start(),

      shell_source.length());

  Handle<String> name = String::New(shell_source_name.start(),

      shell_source_name.length());

  Handle<Script> script = Script::Compile(source, name);

  script->Run();

  // Mark the d8 shell script as native to avoid it showing up as normal source

  // in the debugger.

  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));

#ifdef ENABLE_DEBUGGER_SUPPORT

  // Start the in-process debugger if requested.

  if (i::FLAG_debugger && !i::FLAG_debugger_agent) {

    v8::Debug::SetDebugEventListener2(HandleDebugEvent);

  }

#endif  // ENABLE_DEBUGGER_SUPPORT

}

#endif  // V8_SHARED

#ifdef COMPRESS_STARTUP_DATA_BZ2

class BZip2Decompressor : public v8::StartupDataDecompressor {

 public:

  virtual ~BZip2Decompressor() { }

 protected:

  virtual int DecompressData(char* raw_data,

                             int* raw_data_size,

                             const char* compressed_data,

                             int compressed_data_size) {

    ASSERT_EQ(v8::StartupData::kBZip2,

              v8::V8::GetCompressedStartupDataAlgorithm());

    unsigned int decompressed_size = *raw_data_size;

    int result =

        BZ2_bzBuffToBuffDecompress(raw_data,

                                   &decompressed_size,

                                   const_cast<char*>(compressed_data),

                                   compressed_data_size,

                                   0, 1);

    if (result == BZ_OK) {

      *raw_data_size = decompressed_size;

    }

    return result;

  }

};

#endif

Handle<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {

  Handle<ObjectTemplate> global_template = ObjectTemplate::New();

  global_template->Set(String::New("print"), FunctionTemplate::New(Print));

  global_template->Set(String::New("write"), FunctionTemplate::New(Write));

  global_template->Set(String::New("read"), FunctionTemplate::New(Read));

  global_template->Set(String::New("readbuffer"),

                       FunctionTemplate::New(ReadBuffer));

  global_template->Set(String::New("readline"),

                       FunctionTemplate::New(ReadLine));

  global_template->Set(String::New("load"), FunctionTemplate::New(Load));

  global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));

  global_template->Set(String::New("version"), FunctionTemplate::New(Version));

  // Bind the Realm object.

  Handle<ObjectTemplate> realm_template = ObjectTemplate::New();

  realm_template->Set(String::New("current"),

                      FunctionTemplate::New(RealmCurrent));

  realm_template->Set(String::New("owner"),

                      FunctionTemplate::New(RealmOwner));

  realm_template->Set(String::New("global"),

                      FunctionTemplate::New(RealmGlobal));

  realm_template->Set(String::New("create"),

                      FunctionTemplate::New(RealmCreate));

  realm_template->Set(String::New("dispose"),

                      FunctionTemplate::New(RealmDispose));

  realm_template->Set(String::New("switch"),

                      FunctionTemplate::New(RealmSwitch));

  realm_template->Set(String::New("eval"),

                      FunctionTemplate::New(RealmEval));

  realm_template->SetAccessor(String::New("shared"),

                              RealmSharedGet, RealmSharedSet);

  global_template->Set(String::New("Realm"), realm_template);

#ifndef V8_SHARED

  Handle<ObjectTemplate> performance_template = ObjectTemplate::New();

  performance_template->Set(String::New("now"),

                            FunctionTemplate::New(PerformanceNow));

  global_template->Set(String::New("performance"), performance_template);

#endif  // V8_SHARED

#if !defined(V8_SHARED) && !defined(_WIN32) && !defined(_WIN64)

  Handle<ObjectTemplate> os_templ = ObjectTemplate::New();

  AddOSMethods(os_templ);

  global_template->Set(String::New("os"), os_templ);

#endif  // V8_SHARED

  return global_template;

}

void Shell::Initialize(Isolate* isolate) {

#ifdef COMPRESS_STARTUP_DATA_BZ2

  BZip2Decompressor startup_data_decompressor;

  int bz2_result = startup_data_decompressor.Decompress();

  if (bz2_result != BZ_OK) {

    fprintf(stderr, "bzip error code: %d\n", bz2_result);

    Exit(1);

  }

#endif

#ifndef V8_SHARED

  Shell::counter_map_ = new CounterMap();

  // Set up counters

  if (i::StrLength(i::FLAG_map_counters) != 0)

    MapCounters(i::FLAG_map_counters);

  if (i::FLAG_dump_counters || i::FLAG_track_gc_object_stats) {

    V8::SetCounterFunction(LookupCounter);

    V8::SetCreateHistogramFunction(CreateHistogram);

    V8::SetAddHistogramSampleFunction(AddHistogramSample);

  }

#endif  // V8_SHARED

}

void Shell::InitializeDebugger(Isolate* isolate) {

  if (options.test_shell) return;

#ifndef V8_SHARED

  Locker lock(isolate);

  HandleScope scope(isolate);

  Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);

  utility_context_.Reset(isolate,

                         Context::New(isolate, NULL, global_template));

#ifdef ENABLE_DEBUGGER_SUPPORT

  // Start the debugger agent if requested.

  if (i::FLAG_debugger_agent) {

    v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);

    v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessages, true);

  }

#endif  // ENABLE_DEBUGGER_SUPPORT

#endif  // V8_SHARED

}

Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {

#ifndef V8_SHARED

  // This needs to be a critical section since this is not thread-safe

  i::LockGuard<i::Mutex> lock_guard(&context_mutex_);

#endif  // V8_SHARED

  // Initialize the global objects

  Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);

  HandleScope handle_scope(isolate);

  Local<Context> context = Context::New(isolate, NULL, global_template);

  ASSERT(!context.IsEmpty());

  Context::Scope scope(context);

#ifndef V8_SHARED

  i::Factory* factory = reinterpret_cast<i::Isolate*>(isolate)->factory();

  i::JSArguments js_args = i::FLAG_js_arguments;

  i::Handle<i::FixedArray> arguments_array =

      factory->NewFixedArray(js_args.argc);

  for (int j = 0; j < js_args.argc; j++) {

    i::Handle<i::String> arg =

        factory->NewStringFromUtf8(i::CStrVector(js_args[j]));

    arguments_array->set(j, *arg);

  }

  i::Handle<i::JSArray> arguments_jsarray =

      factory->NewJSArrayWithElements(arguments_array);

  context->Global()->Set(String::New("arguments"),

                         Utils::ToLocal(arguments_jsarray));

#endif  // V8_SHARED

  return handle_scope.Close(context);

}

void Shell::Exit(int exit_code) {

  // Use _exit instead of exit to avoid races between isolate

  // threads and static destructors.

  fflush(stdout);

  fflush(stderr);

  _exit(exit_code);

}

#ifndef V8_SHARED

struct CounterAndKey {

  Counter* counter;

  const char* key;

};

inline bool operator<(const CounterAndKey& lhs, const CounterAndKey& rhs) {

  return strcmp(lhs.key, rhs.key) < 0;

}

#endif  // V8_SHARED

void Shell::OnExit() {

  LineEditor* line_editor = LineEditor::Get();

  if (line_editor) line_editor->Close();

#ifndef V8_SHARED

  if (i::FLAG_dump_counters) {

    int number_of_counters = 0;

    for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {

      number_of_counters++;

    }

    CounterAndKey* counters = new CounterAndKey[number_of_counters];

    int j = 0;

    for (CounterMap::Iterator i(counter_map_); i.More(); i.Next(), j++) {

      counters[j].counter = i.CurrentValue();

      counters[j].key = i.CurrentKey();

    }

    std::sort(counters, counters + number_of_counters);

    printf("+----------------------------------------------------------------+"

           "-------------+\n");

    printf("| Name                                                           |"

           " Value       |\n");

    printf("+----------------------------------------------------------------+"

           "-------------+\n");

    for (j = 0; j < number_of_counters; j++) {

      Counter* counter = counters[j].counter;

      const char* key = counters[j].key;

      if (counter->is_histogram()) {

        printf("| c:%-60s | %11i |\n", key, counter->count());

        printf("| t:%-60s | %11i |\n", key, counter->sample_total());

      } else {

        printf("| %-62s | %11i |\n", key, counter->count());

      }

    }

    printf("+----------------------------------------------------------------+"

           "-------------+\n");

    delete [] counters;

  }

  delete counters_file_;

  delete counter_map_;

#endif  // V8_SHARED

}

static FILE* FOpen(const char* path, const char* mode) {

#if defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))

  FILE* result;

  if (fopen_s(&result, path, mode) == 0) {

    return result;

  } else {

    return NULL;

  }

#else

  FILE* file = fopen(path, mode);

  if (file == NULL) return NULL;

  struct stat file_stat;

  if (fstat(fileno(file), &file_stat) != 0) return NULL;

  bool is_regular_file = ((file_stat.st_mode & S_IFREG) != 0);

  if (is_regular_file) return file;

  fclose(file);

  return NULL;

#endif

}

static char* ReadChars(Isolate* isolate, const char* name, int* size_out) {

  // Release the V8 lock while reading files.

  v8::Unlocker unlocker(isolate);

  FILE* file = FOpen(name, "rb");

  if (file == NULL) return NULL;

  fseek(file, 0, SEEK_END);

  int size = ftell(file);

  rewind(file);

  char* chars = new char[size + 1];

  chars[size] = '\0';

  for (int i = 0; i < size;) {

    int read = static_cast<int>(fread(&chars[i], 1, size - i, file));

    i += read;

  }

  fclose(file);

  *size_out = size;

  return chars;

}

static void ReadBufferWeakCallback(v8::Isolate* isolate,

                                   Persistent<ArrayBuffer>* array_buffer,

                                   uint8_t* data) {

  size_t byte_length =

      Local<ArrayBuffer>::New(isolate, *array_buffer)->ByteLength();

  isolate->AdjustAmountOfExternalAllocatedMemory(

      -static_cast<intptr_t>(byte_length));

  delete[] data;

  array_buffer->Dispose();

}

void Shell::ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args) {

  ASSERT(sizeof(char) == sizeof(uint8_t));  // NOLINT

  String::Utf8Value filename(args[0]);

  int length;

  if (*filename == NULL) {

    Throw("Error loading file");

    return;

  }

  Isolate* isolate = args.GetIsolate();

  uint8_t* data = reinterpret_cast<uint8_t*>(

      ReadChars(args.GetIsolate(), *filename, &length));

  if (data == NULL) {

    Throw("Error reading file");

    return;

  }

  Handle<v8::ArrayBuffer> buffer = ArrayBuffer::New(data, length);

  v8::Persistent<v8::ArrayBuffer> weak_handle(isolate, buffer);

  weak_handle.MakeWeak(data, ReadBufferWeakCallback);

  weak_handle.MarkIndependent();

  isolate->AdjustAmountOfExternalAllocatedMemory(length);

  args.GetReturnValue().Set(buffer);

}

#ifndef V8_SHARED

static char* ReadToken(char* data, char token) {

  char* next = i::OS::StrChr(data, token);

  if (next != NULL) {

    *next = '\0';

    return (next + 1);

  }

  return NULL;

}

static char* ReadLine(char* data) {

  return ReadToken(data, '\n');

}

static char* ReadWord(char* data) {

  return ReadToken(data, ' ');

}

#endif  // V8_SHARED

// Reads a file into a v8 string.

Handle<String> Shell::ReadFile(Isolate* isolate, const char* name) {

  int size = 0;

  char* chars = ReadChars(isolate, name, &size);

  if (chars == NULL) return Handle<String>();

  Handle<String> result = String::New(chars, size);

  delete[] chars;

  return result;

}

void Shell::RunShell(Isolate* isolate) {

  Locker locker(isolate);

  HandleScope outer_scope(isolate);

  v8::Local<v8::Context> context =

      v8::Local<v8::Context>::New(isolate, evaluation_context_);

  v8::Context::Scope context_scope(context);

  PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));

  Handle<String> name = String::New("(d8)");

  LineEditor* console = LineEditor::Get();

  printf("V8 version %s [console: %s]\n", V8::GetVersion(), console->name());

  console->Open(isolate);

  while (true) {

    HandleScope inner_scope(isolate);

    Handle<String> input = console->Prompt(Shell::kPrompt);

    if (input.IsEmpty()) break;

    ExecuteString(isolate, input, name, true, true);

  }

  printf("\n");

}

#ifndef V8_SHARED

class ShellThread : public i::Thread {

 public:

  // Takes ownership of the underlying char array of |files|.

  ShellThread(Isolate* isolate, char* files)

      : Thread("d8:ShellThread"),

        isolate_(isolate), files_(files) { }

  ~ShellThread() {

    delete[] files_;

  }

  virtual void Run();

 private:

  Isolate* isolate_;

  char* files_;

};

void ShellThread::Run() {

  char* ptr = files_;

  while ((ptr != NULL) && (*ptr != '\0')) {

    // For each newline-separated line.

    char* next_line = ReadLine(ptr);

    if (*ptr == '#') {

      // Skip comment lines.

      ptr = next_line;

      continue;

    }

    // Prepare the context for this thread.

    Locker locker(isolate_);

    HandleScope outer_scope(isolate_);

    Local<Context> thread_context =

        Shell::CreateEvaluationContext(isolate_);

    Context::Scope context_scope(thread_context);

    PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate_));

    while ((ptr != NULL) && (*ptr != '\0')) {

      HandleScope inner_scope(isolate_);

      char* filename = ptr;

      ptr = ReadWord(ptr);

      // Skip empty strings.

      if (strlen(filename) == 0) {

        continue;

      }

      Handle<String> str = Shell::ReadFile(isolate_, filename);

      if (str.IsEmpty()) {

        printf("File '%s' not found\n", filename);

        Shell::Exit(1);

      }

      Shell::ExecuteString(isolate_, str, String::New(filename), false, false);

    }

    ptr = next_line;

  }

}

#endif  // V8_SHARED

SourceGroup::~SourceGroup() {

#ifndef V8_SHARED

  delete thread_;

  thread_ = NULL;

#endif  // V8_SHARED

}

void SourceGroup::Execute(Isolate* isolate) {

  bool exception_was_thrown = false;

  for (int i = begin_offset_; i < end_offset_; ++i) {

    const char* arg = argv_[i];

    if (strcmp(arg, "-e") == 0 && i + 1 < end_offset_) {

      // Execute argument given to -e option directly.

      HandleScope handle_scope(isolate);

      Handle<String> file_name = String::New("unnamed");

      Handle<String> source = String::New(argv_[i + 1]);

      if (!Shell::ExecuteString(isolate, source, file_name, false, true)) {

        exception_was_thrown = true;

        break;

      }

      ++i;

    } else if (arg[0] == '-') {

      // Ignore other options. They have been parsed already.

    } else {

      // Use all other arguments as names of files to load and run.

      HandleScope handle_scope(isolate);

      Handle<String> file_name = String::New(arg);

      Handle<String> source = ReadFile(isolate, arg);

      if (source.IsEmpty()) {

        printf("Error reading '%s'\n", arg);

        Shell::Exit(1);

      }

      if (!Shell::ExecuteString(isolate, source, file_name, false, true)) {

        exception_was_thrown = true;

        break;

      }

    }

  }

  if (exception_was_thrown != Shell::options.expected_to_throw) {

    Shell::Exit(1);

  }

}

Handle<String> SourceGroup::ReadFile(Isolate* isolate, const char* name) {

  int size;

  char* chars = ReadChars(isolate, name, &size);

  if (chars == NULL) return Handle<String>();

  Handle<String> result = String::New(chars, size);

  delete[] chars;

  return result;

}

#ifndef V8_SHARED

i::Thread::Options SourceGroup::GetThreadOptions() {

  // On some systems (OSX 10.6) the stack size default is 0.5Mb or less

  // which is not enough to parse the big literal expressions used in tests.

  // The stack size should be at least StackGuard::kLimitSize + some

  // OS-specific padding for thread startup code.  2Mbytes seems to be enough.

  return i::Thread::Options("IsolateThread", 2 * MB);

}

void SourceGroup::ExecuteInThread() {

  Isolate* isolate = Isolate::New();

  do {

    next_semaphore_.Wait();

    {

      Isolate::Scope iscope(isolate);

      Locker lock(isolate);

      {

        HandleScope scope(isolate);

        PerIsolateData data(isolate);

        Local<Context> context = Shell::CreateEvaluationContext(isolate);

        {

          Context::Scope cscope(context);

          PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));

          Execute(isolate);

        }

      }

      if (Shell::options.send_idle_notification) {

        const int kLongIdlePauseInMs = 1000;

        V8::ContextDisposedNotification();

        V8::IdleNotification(kLongIdlePauseInMs);

      }

    }

    done_semaphore_.Signal();

  } while (!Shell::options.last_run);