v8::SourceGroup Class Reference

#include <d8.h>

Collaboration diagram for v8::SourceGroup:

Classes
class	IsolateThread

Public Member Functions
	SourceGroup ()
	~SourceGroup ()
void	Begin (char **argv, int offset)
void	End (int offset)
void	Execute (Isolate *isolate)
void	StartExecuteInThread ()
void	WaitForThread ()

Private Member Functions
void	ExecuteInThread ()
void	ExitShell (int exit_code)
Handle< String >	ReadFile (Isolate *isolate, const char *name)

Static Private Member Functions
static base::Thread::Options	GetThreadOptions ()

Private Attributes
base::Semaphore	next_semaphore_
base::Semaphore	done_semaphore_
base::Thread *	thread_
const char **	argv_
int	begin_offset_
int	end_offset_

Detailed Description

Definition at line 117 of file d8.h.

Constructor & Destructor Documentation

SourceGroup()

v8::SourceGroup::SourceGroup ( )

inline

Definition at line 119 of file d8.h.

                :
#ifndef V8_SHARED
      next_semaphore_(0),
      done_semaphore_(0),
      thread_(NULL),
#endif  // !V8_SHARED
      argv_(NULL),
      begin_offset_(0),
      end_offset_(0) {}

~SourceGroup()

v8::SourceGroup::~SourceGroup

(

)

Definition at line 1176 of file d8.cc.

                          {
#ifndef V8_SHARED
  delete thread_;
  thread_ = NULL;
#endif  // !V8_SHARED
}

References NULL.

Member Function Documentation

Begin()

void v8::SourceGroup::Begin ( char **  argv, int  offset  )

inline

Definition at line 131 of file d8.h.

                                      {
    argv_ = const_cast<const char**>(argv);
    begin_offset_ = offset;
  }

References argv_, and begin_offset_.

Referenced by v8::Shell::SetOptions().

Here is the caller graph for this function:

End()

void v8::SourceGroup::End ( int  offset )

inline

Definition at line 136 of file d8.h.

{ end_offset_ = offset; }

References end_offset_.

Referenced by v8::Shell::SetOptions().

Here is the caller graph for this function:

Execute()

void v8::SourceGroup::Execute

(

Isolate *

isolate

)

Definition at line 1184 of file d8.cc.

                                          {
  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::NewFromUtf8(isolate, "unnamed");
      Handle<String> source = String::NewFromUtf8(isolate, 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::NewFromUtf8(isolate, 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);
  }
}

References v8::Shell::ExecuteString(), v8::Shell::Exit(), v8::Handle< T >::IsEmpty(), v8::String::NewFromUtf8(), v8::Shell::options, and v8::internal::ReadFile().

Here is the call graph for this function:

ExecuteInThread()

void v8::SourceGroup::ExecuteInThread ( )

private

Definition at line 1242 of file d8.cc.

                                  {
  Isolate* isolate = Isolate::New();
  do {
    next_semaphore_.Wait();
    {
      Isolate::Scope iscope(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;
        isolate->ContextDisposedNotification();
        isolate->IdleNotification(kLongIdlePauseInMs);
      }
      if (Shell::options.invoke_weak_callbacks) {
        // By sending a low memory notifications, we will try hard to collect
        // all garbage and will therefore also invoke all weak callbacks of
        // actually unreachable persistent handles.
        isolate->LowMemoryNotification();
      }
    }
    done_semaphore_.Signal();
  } while (!Shell::options.last_run);
 
  isolate->Dispose();
}

References v8::Isolate::ContextDisposedNotification(), v8::Shell::CreateEvaluationContext(), v8::Isolate::Dispose(), v8::PerIsolateData::Get(), v8::Isolate::IdleNotification(), v8::Isolate::LowMemoryNotification(), v8::Isolate::New(), and v8::Shell::options.

Referenced by v8::SourceGroup::IsolateThread::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

ExitShell()

void v8::SourceGroup::ExitShell ( int  exit_code )

private

GetThreadOptions()

base::Thread::Options v8::SourceGroup::GetThreadOptions ( )

staticprivate

Definition at line 1233 of file d8.cc.

                                                {
  // 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 base::Thread::Options("IsolateThread", 2 * MB);
}

References v8::MB.

ReadFile()

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

private

Definition at line 1221 of file d8.cc.

                                                                       {
  int size;
  char* chars = ReadChars(isolate, name, &size);
  if (chars == NULL) return Handle<String>();
  Handle<String> result =
      String::NewFromUtf8(isolate, chars, String::kNormalString, size);
  delete[] chars;
  return result;
}

References v8::String::kNormalString, name, v8::String::NewFromUtf8(), NULL, v8::ReadChars(), and size.

Here is the call graph for this function:

StartExecuteInThread()

void v8::SourceGroup::StartExecuteInThread

(

)

Definition at line 1277 of file d8.cc.

                                       {
  if (thread_ == NULL) {
    thread_ = new IsolateThread(this);
    thread_->Start();
  }
  next_semaphore_.Signal();
}

References NULL.

WaitForThread()

void v8::SourceGroup::WaitForThread

(

)

Definition at line 1286 of file d8.cc.

                                {
  if (thread_ == NULL) return;
  if (Shell::options.last_run) {
    thread_->Join();
  } else {
    done_semaphore_.Wait();
  }
}

References NULL, and v8::Shell::options.

Member Data Documentation

argv_

const char** v8::SourceGroup::argv_

private

Definition at line 169 of file d8.h.

Referenced by Begin().

begin_offset_

int v8::SourceGroup::begin_offset_

private

Definition at line 170 of file d8.h.

Referenced by Begin().

done_semaphore_

base::Semaphore v8::SourceGroup::done_semaphore_

private

Definition at line 162 of file d8.h.

end_offset_

int v8::SourceGroup::end_offset_

private

Definition at line 171 of file d8.h.

Referenced by End().

next_semaphore_

base::Semaphore v8::SourceGroup::next_semaphore_

private

Definition at line 161 of file d8.h.

thread_

base::Thread* v8::SourceGroup::thread_

private

Definition at line 163 of file d8.h.

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/d8.h
• /mnt/V8SourceCode/src/d8.cc