// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#ifdef V8_SHARED
-#define USING_V8_SHARED
+#ifdef USING_V8_SHARED // Defined when linking against shared lib on Windows.
+#define V8_SHARED
#endif
#ifdef COMPRESS_STARTUP_DATA_BZ2
#include <errno.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/stat.h>
-#ifdef USING_V8_SHARED
+#ifdef V8_SHARED
#include <assert.h>
#include "../include/v8-testing.h"
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
#include "d8.h"
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
#include "api.h"
#include "checks.h"
#include "d8-debug.h"
#include "natives.h"
#include "platform.h"
#include "v8.h"
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
#if !defined(_WIN32) && !defined(_WIN64)
#include <unistd.h> // NOLINT
#endif
-#ifdef USING_V8_SHARED
+#ifndef ASSERT
#define ASSERT(condition) assert(condition)
-#endif // USING_V8_SHARED
+#endif
namespace v8 {
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
LineEditor *LineEditor::first_ = NULL;
const char* Shell::kHistoryFileName = ".d8_history";
CounterCollection* Shell::counters_ = &local_counters_;
i::Mutex* Shell::context_mutex_(i::OS::CreateMutex());
Persistent<Context> Shell::utility_context_;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
Persistent<Context> Shell::evaluation_context_;
ShellOptions Shell::options;
const char* Shell::kPrompt = "d8> ";
-#ifndef USING_V8_SHARED
+#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 // USING_V8_SHARED
+#endif // V8_SHARED
// Converts a V8 value to a C string.
Handle<Value> name,
bool print_result,
bool report_exceptions) {
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
bool FLAG_debugger = i::FLAG_debugger;
#else
bool FLAG_debugger = false;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
HandleScope handle_scope;
TryCatch try_catch;
options.script_executed = true;
String::New("Array constructor needs one parameter."));
}
static const int kMaxLength = 0x3fffffff;
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
size_t length = 0;
if (args[0]->IsUint32()) {
length = args[0]->Uint32Value();
Handle<Value> Shell::Quit(const Arguments& args) {
int exit_code = args[0]->Int32Value();
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
OnExit();
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
exit(exit_code);
return Undefined();
}
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
Handle<Array> Shell::GetCompletions(Handle<String> text, Handle<String> full) {
HandleScope handle_scope;
Context::Scope context_scope(utility_context_);
return val;
}
#endif // ENABLE_DEBUGGER_SUPPORT
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
-#ifndef USING_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++)
}
#endif // ENABLE_DEBUGGER_SUPPORT
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
#ifdef COMPRESS_STARTUP_DATA_BZ2
global_template->Set(String::New("lol_is_enabled"), Boolean::New(false));
#endif
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
Handle<ObjectTemplate> os_templ = ObjectTemplate::New();
AddOSMethods(os_templ);
global_template->Set(String::New("os"), os_templ);
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
return global_template;
}
}
#endif
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
Shell::counter_map_ = new CounterMap();
// Set up counters
if (i::StrLength(i::FLAG_map_counters) != 0)
V8::SetCreateHistogramFunction(CreateHistogram);
V8::SetAddHistogramSampleFunction(AddHistogramSample);
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
if (options.test_shell) return;
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
Locker lock;
HandleScope scope;
Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);
}
#endif // ENABLE_DEBUGGER_SUPPORT
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
}
Persistent<Context> Shell::CreateEvaluationContext() {
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
// This needs to be a critical section since this is not thread-safe
i::ScopedLock lock(context_mutex_);
-#endif // USING_V8_SHARED
+#endif // 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
+#ifndef V8_SHARED
i::JSArguments js_args = i::FLAG_js_arguments;
i::Handle<i::FixedArray> arguments_array =
FACTORY->NewFixedArray(js_args.argc());
FACTORY->NewJSArrayWithElements(arguments_array);
context->Global()->Set(String::New("arguments"),
Utils::ToLocal(arguments_jsarray));
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
return context;
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
void Shell::OnExit() {
if (i::FLAG_dump_counters) {
printf("+----------------------------------------+-------------+\n");
if (counters_file_ != NULL)
delete counters_file_;
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
+
+
+static FILE* FOpen(const char* path, const char* mode) {
+#if (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(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
+ FILE* file = FOpen(name, "rb");
if (file == NULL) return NULL;
fseek(file, 0, SEEK_END);
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
static char* ReadToken(char* data, char token) {
char* next = i::OS::StrChr(data, token);
if (next != NULL) {
static char* ReadWord(char* data) {
return ReadToken(data, ' ');
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
// Reads a file into a v8 string.
Context::Scope context_scope(evaluation_context_);
HandleScope handle_scope;
Handle<String> name = String::New("(d8)");
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
LineEditor* editor = LineEditor::Get();
printf("V8 version %s [console: %s]\n", V8::GetVersion(), editor->name());
if (i::FLAG_debugger) {
if (fgets(buffer, kBufferSize, stdin) == NULL) break;
ExecuteString(String::New(buffer), name, true, true);
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
printf("\n");
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
class ShellThread : public i::Thread {
public:
ShellThread(int no, i::Vector<const char> files)
ptr = next_line;
}
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
void SourceGroup::ExitShell(int exit_code) {
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);
- 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);
+ int size;
+ const char* chars = ReadChars(name, &size);
+ if (chars == NULL) return Handle<String>();
Handle<String> result = String::New(chars, size);
delete[] chars;
return result;
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
i::Thread::Options SourceGroup::GetThreadOptions() {
i::Thread::Options options;
options.name = "IsolateThread";
done_semaphore_->Wait();
}
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
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
+#ifdef 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
+#endif // V8_SHARED
} else if (strcmp(argv[i], "--no-preemption") == 0) {
-#ifdef USING_V8_SHARED
+#ifdef 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
+#endif // V8_SHARED
} else if (strcmp(argv[i], "--preemption-interval") == 0) {
-#ifdef USING_V8_SHARED
+#ifdef V8_SHARED
printf("D8 with shared library does not support multi-threading\n");
return false;
#else
printf("Missing value for --preemption-interval\n");
return false;
}
-#endif // USING_V8_SHARED
+#endif // 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
+#ifdef V8_SHARED
printf("D8 with shared library does not support multi-threading\n");
return false;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
options.num_isolates++;
}
-#ifdef USING_V8_SHARED
+#ifdef V8_SHARED
else if (strcmp(argv[i], "--dump-counters") == 0) {
printf("D8 with shared library does not include counters\n");
return false;
printf("Javascript debugger not included\n");
return false;
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
// Run parallel threads if we are not using --isolate
for (int i = 1; i < argc; i++) {
if (argv[i] == NULL) continue;
}
argv[i] = NULL;
options.parallel_files->Add(i::Vector<const char>(files, size));
+ delete[] files;
}
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
int Shell::RunMain(int argc, char* argv[]) {
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
i::List<i::Thread*> threads(1);
if (options.parallel_files != NULL)
for (int i = 0; i < options.parallel_files->length(); i++) {
for (int i = 1; i < options.num_isolates; ++i) {
options.isolate_sources[i].StartExecuteInThread();
}
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
{ // NOLINT
Locker lock;
HandleScope scope;
context.Dispose();
}
-#ifndef USING_V8_SHARED
+#ifndef 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
+#endif // V8_SHARED
}
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
for (int i = 1; i < options.num_isolates; ++i) {
options.isolate_sources[i].WaitForThread();
}
}
OnExit();
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
return 0;
}
}
-#if !defined(USING_V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
+#if !defined(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 // !USING_V8_SHARED && ENABLE_DEBUGGER_SUPPORT
+#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
// Run interactive shell if explicitly requested or if no script has been
// executed, but never on --test
if (( options.interactive_shell
|| !options.script_executed )
&& !options.test_shell ) {
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
InstallUtilityScript();
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
RunShell();
}
#define V8_D8_H_
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
#include "v8.h"
#include "allocation.h"
#include "hashmap.h"
#else
#include "../include/v8.h"
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
namespace v8 {
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
namespace i = v8::internal;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
// A single counter in a counter collection.
class Counter {
public:
static bool Match(void* key1, void* key2);
i::HashMap hash_map_;
};
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
class SourceGroup {
public:
SourceGroup() :
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
next_semaphore_(v8::internal::OS::CreateSemaphore(0)),
done_semaphore_(v8::internal::OS::CreateSemaphore(0)),
thread_(NULL),
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
argv_(NULL),
begin_offset_(0),
end_offset_(0) { }
void Execute();
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
void StartExecuteInThread();
void WaitForThread();
i::Semaphore* next_semaphore_;
i::Semaphore* done_semaphore_;
i::Thread* thread_;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
void ExitShell(int exit_code);
Handle<String> ReadFile(const char* name);
class ShellOptions {
public:
ShellOptions() :
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
use_preemption(true),
preemption_interval(10),
parallel_files(NULL),
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
script_executed(false),
last_run(true),
stress_opt(false),
num_isolates(1),
isolate_sources(NULL) { }
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
bool use_preemption;
int preemption_interval;
i::List< i::Vector<const char> >* parallel_files;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
bool script_executed;
bool last_run;
bool stress_opt;
SourceGroup* isolate_sources;
};
-#ifdef USING_V8_SHARED
+#ifdef V8_SHARED
class Shell {
#else
class Shell : public i::AllStatic {
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
public:
static bool ExecuteString(Handle<String> source,
Handle<Value> name,
static int RunMain(int argc, char* argv[]);
static int Main(int argc, char* argv[]);
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
static Handle<Array> GetCompletions(Handle<String> text,
Handle<String> full);
static void OnExit();
size_t buckets);
static void AddHistogramSample(void* histogram, int sample);
static void MapCounters(const char* name);
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
#ifdef ENABLE_DEBUGGER_SUPPORT
static Handle<Object> DebugMessageDetails(Handle<String> message);
static Handle<Value> RemoveDirectory(const Arguments& args);
static void AddOSMethods(Handle<ObjectTemplate> os_template);
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
static const char* kHistoryFileName;
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
static const char* kPrompt;
static ShellOptions options;
private:
static Persistent<Context> evaluation_context_;
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
static Persistent<Context> utility_context_;
static CounterMap* counter_map_;
// We statically allocate a set of local counters to be used if we
static Counter* GetCounter(const char* name, bool is_histogram);
static void InstallUtilityScript();
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
static void Initialize();
static void RunShell();
static bool SetOptions(int argc, char* argv[]);
};
-#ifndef USING_V8_SHARED
+#ifndef V8_SHARED
class LineEditor {
public:
enum Type { DUMB = 0, READLINE = 1 };
LineEditor* next_;
static LineEditor* first_;
};
-#endif // USING_V8_SHARED
+#endif // V8_SHARED
} // namespace v8