diff options
author | Steve Block <steveblock@google.com> | 2009-10-30 11:49:00 +0000 |
---|---|---|
committer | Steve Block <steveblock@google.com> | 2009-11-03 17:23:38 +0000 |
commit | a7e24c173cf37484693b9abb38e494fa7bd7baeb (patch) | |
tree | 4aeefe31292fbed0d94f1b93fe86c51849b001c2 /samples | |
parent | af654c46444383e0baed1cb27a4c1d1bdcac8dd9 (diff) | |
download | v8-a7e24c173cf37484693b9abb38e494fa7bd7baeb.tar.gz |
Move V8 to external/v8
Change-Id: If68025d67453785a651c5dfb34fad298c16676a4
Diffstat (limited to 'samples')
-rw-r--r-- | samples/SConscript | 38 | ||||
-rw-r--r-- | samples/count-hosts.js | 42 | ||||
-rw-r--r-- | samples/process.cc | 622 | ||||
-rw-r--r-- | samples/shell.cc | 303 |
4 files changed, 1005 insertions, 0 deletions
diff --git a/samples/SConscript b/samples/SConscript new file mode 100644 index 00000000..31990b68 --- /dev/null +++ b/samples/SConscript @@ -0,0 +1,38 @@ +# Copyright 2008 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. + +from os.path import join +Import('sample context') + +def ConfigureObjectFiles(): + env = Environment() + env.Replace(**context.flags['sample']) + context.ApplyEnvOverrides(env) + return env.Object(sample + '.cc') + +sample_object = ConfigureObjectFiles() +Return('sample_object') diff --git a/samples/count-hosts.js b/samples/count-hosts.js new file mode 100644 index 00000000..bea6553d --- /dev/null +++ b/samples/count-hosts.js @@ -0,0 +1,42 @@ +// Copyright 2008 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. + +function Initialize() { } + +function Process(request) { + if (options.verbose) { + log("Processing " + request.host + request.path + + " from " + request.referrer + "@" + request.userAgent); + } + if (!output[request.host]) { + output[request.host] = 1; + } else { + output[request.host]++ + } +} + +Initialize(); diff --git a/samples/process.cc b/samples/process.cc new file mode 100644 index 00000000..511e21a0 --- /dev/null +++ b/samples/process.cc @@ -0,0 +1,622 @@ +// Copyright 2008 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. + +#include <v8.h> + +#include <string> +#include <map> + +using namespace std; +using namespace v8; + +// These interfaces represent an existing request processing interface. +// The idea is to imagine a real application that uses these interfaces +// and then add scripting capabilities that allow you to interact with +// the objects through JavaScript. + +/** + * A simplified http request. + */ +class HttpRequest { + public: + virtual ~HttpRequest() { } + virtual const string& Path() = 0; + virtual const string& Referrer() = 0; + virtual const string& Host() = 0; + virtual const string& UserAgent() = 0; +}; + +/** + * The abstract superclass of http request processors. + */ +class HttpRequestProcessor { + public: + virtual ~HttpRequestProcessor() { } + + // Initialize this processor. The map contains options that control + // how requests should be processed. + virtual bool Initialize(map<string, string>* options, + map<string, string>* output) = 0; + + // Process a single request. + virtual bool Process(HttpRequest* req) = 0; + + static void Log(const char* event); +}; + +/** + * An http request processor that is scriptable using JavaScript. + */ +class JsHttpRequestProcessor : public HttpRequestProcessor { + public: + + // Creates a new processor that processes requests by invoking the + // Process function of the JavaScript script given as an argument. + explicit JsHttpRequestProcessor(Handle<String> script) : script_(script) { } + virtual ~JsHttpRequestProcessor(); + + virtual bool Initialize(map<string, string>* opts, + map<string, string>* output); + virtual bool Process(HttpRequest* req); + + private: + + // Execute the script associated with this processor and extract the + // Process function. Returns true if this succeeded, otherwise false. + bool ExecuteScript(Handle<String> script); + + // Wrap the options and output map in a JavaScript objects and + // install it in the global namespace as 'options' and 'output'. + bool InstallMaps(map<string, string>* opts, map<string, string>* output); + + // Constructs the template that describes the JavaScript wrapper + // type for requests. + static Handle<ObjectTemplate> MakeRequestTemplate(); + static Handle<ObjectTemplate> MakeMapTemplate(); + + // Callbacks that access the individual fields of request objects. + static Handle<Value> GetPath(Local<String> name, const AccessorInfo& info); + static Handle<Value> GetReferrer(Local<String> name, + const AccessorInfo& info); + static Handle<Value> GetHost(Local<String> name, const AccessorInfo& info); + static Handle<Value> GetUserAgent(Local<String> name, + const AccessorInfo& info); + + // Callbacks that access maps + static Handle<Value> MapGet(Local<String> name, const AccessorInfo& info); + static Handle<Value> MapSet(Local<String> name, + Local<Value> value, + const AccessorInfo& info); + + // Utility methods for wrapping C++ objects as JavaScript objects, + // and going back again. + static Handle<Object> WrapMap(map<string, string>* obj); + static map<string, string>* UnwrapMap(Handle<Object> obj); + static Handle<Object> WrapRequest(HttpRequest* obj); + static HttpRequest* UnwrapRequest(Handle<Object> obj); + + Handle<String> script_; + Persistent<Context> context_; + Persistent<Function> process_; + static Persistent<ObjectTemplate> request_template_; + static Persistent<ObjectTemplate> map_template_; +}; + +// ------------------------- +// --- P r o c e s s o r --- +// ------------------------- + + +static Handle<Value> LogCallback(const Arguments& args) { + if (args.Length() < 1) return v8::Undefined(); + HandleScope scope; + Handle<Value> arg = args[0]; + String::Utf8Value value(arg); + HttpRequestProcessor::Log(*value); + return v8::Undefined(); +} + + +// Execute the script and fetch the Process method. +bool JsHttpRequestProcessor::Initialize(map<string, string>* opts, + map<string, string>* output) { + // Create a handle scope to hold the temporary references. + HandleScope handle_scope; + + // Create a template for the global object where we set the + // built-in global functions. + Handle<ObjectTemplate> global = ObjectTemplate::New(); + global->Set(String::New("log"), FunctionTemplate::New(LogCallback)); + + // Each processor gets its own context so different processors + // don't affect each other (ignore the first three lines). + Handle<Context> context = Context::New(NULL, global); + + // Store the context in the processor object in a persistent handle, + // since we want the reference to remain after we return from this + // method. + context_ = Persistent<Context>::New(context); + + // Enter the new context so all the following operations take place + // within it. + Context::Scope context_scope(context); + + // Make the options mapping available within the context + if (!InstallMaps(opts, output)) + return false; + + // Compile and run the script + if (!ExecuteScript(script_)) + return false; + + // The script compiled and ran correctly. Now we fetch out the + // Process function from the global object. + Handle<String> process_name = String::New("Process"); + Handle<Value> process_val = context->Global()->Get(process_name); + + // If there is no Process function, or if it is not a function, + // bail out + if (!process_val->IsFunction()) return false; + + // It is a function; cast it to a Function + Handle<Function> process_fun = Handle<Function>::Cast(process_val); + + // Store the function in a Persistent handle, since we also want + // that to remain after this call returns + process_ = Persistent<Function>::New(process_fun); + + // All done; all went well + return true; +} + + +bool JsHttpRequestProcessor::ExecuteScript(Handle<String> script) { + HandleScope handle_scope; + + // We're just about to compile the script; set up an error handler to + // catch any exceptions the script might throw. + TryCatch try_catch; + + // Compile the script and check for errors. + Handle<Script> compiled_script = Script::Compile(script); + if (compiled_script.IsEmpty()) { + String::Utf8Value error(try_catch.Exception()); + Log(*error); + // The script failed to compile; bail out. + return false; + } + + // Run the script! + Handle<Value> result = compiled_script->Run(); + if (result.IsEmpty()) { + // The TryCatch above is still in effect and will have caught the error. + String::Utf8Value error(try_catch.Exception()); + Log(*error); + // Running the script failed; bail out. + return false; + } + return true; +} + + +bool JsHttpRequestProcessor::InstallMaps(map<string, string>* opts, + map<string, string>* output) { + HandleScope handle_scope; + + // Wrap the map object in a JavaScript wrapper + Handle<Object> opts_obj = WrapMap(opts); + + // Set the options object as a property on the global object. + context_->Global()->Set(String::New("options"), opts_obj); + + Handle<Object> output_obj = WrapMap(output); + context_->Global()->Set(String::New("output"), output_obj); + + return true; +} + + +bool JsHttpRequestProcessor::Process(HttpRequest* request) { + // Create a handle scope to keep the temporary object references. + HandleScope handle_scope; + + // Enter this processor's context so all the remaining operations + // take place there + Context::Scope context_scope(context_); + + // Wrap the C++ request object in a JavaScript wrapper + Handle<Object> request_obj = WrapRequest(request); + + // Set up an exception handler before calling the Process function + TryCatch try_catch; + + // Invoke the process function, giving the global object as 'this' + // and one argument, the request. + const int argc = 1; + Handle<Value> argv[argc] = { request_obj }; + Handle<Value> result = process_->Call(context_->Global(), argc, argv); + if (result.IsEmpty()) { + String::Utf8Value error(try_catch.Exception()); + Log(*error); + return false; + } else { + return true; + } +} + + +JsHttpRequestProcessor::~JsHttpRequestProcessor() { + // Dispose the persistent handles. When noone else has any + // references to the objects stored in the handles they will be + // automatically reclaimed. + context_.Dispose(); + process_.Dispose(); +} + + +Persistent<ObjectTemplate> JsHttpRequestProcessor::request_template_; +Persistent<ObjectTemplate> JsHttpRequestProcessor::map_template_; + + +// ----------------------------------- +// --- A c c e s s i n g M a p s --- +// ----------------------------------- + +// Utility function that wraps a C++ http request object in a +// JavaScript object. +Handle<Object> JsHttpRequestProcessor::WrapMap(map<string, string>* obj) { + // Handle scope for temporary handles. + HandleScope handle_scope; + + // Fetch the template for creating JavaScript map wrappers. + // It only has to be created once, which we do on demand. + if (request_template_.IsEmpty()) { + Handle<ObjectTemplate> raw_template = MakeMapTemplate(); + map_template_ = Persistent<ObjectTemplate>::New(raw_template); + } + Handle<ObjectTemplate> templ = map_template_; + + // Create an empty map wrapper. + Handle<Object> result = templ->NewInstance(); + + // Wrap the raw C++ pointer in an External so it can be referenced + // from within JavaScript. + Handle<External> map_ptr = External::New(obj); + + // Store the map pointer in the JavaScript wrapper. + result->SetInternalField(0, map_ptr); + + // Return the result through the current handle scope. Since each + // of these handles will go away when the handle scope is deleted + // we need to call Close to let one, the result, escape into the + // outer handle scope. + return handle_scope.Close(result); +} + + +// Utility function that extracts the C++ map pointer from a wrapper +// object. +map<string, string>* JsHttpRequestProcessor::UnwrapMap(Handle<Object> obj) { + Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0)); + void* ptr = field->Value(); + return static_cast<map<string, string>*>(ptr); +} + + +// Convert a JavaScript string to a std::string. To not bother too +// much with string encodings we just use ascii. +string ObjectToString(Local<Value> value) { + String::Utf8Value utf8_value(value); + return string(*utf8_value); +} + + +Handle<Value> JsHttpRequestProcessor::MapGet(Local<String> name, + const AccessorInfo& info) { + // Fetch the map wrapped by this object. + map<string, string>* obj = UnwrapMap(info.Holder()); + + // Convert the JavaScript string to a std::string. + string key = ObjectToString(name); + + // Look up the value if it exists using the standard STL ideom. + map<string, string>::iterator iter = obj->find(key); + + // If the key is not present return an empty handle as signal + if (iter == obj->end()) return Handle<Value>(); + + // Otherwise fetch the value and wrap it in a JavaScript string + const string& value = (*iter).second; + return String::New(value.c_str(), value.length()); +} + + +Handle<Value> JsHttpRequestProcessor::MapSet(Local<String> name, + Local<Value> value_obj, + const AccessorInfo& info) { + // Fetch the map wrapped by this object. + map<string, string>* obj = UnwrapMap(info.Holder()); + + // Convert the key and value to std::strings. + string key = ObjectToString(name); + string value = ObjectToString(value_obj); + + // Update the map. + (*obj)[key] = value; + + // Return the value; any non-empty handle will work. + return value_obj; +} + + +Handle<ObjectTemplate> JsHttpRequestProcessor::MakeMapTemplate() { + HandleScope handle_scope; + + Handle<ObjectTemplate> result = ObjectTemplate::New(); + result->SetInternalFieldCount(1); + result->SetNamedPropertyHandler(MapGet, MapSet); + + // Again, return the result through the current handle scope. + return handle_scope.Close(result); +} + + +// ------------------------------------------- +// --- A c c e s s i n g R e q u e s t s --- +// ------------------------------------------- + +/** + * Utility function that wraps a C++ http request object in a + * JavaScript object. + */ +Handle<Object> JsHttpRequestProcessor::WrapRequest(HttpRequest* request) { + // Handle scope for temporary handles. + HandleScope handle_scope; + + // Fetch the template for creating JavaScript http request wrappers. + // It only has to be created once, which we do on demand. + if (request_template_.IsEmpty()) { + Handle<ObjectTemplate> raw_template = MakeRequestTemplate(); + request_template_ = Persistent<ObjectTemplate>::New(raw_template); + } + Handle<ObjectTemplate> templ = request_template_; + + // Create an empty http request wrapper. + Handle<Object> result = templ->NewInstance(); + + // Wrap the raw C++ pointer in an External so it can be referenced + // from within JavaScript. + Handle<External> request_ptr = External::New(request); + + // Store the request pointer in the JavaScript wrapper. + result->SetInternalField(0, request_ptr); + + // Return the result through the current handle scope. Since each + // of these handles will go away when the handle scope is deleted + // we need to call Close to let one, the result, escape into the + // outer handle scope. + return handle_scope.Close(result); +} + + +/** + * Utility function that extracts the C++ http request object from a + * wrapper object. + */ +HttpRequest* JsHttpRequestProcessor::UnwrapRequest(Handle<Object> obj) { + Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0)); + void* ptr = field->Value(); + return static_cast<HttpRequest*>(ptr); +} + + +Handle<Value> JsHttpRequestProcessor::GetPath(Local<String> name, + const AccessorInfo& info) { + // Extract the C++ request object from the JavaScript wrapper. + HttpRequest* request = UnwrapRequest(info.Holder()); + + // Fetch the path. + const string& path = request->Path(); + + // Wrap the result in a JavaScript string and return it. + return String::New(path.c_str(), path.length()); +} + + +Handle<Value> JsHttpRequestProcessor::GetReferrer(Local<String> name, + const AccessorInfo& info) { + HttpRequest* request = UnwrapRequest(info.Holder()); + const string& path = request->Referrer(); + return String::New(path.c_str(), path.length()); +} + + +Handle<Value> JsHttpRequestProcessor::GetHost(Local<String> name, + const AccessorInfo& info) { + HttpRequest* request = UnwrapRequest(info.Holder()); + const string& path = request->Host(); + return String::New(path.c_str(), path.length()); +} + + +Handle<Value> JsHttpRequestProcessor::GetUserAgent(Local<String> name, + const AccessorInfo& info) { + HttpRequest* request = UnwrapRequest(info.Holder()); + const string& path = request->UserAgent(); + return String::New(path.c_str(), path.length()); +} + + +Handle<ObjectTemplate> JsHttpRequestProcessor::MakeRequestTemplate() { + HandleScope handle_scope; + + Handle<ObjectTemplate> result = ObjectTemplate::New(); + result->SetInternalFieldCount(1); + + // Add accessors for each of the fields of the request. + result->SetAccessor(String::NewSymbol("path"), GetPath); + result->SetAccessor(String::NewSymbol("referrer"), GetReferrer); + result->SetAccessor(String::NewSymbol("host"), GetHost); + result->SetAccessor(String::NewSymbol("userAgent"), GetUserAgent); + + // Again, return the result through the current handle scope. + return handle_scope.Close(result); +} + + +// --- Test --- + + +void HttpRequestProcessor::Log(const char* event) { + printf("Logged: %s\n", event); +} + + +/** + * A simplified http request. + */ +class StringHttpRequest : public HttpRequest { + public: + StringHttpRequest(const string& path, + const string& referrer, + const string& host, + const string& user_agent); + virtual const string& Path() { return path_; } + virtual const string& Referrer() { return referrer_; } + virtual const string& Host() { return host_; } + virtual const string& UserAgent() { return user_agent_; } + private: + string path_; + string referrer_; + string host_; + string user_agent_; +}; + + +StringHttpRequest::StringHttpRequest(const string& path, + const string& referrer, + const string& host, + const string& user_agent) + : path_(path), + referrer_(referrer), + host_(host), + user_agent_(user_agent) { } + + +void ParseOptions(int argc, + char* argv[], + map<string, string>& options, + string* file) { + for (int i = 1; i < argc; i++) { + string arg = argv[i]; + int index = arg.find('=', 0); + if (index == string::npos) { + *file = arg; + } else { + string key = arg.substr(0, index); + string value = arg.substr(index+1); + options[key] = value; + } + } +} + + +// Reads a file into a v8 string. +Handle<String> ReadFile(const string& name) { + FILE* file = fopen(name.c_str(), "rb"); + 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 = fread(&chars[i], 1, size - i, file); + i += read; + } + fclose(file); + Handle<String> result = String::New(chars, size); + delete[] chars; + return result; +} + + +const int kSampleSize = 6; +StringHttpRequest kSampleRequests[kSampleSize] = { + StringHttpRequest("/process.cc", "localhost", "google.com", "firefox"), + StringHttpRequest("/", "localhost", "google.net", "firefox"), + StringHttpRequest("/", "localhost", "google.org", "safari"), + StringHttpRequest("/", "localhost", "yahoo.com", "ie"), + StringHttpRequest("/", "localhost", "yahoo.com", "safari"), + StringHttpRequest("/", "localhost", "yahoo.com", "firefox") +}; + + +bool ProcessEntries(HttpRequestProcessor* processor, int count, + StringHttpRequest* reqs) { + for (int i = 0; i < count; i++) { + if (!processor->Process(&reqs[i])) + return false; + } + return true; +} + + +void PrintMap(map<string, string>* m) { + for (map<string, string>::iterator i = m->begin(); i != m->end(); i++) { + pair<string, string> entry = *i; + printf("%s: %s\n", entry.first.c_str(), entry.second.c_str()); + } +} + + +int main(int argc, char* argv[]) { + map<string, string> options; + string file; + ParseOptions(argc, argv, options, &file); + if (file.empty()) { + fprintf(stderr, "No script was specified.\n"); + return 1; + } + HandleScope scope; + Handle<String> source = ReadFile(file); + if (source.IsEmpty()) { + fprintf(stderr, "Error reading '%s'.\n", file.c_str()); + return 1; + } + JsHttpRequestProcessor processor(source); + map<string, string> output; + if (!processor.Initialize(&options, &output)) { + fprintf(stderr, "Error initializing processor.\n"); + return 1; + } + if (!ProcessEntries(&processor, kSampleSize, kSampleRequests)) + return 1; + PrintMap(&output); +} diff --git a/samples/shell.cc b/samples/shell.cc new file mode 100644 index 00000000..27ed293e --- /dev/null +++ b/samples/shell.cc @@ -0,0 +1,303 @@ +// Copyright 2009 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. + +#include <v8.h> +#include <fcntl.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> + + +void RunShell(v8::Handle<v8::Context> context); +bool ExecuteString(v8::Handle<v8::String> source, + v8::Handle<v8::Value> name, + bool print_result, + bool report_exceptions); +v8::Handle<v8::Value> Print(const v8::Arguments& args); +v8::Handle<v8::Value> Read(const v8::Arguments& args); +v8::Handle<v8::Value> Load(const v8::Arguments& args); +v8::Handle<v8::Value> Quit(const v8::Arguments& args); +v8::Handle<v8::Value> Version(const v8::Arguments& args); +v8::Handle<v8::String> ReadFile(const char* name); +void ReportException(v8::TryCatch* handler); + + +int RunMain(int argc, char* argv[]) { + v8::V8::SetFlagsFromCommandLine(&argc, argv, true); + v8::HandleScope handle_scope; + // Create a template for the global object. + v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(); + // Bind the global 'print' function to the C++ Print callback. + global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print)); + // Bind the global 'read' function to the C++ Read callback. + global->Set(v8::String::New("read"), v8::FunctionTemplate::New(Read)); + // Bind the global 'load' function to the C++ Load callback. + global->Set(v8::String::New("load"), v8::FunctionTemplate::New(Load)); + // Bind the 'quit' function + global->Set(v8::String::New("quit"), v8::FunctionTemplate::New(Quit)); + // Bind the 'version' function + global->Set(v8::String::New("version"), v8::FunctionTemplate::New(Version)); + // Create a new execution environment containing the built-in + // functions + v8::Handle<v8::Context> context = v8::Context::New(NULL, global); + // Enter the newly created execution environment. + v8::Context::Scope context_scope(context); + bool run_shell = (argc == 1); + for (int i = 1; i < argc; i++) { + const char* str = argv[i]; + if (strcmp(str, "--shell") == 0) { + run_shell = true; + } else if (strcmp(str, "-f") == 0) { + // Ignore any -f flags for compatibility with the other stand- + // alone JavaScript engines. + continue; + } else if (strncmp(str, "--", 2) == 0) { + printf("Warning: unknown flag %s.\nTry --help for options\n", str); + } else if (strcmp(str, "-e") == 0 && i + 1 < argc) { + // Execute argument given to -e option directly + v8::HandleScope handle_scope; + v8::Handle<v8::String> file_name = v8::String::New("unnamed"); + v8::Handle<v8::String> source = v8::String::New(argv[i + 1]); + if (!ExecuteString(source, file_name, false, true)) + return 1; + i++; + } else { + // Use all other arguments as names of files to load and run. + v8::HandleScope handle_scope; + v8::Handle<v8::String> file_name = v8::String::New(str); + v8::Handle<v8::String> source = ReadFile(str); + if (source.IsEmpty()) { + printf("Error reading '%s'\n", str); + return 1; + } + if (!ExecuteString(source, file_name, false, true)) + return 1; + } + } + if (run_shell) RunShell(context); + return 0; +} + + +int main(int argc, char* argv[]) { + int result = RunMain(argc, argv); + v8::V8::Dispose(); + return result; +} + + +// Extracts a C string from a V8 Utf8Value. +const char* ToCString(const v8::String::Utf8Value& value) { + return *value ? *value : "<string conversion failed>"; +} + + +// The callback that is invoked by v8 whenever the JavaScript 'print' +// function is called. Prints its arguments on stdout separated by +// spaces and ending with a newline. +v8::Handle<v8::Value> Print(const v8::Arguments& args) { + bool first = true; + for (int i = 0; i < args.Length(); i++) { + v8::HandleScope handle_scope; + if (first) { + first = false; + } else { + printf(" "); + } + v8::String::Utf8Value str(args[i]); + const char* cstr = ToCString(str); + printf("%s", cstr); + } + printf("\n"); + fflush(stdout); + return v8::Undefined(); +} + + +// The callback that is invoked by v8 whenever the JavaScript 'read' +// function is called. This function loads the content of the file named in +// the argument into a JavaScript string. +v8::Handle<v8::Value> Read(const v8::Arguments& args) { + if (args.Length() != 1) { + return v8::ThrowException(v8::String::New("Bad parameters")); + } + v8::String::Utf8Value file(args[0]); + if (*file == NULL) { + return v8::ThrowException(v8::String::New("Error loading file")); + } + v8::Handle<v8::String> source = ReadFile(*file); + if (source.IsEmpty()) { + return v8::ThrowException(v8::String::New("Error loading file")); + } + return source; +} + + +// The callback that is invoked by v8 whenever the JavaScript 'load' +// function is called. Loads, compiles and executes its argument +// JavaScript file. +v8::Handle<v8::Value> Load(const v8::Arguments& args) { + for (int i = 0; i < args.Length(); i++) { + v8::HandleScope handle_scope; + v8::String::Utf8Value file(args[i]); + if (*file == NULL) { + return v8::ThrowException(v8::String::New("Error loading file")); + } + v8::Handle<v8::String> source = ReadFile(*file); + if (source.IsEmpty()) { + return v8::ThrowException(v8::String::New("Error loading file")); + } + if (!ExecuteString(source, v8::String::New(*file), false, false)) { + return v8::ThrowException(v8::String::New("Error executing file")); + } + } + return v8::Undefined(); +} + + +// The callback that is invoked by v8 whenever the JavaScript 'quit' +// function is called. Quits. +v8::Handle<v8::Value> Quit(const v8::Arguments& args) { + // If not arguments are given args[0] will yield undefined which + // converts to the integer value 0. + int exit_code = args[0]->Int32Value(); + exit(exit_code); + return v8::Undefined(); +} + + +v8::Handle<v8::Value> Version(const v8::Arguments& args) { + return v8::String::New(v8::V8::GetVersion()); +} + + +// Reads a file into a v8 string. +v8::Handle<v8::String> ReadFile(const char* name) { + FILE* file = fopen(name, "rb"); + if (file == NULL) return v8::Handle<v8::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 = fread(&chars[i], 1, size - i, file); + i += read; + } + fclose(file); + v8::Handle<v8::String> result = v8::String::New(chars, size); + delete[] chars; + return result; +} + + +// The read-eval-execute loop of the shell. +void RunShell(v8::Handle<v8::Context> context) { + printf("V8 version %s\n", v8::V8::GetVersion()); + static const int kBufferSize = 256; + while (true) { + char buffer[kBufferSize]; + printf("> "); + char* str = fgets(buffer, kBufferSize, stdin); + if (str == NULL) break; + v8::HandleScope handle_scope; + ExecuteString(v8::String::New(str), + v8::String::New("(shell)"), + true, + true); + } + printf("\n"); +} + + +// Executes a string within the current v8 context. +bool ExecuteString(v8::Handle<v8::String> source, + v8::Handle<v8::Value> name, + bool print_result, + bool report_exceptions) { + v8::HandleScope handle_scope; + v8::TryCatch try_catch; + v8::Handle<v8::Script> script = v8::Script::Compile(source, name); + if (script.IsEmpty()) { + // Print errors that happened during compilation. + if (report_exceptions) + ReportException(&try_catch); + return false; + } else { + v8::Handle<v8::Value> result = script->Run(); + if (result.IsEmpty()) { + // Print errors that happened during execution. + if (report_exceptions) + ReportException(&try_catch); + return false; + } else { + if (print_result && !result->IsUndefined()) { + // If all went well and the result wasn't undefined then print + // the returned value. + v8::String::Utf8Value str(result); + const char* cstr = ToCString(str); + printf("%s\n", cstr); + } + return true; + } + } +} + + +void ReportException(v8::TryCatch* try_catch) { + v8::HandleScope handle_scope; + v8::String::Utf8Value exception(try_catch->Exception()); + const char* exception_string = ToCString(exception); + v8::Handle<v8::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"); + } +} |