Introduces a light version of D8 that links against shared library.
Review URL: http://codereview.chromium.org/7351017 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@8657 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
yangguo@chromium.org
parent
d4779286b6
commit
e8bf31427b
13
SConstruct
13
SConstruct
@ -773,6 +773,13 @@ PREPARSER_FLAGS = {
|
||||
|
||||
|
||||
D8_FLAGS = {
|
||||
'all': {
|
||||
'library:shared': {
|
||||
'CPPDEFINES': ['V8_SHARED'],
|
||||
'LIBS': ['v8'],
|
||||
'LIBPATH': ['.']
|
||||
},
|
||||
},
|
||||
'gcc': {
|
||||
'all': {
|
||||
'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'],
|
||||
@ -1370,7 +1377,11 @@ def BuildSpecific(env, mode, env_overrides, tools):
|
||||
d8_env = Environment(tools=tools)
|
||||
d8_env.Replace(**context.flags['d8'])
|
||||
context.ApplyEnvOverrides(d8_env)
|
||||
shell = d8_env.Program('d8' + suffix, object_files + shell_files)
|
||||
if context.options['library'] == 'static':
|
||||
shell = d8_env.Program('d8' + suffix, object_files + shell_files)
|
||||
else:
|
||||
shell = d8_env.Program('d8' + suffix, shell_files)
|
||||
d8_env.Depends(shell, library)
|
||||
context.d8_targets.append(shell)
|
||||
|
||||
for sample in context.samples:
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
'type': 'none',
|
||||
'dependencies': [
|
||||
'../samples/samples.gyp:*',
|
||||
'../src/d8.gyp:*',
|
||||
'../src/d8.gyp:d8',
|
||||
],
|
||||
'conditions': [
|
||||
[ 'component!="shared_library"', {
|
||||
|
||||
@ -243,7 +243,14 @@ PREPARSER_SOURCES = {
|
||||
}
|
||||
|
||||
|
||||
D8_FILES = {
|
||||
D8_LIGHT_FILES = {
|
||||
'all': [
|
||||
'd8.cc'
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
D8_FULL_FILES = {
|
||||
'all': [
|
||||
'd8.cc', 'd8-debug.cc'
|
||||
],
|
||||
@ -323,11 +330,15 @@ def ConfigureObjectFiles():
|
||||
|
||||
# Build the standard platform-independent source files.
|
||||
source_files = context.GetRelevantSources(SOURCES)
|
||||
|
||||
d8_files = context.GetRelevantSources(D8_FILES)
|
||||
d8_js = env.JS2C('d8-js.cc', 'd8.js', **{'TYPE': 'D8', 'COMPRESSION': 'off'})
|
||||
d8_js_obj = context.ConfigureObject(env, d8_js, CPPPATH=['.'])
|
||||
d8_objs = [context.ConfigureObject(env, [d8_files]), d8_js_obj]
|
||||
if context.options['library'] == 'shared':
|
||||
d8_files = context.GetRelevantSources(D8_LIGHT_FILES)
|
||||
d8_objs = []
|
||||
else:
|
||||
d8_files = context.GetRelevantSources(D8_FULL_FILES)
|
||||
d8_objs = [d8_js_obj]
|
||||
d8_objs.append(context.ConfigureObject(env, [d8_files]))
|
||||
|
||||
# Combine the JavaScript library files into a single C++ file and
|
||||
# compile it.
|
||||
|
||||
233
src/d8.cc
233
src/d8.cc
@ -26,33 +26,49 @@
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
||||
#ifdef V8_SHARED
|
||||
#define USING_V8_SHARED
|
||||
#endif
|
||||
|
||||
#ifdef COMPRESS_STARTUP_DATA_BZ2
|
||||
#include <bzlib.h>
|
||||
#endif
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "v8.h"
|
||||
#ifdef USING_V8_SHARED
|
||||
#include <assert.h>
|
||||
#include "../include/v8-testing.h"
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
#include "d8.h"
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
#include "api.h"
|
||||
#include "checks.h"
|
||||
#include "d8-debug.h"
|
||||
#include "debug.h"
|
||||
#include "api.h"
|
||||
#include "natives.h"
|
||||
#include "platform.h"
|
||||
#include "v8.h"
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
#if !defined(_WIN32) && !defined(_WIN64)
|
||||
#include <unistd.h> // NOLINT
|
||||
#endif
|
||||
|
||||
#ifdef USING_V8_SHARED
|
||||
#define ASSERT(condition) assert(condition)
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
namespace v8 {
|
||||
|
||||
|
||||
const char* Shell::kHistoryFileName = ".d8_history";
|
||||
const char* Shell::kPrompt = "d8> ";
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
LineEditor *LineEditor::first_ = NULL;
|
||||
const char* Shell::kHistoryFileName = ".d8_history";
|
||||
|
||||
|
||||
LineEditor::LineEditor(Type type, const char* name)
|
||||
@ -98,17 +114,22 @@ CounterMap* Shell::counter_map_;
|
||||
i::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
|
||||
CounterCollection Shell::local_counters_;
|
||||
CounterCollection* Shell::counters_ = &local_counters_;
|
||||
Persistent<Context> Shell::utility_context_;
|
||||
Persistent<Context> Shell::evaluation_context_;
|
||||
i::Mutex* Shell::context_mutex_(i::OS::CreateMutex());
|
||||
Persistent<Context> Shell::utility_context_;
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
Persistent<Context> Shell::evaluation_context_;
|
||||
ShellOptions Shell::options;
|
||||
const char* Shell::kPrompt = "d8> ";
|
||||
|
||||
|
||||
#ifndef USING_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 // USING_V8_SHARED
|
||||
|
||||
|
||||
// Converts a V8 value to a C string.
|
||||
@ -122,17 +143,22 @@ bool Shell::ExecuteString(Handle<String> source,
|
||||
Handle<Value> name,
|
||||
bool print_result,
|
||||
bool report_exceptions) {
|
||||
#ifndef USING_V8_SHARED
|
||||
bool FLAG_debugger = i::FLAG_debugger;
|
||||
#else
|
||||
bool FLAG_debugger = false;
|
||||
#endif // USING_V8_SHARED
|
||||
HandleScope handle_scope;
|
||||
TryCatch try_catch;
|
||||
options.script_executed = true;
|
||||
if (i::FLAG_debugger) {
|
||||
if (FLAG_debugger) {
|
||||
// When debugging make exceptions appear to be uncaught.
|
||||
try_catch.SetVerbose(true);
|
||||
}
|
||||
Handle<Script> script = Script::Compile(source, name);
|
||||
if (script.IsEmpty()) {
|
||||
// Print errors that happened during compilation.
|
||||
if (report_exceptions && !i::FLAG_debugger)
|
||||
if (report_exceptions && !FLAG_debugger)
|
||||
ReportException(&try_catch);
|
||||
return false;
|
||||
} else {
|
||||
@ -140,7 +166,7 @@ bool Shell::ExecuteString(Handle<String> source,
|
||||
if (result.IsEmpty()) {
|
||||
ASSERT(try_catch.HasCaught());
|
||||
// Print errors that happened during execution.
|
||||
if (report_exceptions && !i::FLAG_debugger)
|
||||
if (report_exceptions && !FLAG_debugger)
|
||||
ReportException(&try_catch);
|
||||
return false;
|
||||
} else {
|
||||
@ -196,15 +222,20 @@ Handle<Value> Shell::Read(const Arguments& args) {
|
||||
|
||||
|
||||
Handle<Value> Shell::ReadLine(const Arguments& args) {
|
||||
i::SmartPointer<char> line(i::ReadLine(""));
|
||||
if (*line == NULL) {
|
||||
return Null();
|
||||
}
|
||||
size_t len = strlen(*line);
|
||||
if (len > 0 && line[len - 1] == '\n') {
|
||||
--len;
|
||||
}
|
||||
return String::New(*line, len);
|
||||
static const int kBufferSize = 256;
|
||||
char buffer[kBufferSize];
|
||||
Handle<String> accumulator = String::New("");
|
||||
bool linebreak;
|
||||
int length;
|
||||
do { // Repeat if the line ends with an escape '\'.
|
||||
// fgets got an error. Just give up.
|
||||
if (fgets(buffer, kBufferSize, stdin) == NULL) return Null();
|
||||
length = strlen(buffer);
|
||||
linebreak = (length > 1 && buffer[length-2] == '\\');
|
||||
if (linebreak) buffer[length-2] = '\n';
|
||||
accumulator = String::Concat(accumulator, String::New(buffer, length-1));
|
||||
} while (linebreak);
|
||||
return accumulator;
|
||||
}
|
||||
|
||||
|
||||
@ -236,6 +267,10 @@ Handle<Value> Shell::CreateExternalArray(const Arguments& args,
|
||||
return ThrowException(
|
||||
String::New("Array constructor needs one parameter."));
|
||||
}
|
||||
static const int kMaxLength = 0x3fffffff;
|
||||
#ifndef USING_V8_SHARED
|
||||
ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
|
||||
#endif // USING_V8_SHARED
|
||||
size_t length = 0;
|
||||
if (args[0]->IsUint32()) {
|
||||
length = args[0]->Uint32Value();
|
||||
@ -244,7 +279,7 @@ Handle<Value> Shell::CreateExternalArray(const Arguments& args,
|
||||
if (raw_length < 0) {
|
||||
return ThrowException(String::New("Array length must not be negative."));
|
||||
}
|
||||
if (raw_length > i::ExternalArray::kMaxLength) {
|
||||
if (raw_length > kMaxLength) {
|
||||
return ThrowException(
|
||||
String::New("Array length exceeds maximum length."));
|
||||
}
|
||||
@ -252,7 +287,7 @@ Handle<Value> Shell::CreateExternalArray(const Arguments& args,
|
||||
} else {
|
||||
return ThrowException(String::New("Array length must be a number."));
|
||||
}
|
||||
if (length > static_cast<size_t>(i::ExternalArray::kMaxLength)) {
|
||||
if (length > static_cast<size_t>(kMaxLength)) {
|
||||
return ThrowException(String::New("Array length exceeds maximum length."));
|
||||
}
|
||||
void* data = calloc(length, element_size);
|
||||
@ -332,7 +367,9 @@ Handle<Value> Shell::Yield(const Arguments& args) {
|
||||
|
||||
Handle<Value> Shell::Quit(const Arguments& args) {
|
||||
int exit_code = args[0]->Int32Value();
|
||||
#ifndef USING_V8_SHARED
|
||||
OnExit();
|
||||
#endif // USING_V8_SHARED
|
||||
exit(exit_code);
|
||||
return Undefined();
|
||||
}
|
||||
@ -381,6 +418,7 @@ void Shell::ReportException(v8::TryCatch* try_catch) {
|
||||
}
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
Handle<Array> Shell::GetCompletions(Handle<String> text, Handle<String> full) {
|
||||
HandleScope handle_scope;
|
||||
Context::Scope context_scope(utility_context_);
|
||||
@ -414,9 +452,11 @@ Handle<Value> Shell::DebugCommandToJSONRequest(Handle<String> command) {
|
||||
Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
|
||||
return val;
|
||||
}
|
||||
#endif
|
||||
#endif // ENABLE_DEBUGGER_SUPPORT
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
int32_t* Counter::Bind(const char* name, bool is_histogram) {
|
||||
int i;
|
||||
for (i = 0; i < kMaxNameSize - 1 && name[i]; i++)
|
||||
@ -448,8 +488,8 @@ Counter* CounterCollection::GetNextCounter() {
|
||||
|
||||
|
||||
void Shell::MapCounters(const char* name) {
|
||||
counters_file_ = i::OS::MemoryMappedFile::create(name,
|
||||
sizeof(CounterCollection), &local_counters_);
|
||||
counters_file_ = i::OS::MemoryMappedFile::create(
|
||||
name, sizeof(CounterCollection), &local_counters_);
|
||||
void* memory = (counters_file_ == NULL) ?
|
||||
NULL : counters_file_->memory();
|
||||
if (memory == NULL) {
|
||||
@ -514,6 +554,7 @@ void Shell::AddHistogramSample(void* histogram, int sample) {
|
||||
counter->AddSample(sample);
|
||||
}
|
||||
|
||||
|
||||
void Shell::InstallUtilityScript() {
|
||||
Locker lock;
|
||||
HandleScope scope;
|
||||
@ -532,7 +573,7 @@ void Shell::InstallUtilityScript() {
|
||||
utility_context_->Global()->Set(String::New("$debug"),
|
||||
Utils::ToLocal(js_debug));
|
||||
debug->debug_context()->set_security_token(HEAP->undefined_value());
|
||||
#endif
|
||||
#endif // ENABLE_DEBUGGER_SUPPORT
|
||||
|
||||
// Run the d8 shell utility script in the utility context
|
||||
int source_index = i::NativesCollection<i::D8>::GetIndex("d8");
|
||||
@ -550,10 +591,10 @@ void Shell::InstallUtilityScript() {
|
||||
// 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()));
|
||||
? 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
|
||||
@ -561,8 +602,9 @@ void Shell::InstallUtilityScript() {
|
||||
if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
|
||||
v8::Debug::SetDebugEventListener(HandleDebugEvent);
|
||||
}
|
||||
#endif
|
||||
#endif // ENABLE_DEBUGGER_SUPPORT
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
#ifdef COMPRESS_STARTUP_DATA_BZ2
|
||||
@ -629,9 +671,11 @@ Handle<ObjectTemplate> Shell::CreateGlobalTemplate() {
|
||||
global_template->Set(String::New("lol_is_enabled"), Boolean::New(false));
|
||||
#endif
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
Handle<ObjectTemplate> os_templ = ObjectTemplate::New();
|
||||
AddOSMethods(os_templ);
|
||||
global_template->Set(String::New("os"), os_templ);
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
return global_template;
|
||||
}
|
||||
@ -647,6 +691,7 @@ void Shell::Initialize() {
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
Shell::counter_map_ = new CounterMap();
|
||||
// Set up counters
|
||||
if (i::StrLength(i::FLAG_map_counters) != 0)
|
||||
@ -656,9 +701,10 @@ void Shell::Initialize() {
|
||||
V8::SetCreateHistogramFunction(CreateHistogram);
|
||||
V8::SetAddHistogramSampleFunction(AddHistogramSample);
|
||||
}
|
||||
|
||||
#endif // USING_V8_SHARED
|
||||
if (options.test_shell) return;
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
Locker lock;
|
||||
HandleScope scope;
|
||||
Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
|
||||
@ -669,18 +715,22 @@ void Shell::Initialize() {
|
||||
if (i::FLAG_debugger_agent) {
|
||||
v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);
|
||||
}
|
||||
#endif
|
||||
#endif // ENABLE_DEBUGGER_SUPPORT
|
||||
#endif // USING_V8_SHARED
|
||||
}
|
||||
|
||||
|
||||
Persistent<Context> Shell::CreateEvaluationContext() {
|
||||
#ifndef USING_V8_SHARED
|
||||
// This needs to be a critical section since this is not thread-safe
|
||||
i::ScopedLock lock(context_mutex_);
|
||||
#endif // USING_V8_SHARED
|
||||
// Initialize the global objects
|
||||
Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
|
||||
Persistent<Context> context = Context::New(NULL, global_template);
|
||||
Context::Scope scope(context);
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
i::JSArguments js_args = i::FLAG_js_arguments;
|
||||
i::Handle<i::FixedArray> arguments_array =
|
||||
FACTORY->NewFixedArray(js_args.argc());
|
||||
@ -692,11 +742,13 @@ Persistent<Context> Shell::CreateEvaluationContext() {
|
||||
i::Handle<i::JSArray> arguments_jsarray =
|
||||
FACTORY->NewJSArrayWithElements(arguments_array);
|
||||
context->Global()->Set(String::New("arguments"),
|
||||
Utils::ToLocal(arguments_jsarray));
|
||||
Utils::ToLocal(arguments_jsarray));
|
||||
#endif // USING_V8_SHARED
|
||||
return context;
|
||||
}
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
void Shell::OnExit() {
|
||||
if (i::FLAG_dump_counters) {
|
||||
printf("+----------------------------------------+-------------+\n");
|
||||
@ -716,12 +768,18 @@ void Shell::OnExit() {
|
||||
if (counters_file_ != NULL)
|
||||
delete counters_file_;
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
static char* ReadChars(const char* name, int* size_out) {
|
||||
// Release the V8 lock while reading files.
|
||||
v8::Unlocker unlocker(Isolate::GetCurrent());
|
||||
#ifndef USING_V8_SHARED
|
||||
FILE* file = i::OS::FOpen(name, "rb");
|
||||
#else
|
||||
// TODO(yangguo@chromium.org): reading from a directory hangs!
|
||||
FILE* file = fopen(name, "rb");
|
||||
#endif // USING_V8_SHARED
|
||||
if (file == NULL) return NULL;
|
||||
|
||||
fseek(file, 0, SEEK_END);
|
||||
@ -740,6 +798,7 @@ static char* ReadChars(const char* name, int* size_out) {
|
||||
}
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
static char* ReadToken(char* data, char token) {
|
||||
char* next = i::OS::StrChr(data, token);
|
||||
if (next != NULL) {
|
||||
@ -759,6 +818,7 @@ static char* ReadLine(char* data) {
|
||||
static char* ReadWord(char* data) {
|
||||
return ReadToken(data, ' ');
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
// Reads a file into a v8 string.
|
||||
@ -773,34 +833,44 @@ Handle<String> Shell::ReadFile(const char* name) {
|
||||
|
||||
|
||||
void Shell::RunShell() {
|
||||
Locker locker;
|
||||
Context::Scope context_scope(evaluation_context_);
|
||||
HandleScope handle_scope;
|
||||
Handle<String> name = String::New("(d8)");
|
||||
#ifndef USING_V8_SHARED
|
||||
LineEditor* editor = LineEditor::Get();
|
||||
printf("V8 version %s [console: %s]\n", V8::GetVersion(), editor->name());
|
||||
if (i::FLAG_debugger) {
|
||||
printf("JavaScript debugger enabled\n");
|
||||
}
|
||||
|
||||
editor->Open();
|
||||
while (true) {
|
||||
Locker locker;
|
||||
HandleScope handle_scope;
|
||||
Context::Scope context_scope(evaluation_context_);
|
||||
i::SmartPointer<char> input = editor->Prompt(Shell::kPrompt);
|
||||
if (input.is_empty())
|
||||
break;
|
||||
if (input.is_empty()) break;
|
||||
editor->AddHistory(*input);
|
||||
Handle<String> name = String::New("(d8)");
|
||||
ExecuteString(String::New(*input), name, true, true);
|
||||
}
|
||||
editor->Close();
|
||||
#else
|
||||
printf("V8 version %s [D8 light using shared library]\n", V8::GetVersion());
|
||||
static const int kBufferSize = 256;
|
||||
while (true) {
|
||||
char buffer[kBufferSize];
|
||||
printf("%s", Shell::kPrompt);
|
||||
if (fgets(buffer, kBufferSize, stdin) == NULL) break;
|
||||
ExecuteString(String::New(buffer), name, true, true);
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
class ShellThread : public i::Thread {
|
||||
public:
|
||||
ShellThread(int no, i::Vector<const char> files)
|
||||
: Thread("d8:ShellThread"),
|
||||
no_(no), files_(files) { }
|
||||
: Thread("d8:ShellThread"),
|
||||
no_(no), files_(files) { }
|
||||
virtual void Run();
|
||||
private:
|
||||
int no_;
|
||||
@ -848,6 +918,7 @@ void ShellThread::Run() {
|
||||
ptr = next_line;
|
||||
}
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
void SourceGroup::ExitShell(int exit_code) {
|
||||
@ -894,7 +965,12 @@ void SourceGroup::Execute() {
|
||||
|
||||
|
||||
Handle<String> SourceGroup::ReadFile(const char* name) {
|
||||
#ifndef USING_V8_SHARED
|
||||
FILE* file = i::OS::FOpen(name, "rb");
|
||||
#else
|
||||
// TODO(yangguo@chromium.org): reading from a directory hangs!
|
||||
FILE* file = fopen(name, "rb");
|
||||
#endif // USING_V8_SHARED
|
||||
if (file == NULL) return Handle<String>();
|
||||
|
||||
fseek(file, 0, SEEK_END);
|
||||
@ -914,6 +990,7 @@ Handle<String> SourceGroup::ReadFile(const char* name) {
|
||||
}
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
i::Thread::Options SourceGroup::GetThreadOptions() {
|
||||
i::Thread::Options options;
|
||||
options.name = "IsolateThread";
|
||||
@ -965,6 +1042,7 @@ void SourceGroup::WaitForThread() {
|
||||
done_semaphore_->Wait();
|
||||
}
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
@ -986,12 +1064,26 @@ bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
options.test_shell = true;
|
||||
argv[i] = NULL;
|
||||
} else if (strcmp(argv[i], "--preemption") == 0) {
|
||||
#ifdef USING_V8_SHARED
|
||||
printf("D8 with shared library does not support multi-threading\n");
|
||||
return false;
|
||||
#else
|
||||
options.use_preemption = true;
|
||||
argv[i] = NULL;
|
||||
#endif // USING_V8_SHARED
|
||||
} else if (strcmp(argv[i], "--no-preemption") == 0) {
|
||||
#ifdef USING_V8_SHARED
|
||||
printf("D8 with shared library does not support multi-threading\n");
|
||||
return false;
|
||||
#else
|
||||
options.use_preemption = false;
|
||||
argv[i] = NULL;
|
||||
#endif // USING_V8_SHARED
|
||||
} else if (strcmp(argv[i], "--preemption-interval") == 0) {
|
||||
#ifdef USING_V8_SHARED
|
||||
printf("D8 with shared library does not support multi-threading\n");
|
||||
return false;
|
||||
#else
|
||||
if (++i < argc) {
|
||||
argv[i-1] = NULL;
|
||||
char* end = NULL;
|
||||
@ -1007,15 +1099,33 @@ bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
printf("Missing value for --preemption-interval\n");
|
||||
return false;
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
} else if (strcmp(argv[i], "-f") == 0) {
|
||||
// Ignore any -f flags for compatibility with other stand-alone
|
||||
// JavaScript engines.
|
||||
continue;
|
||||
} else if (strcmp(argv[i], "--isolate") == 0) {
|
||||
#ifdef USING_V8_SHARED
|
||||
printf("D8 with shared library does not support multi-threading\n");
|
||||
return false;
|
||||
#endif // USING_V8_SHARED
|
||||
options.num_isolates++;
|
||||
}
|
||||
#ifdef USING_V8_SHARED
|
||||
else if (strcmp(argv[i], "--dump-counters") == 0) {
|
||||
printf("D8 with shared library does not include counters\n");
|
||||
return false;
|
||||
} else if (strcmp(argv[i], "-p") == 0) {
|
||||
printf("D8 with shared library does not support multi-threading\n");
|
||||
return false;
|
||||
} else if (strcmp(argv[i], "--debugger") == 0) {
|
||||
printf("Javascript debugger not included\n");
|
||||
return false;
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
}
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
// Run parallel threads if we are not using --isolate
|
||||
for (int i = 1; i < argc; i++) {
|
||||
if (argv[i] == NULL) continue;
|
||||
@ -1038,6 +1148,7 @@ bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
options.parallel_files->Add(i::Vector<const char>(files, size));
|
||||
}
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
|
||||
|
||||
@ -1062,21 +1173,21 @@ bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
|
||||
|
||||
int Shell::RunMain(int argc, char* argv[]) {
|
||||
#ifndef USING_V8_SHARED
|
||||
i::List<i::Thread*> threads(1);
|
||||
|
||||
{
|
||||
if (options.parallel_files != NULL)
|
||||
for (int i = 0; i < options.parallel_files->length(); i++) {
|
||||
i::Vector<const char> files = options.parallel_files->at(i);
|
||||
ShellThread* thread = new ShellThread(threads.length(), files);
|
||||
thread->Start();
|
||||
threads.Add(thread);
|
||||
}
|
||||
|
||||
for (int i = 1; i < options.num_isolates; ++i) {
|
||||
options.isolate_sources[i].StartExecuteInThread();
|
||||
if (options.parallel_files != NULL)
|
||||
for (int i = 0; i < options.parallel_files->length(); i++) {
|
||||
i::Vector<const char> files = options.parallel_files->at(i);
|
||||
ShellThread* thread = new ShellThread(threads.length(), files);
|
||||
thread->Start();
|
||||
threads.Add(thread);
|
||||
}
|
||||
|
||||
for (int i = 1; i < options.num_isolates; ++i) {
|
||||
options.isolate_sources[i].StartExecuteInThread();
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
{ // NOLINT
|
||||
Locker lock;
|
||||
HandleScope scope;
|
||||
Persistent<Context> context = CreateEvaluationContext();
|
||||
@ -1090,14 +1201,18 @@ int Shell::RunMain(int argc, char* argv[]) {
|
||||
} else {
|
||||
context.Dispose();
|
||||
}
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
// Start preemption if threads have been created and preemption is enabled.
|
||||
if (options.parallel_files != NULL
|
||||
&& threads.length() > 0
|
||||
&& options.use_preemption) {
|
||||
Locker::StartPreemption(options.preemption_interval);
|
||||
}
|
||||
#endif // USING_V8_SHARED
|
||||
}
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
for (int i = 1; i < options.num_isolates; ++i) {
|
||||
options.isolate_sources[i].WaitForThread();
|
||||
}
|
||||
@ -1110,6 +1225,7 @@ int Shell::RunMain(int argc, char* argv[]) {
|
||||
}
|
||||
|
||||
OnExit();
|
||||
#endif // USING_V8_SHARED
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1136,14 +1252,15 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
result = RunMain(argc, argv);
|
||||
}
|
||||
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT
|
||||
|
||||
#if !defined(USING_V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
|
||||
// Run remote debugger if requested, but never on --test
|
||||
if (i::FLAG_remote_debugger && !options.test_shell) {
|
||||
InstallUtilityScript();
|
||||
RunRemoteDebugger(i::FLAG_debugger_port);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
#endif // !USING_V8_SHARED && ENABLE_DEBUGGER_SUPPORT
|
||||
|
||||
// Run interactive shell if explicitly requested or if no script has been
|
||||
// executed, but never on --test
|
||||
@ -1151,7 +1268,9 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
if (( options.interactive_shell
|
||||
|| !options.script_executed )
|
||||
&& !options.test_shell ) {
|
||||
#ifndef USING_V8_SHARED
|
||||
InstallUtilityScript();
|
||||
#endif // USING_V8_SHARED
|
||||
RunShell();
|
||||
}
|
||||
|
||||
|
||||
24
src/d8.gyp
24
src/d8.gyp
@ -31,7 +31,6 @@
|
||||
'target_name': 'd8',
|
||||
'type': 'executable',
|
||||
'dependencies': [
|
||||
'd8_js2c#host',
|
||||
'../tools/gyp/v8.gyp:v8',
|
||||
],
|
||||
'include_dirs+': [
|
||||
@ -42,15 +41,24 @@
|
||||
],
|
||||
'sources': [
|
||||
'd8.cc',
|
||||
'd8-debug.cc',
|
||||
'<(SHARED_INTERMEDIATE_DIR)/d8-js.cc',
|
||||
],
|
||||
'conditions': [
|
||||
[ 'OS=="linux" or OS=="mac" or OS=="freebsd" or OS=="openbsd" or OS=="solaris"', {
|
||||
'sources': [ 'd8-posix.cc', ]
|
||||
}],
|
||||
[ 'OS=="win"', {
|
||||
'sources': [ 'd8-windows.cc', ]
|
||||
[ 'component!="shared_library"', {
|
||||
'dependencies': [ 'd8_js2c#host', ],
|
||||
'sources': [ 'd8-debug.cc', '<(SHARED_INTERMEDIATE_DIR)/d8-js.cc', ],
|
||||
'conditions': [
|
||||
[ 'console=="readline"', {
|
||||
'libraries': [ '-lreadline', ],
|
||||
'sources': [ 'd8-readline.cc' ],
|
||||
}],
|
||||
[ '(OS=="linux" or OS=="mac" or OS=="freebsd" \
|
||||
or OS=="openbsd" or OS=="solaris")', {
|
||||
'sources': [ 'd8-posix.cc', ]
|
||||
}],
|
||||
[ 'OS=="win"', {
|
||||
'sources': [ 'd8-windows.cc', ]
|
||||
}],
|
||||
],
|
||||
}],
|
||||
],
|
||||
},
|
||||
|
||||
109
src/d8.h
109
src/d8.h
@ -28,16 +28,23 @@
|
||||
#ifndef V8_D8_H_
|
||||
#define V8_D8_H_
|
||||
|
||||
#include "allocation.h"
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
#include "v8.h"
|
||||
#include "allocation.h"
|
||||
#include "hashmap.h"
|
||||
#else
|
||||
#include "../include/v8.h"
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
namespace v8 {
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
namespace i = v8::internal;
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
// A single counter in a counter collection.
|
||||
class Counter {
|
||||
public:
|
||||
@ -110,17 +117,20 @@ class CounterMap {
|
||||
static bool Match(void* key1, void* key2);
|
||||
i::HashMap hash_map_;
|
||||
};
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
class SourceGroup {
|
||||
public:
|
||||
SourceGroup()
|
||||
: next_semaphore_(v8::internal::OS::CreateSemaphore(0)),
|
||||
done_semaphore_(v8::internal::OS::CreateSemaphore(0)),
|
||||
thread_(NULL),
|
||||
argv_(NULL),
|
||||
begin_offset_(0),
|
||||
end_offset_(0) { }
|
||||
SourceGroup() :
|
||||
#ifndef USING_V8_SHARED
|
||||
next_semaphore_(v8::internal::OS::CreateSemaphore(0)),
|
||||
done_semaphore_(v8::internal::OS::CreateSemaphore(0)),
|
||||
thread_(NULL),
|
||||
#endif // USING_V8_SHARED
|
||||
argv_(NULL),
|
||||
begin_offset_(0),
|
||||
end_offset_(0) { }
|
||||
|
||||
void Begin(char** argv, int offset) {
|
||||
argv_ = const_cast<const char**>(argv);
|
||||
@ -131,6 +141,7 @@ class SourceGroup {
|
||||
|
||||
void Execute();
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
void StartExecuteInThread();
|
||||
void WaitForThread();
|
||||
|
||||
@ -154,6 +165,7 @@ class SourceGroup {
|
||||
i::Semaphore* next_semaphore_;
|
||||
i::Semaphore* done_semaphore_;
|
||||
i::Thread* thread_;
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
void ExitShell(int exit_code);
|
||||
Handle<String> ReadFile(const char* name);
|
||||
@ -166,34 +178,41 @@ class SourceGroup {
|
||||
|
||||
class ShellOptions {
|
||||
public:
|
||||
ShellOptions()
|
||||
: script_executed(false),
|
||||
last_run(true),
|
||||
stress_opt(false),
|
||||
stress_deopt(false),
|
||||
interactive_shell(false),
|
||||
test_shell(false),
|
||||
use_preemption(true),
|
||||
preemption_interval(10),
|
||||
num_isolates(1),
|
||||
isolate_sources(NULL),
|
||||
parallel_files(NULL) { }
|
||||
ShellOptions() :
|
||||
#ifndef USING_V8_SHARED
|
||||
use_preemption(true),
|
||||
preemption_interval(10),
|
||||
parallel_files(NULL),
|
||||
#endif // USING_V8_SHARED
|
||||
script_executed(false),
|
||||
last_run(true),
|
||||
stress_opt(false),
|
||||
stress_deopt(false),
|
||||
interactive_shell(false),
|
||||
test_shell(false),
|
||||
num_isolates(1),
|
||||
isolate_sources(NULL) { }
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
bool use_preemption;
|
||||
int preemption_interval;
|
||||
i::List< i::Vector<const char> >* parallel_files;
|
||||
#endif // USING_V8_SHARED
|
||||
bool script_executed;
|
||||
bool last_run;
|
||||
bool stress_opt;
|
||||
bool stress_deopt;
|
||||
bool interactive_shell;
|
||||
bool test_shell;
|
||||
bool use_preemption;
|
||||
int preemption_interval;
|
||||
int num_isolates;
|
||||
SourceGroup* isolate_sources;
|
||||
i::List< i::Vector<const char> >* parallel_files;
|
||||
};
|
||||
|
||||
|
||||
class Shell: public i::AllStatic {
|
||||
#ifdef USING_V8_SHARED
|
||||
class Shell {
|
||||
#else
|
||||
class Shell : public i::AllStatic {
|
||||
#endif // USING_V8_SHARED
|
||||
public:
|
||||
static bool ExecuteString(Handle<String> source,
|
||||
Handle<Value> name,
|
||||
@ -201,6 +220,14 @@ class Shell: public i::AllStatic {
|
||||
bool report_exceptions);
|
||||
static const char* ToCString(const v8::String::Utf8Value& value);
|
||||
static void ReportException(TryCatch* try_catch);
|
||||
static Handle<String> ReadFile(const char* name);
|
||||
static Persistent<Context> CreateEvaluationContext();
|
||||
static int RunMain(int argc, char* argv[]);
|
||||
static int Main(int argc, char* argv[]);
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
static Handle<Array> GetCompletions(Handle<String> text,
|
||||
Handle<String> full);
|
||||
static void OnExit();
|
||||
static int* LookupCounter(const char* name);
|
||||
static void* CreateHistogram(const char* name,
|
||||
@ -209,18 +236,8 @@ class Shell: public i::AllStatic {
|
||||
size_t buckets);
|
||||
static void AddHistogramSample(void* histogram, int sample);
|
||||
static void MapCounters(const char* name);
|
||||
static Handle<String> ReadFile(const char* name);
|
||||
static void Initialize();
|
||||
static Persistent<Context> CreateEvaluationContext();
|
||||
static void InstallUtilityScript();
|
||||
static void RunShell();
|
||||
static bool SetOptions(int argc, char* argv[]);
|
||||
static int RunScript(char* filename);
|
||||
static int RunMain(int argc, char* argv[]);
|
||||
static int Main(int argc, char* argv[]);
|
||||
static Handle<ObjectTemplate> CreateGlobalTemplate();
|
||||
static Handle<Array> GetCompletions(Handle<String> text,
|
||||
Handle<String> full);
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT
|
||||
static Handle<Object> DebugMessageDetails(Handle<String> message);
|
||||
static Handle<Value> DebugCommandToJSONRequest(Handle<String> command);
|
||||
@ -283,15 +300,16 @@ class Shell: public i::AllStatic {
|
||||
static Handle<Value> RemoveDirectory(const Arguments& args);
|
||||
|
||||
static void AddOSMethods(Handle<ObjectTemplate> os_template);
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
static const char* kHistoryFileName;
|
||||
#endif // USING_V8_SHARED
|
||||
static const char* kPrompt;
|
||||
|
||||
static ShellOptions options;
|
||||
|
||||
private:
|
||||
static Persistent<Context> utility_context_;
|
||||
static Persistent<Context> evaluation_context_;
|
||||
#ifndef USING_V8_SHARED
|
||||
static Persistent<Context> utility_context_;
|
||||
static CounterMap* counter_map_;
|
||||
// We statically allocate a set of local counters to be used if we
|
||||
// don't want to store the stats in a memory-mapped file
|
||||
@ -299,7 +317,14 @@ class Shell: public i::AllStatic {
|
||||
static CounterCollection* counters_;
|
||||
static i::OS::MemoryMappedFile* counters_file_;
|
||||
static i::Mutex* context_mutex_;
|
||||
|
||||
static Counter* GetCounter(const char* name, bool is_histogram);
|
||||
static void InstallUtilityScript();
|
||||
#endif // USING_V8_SHARED
|
||||
static void Initialize();
|
||||
static void RunShell();
|
||||
static bool SetOptions(int argc, char* argv[]);
|
||||
static Handle<ObjectTemplate> CreateGlobalTemplate();
|
||||
static Handle<Value> CreateExternalArray(const Arguments& args,
|
||||
ExternalArrayType type,
|
||||
size_t element_size);
|
||||
@ -307,6 +332,7 @@ class Shell: public i::AllStatic {
|
||||
};
|
||||
|
||||
|
||||
#ifndef USING_V8_SHARED
|
||||
class LineEditor {
|
||||
public:
|
||||
enum Type { DUMB = 0, READLINE = 1 };
|
||||
@ -326,6 +352,7 @@ class LineEditor {
|
||||
LineEditor* next_;
|
||||
static LineEditor* first_;
|
||||
};
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
|
||||
} // namespace v8
|
||||
|
||||
Loading…
Reference in New Issue
Block a user