Introduces a light version of D8 that links against shared library.

src/d8.h

 // 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
@@ skipping 10 matching lines @@
 // 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.
 
 #ifndef V8_D8_H_
 #define V8_D8_H_
 
+
+#ifndef USING_V8_SHARED
+#include "v8.h"
 #include "allocation.h"
-#include "v8.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:
   static const int kMaxNameSize = 64;
   int32_t* Bind(const char* name, bool histogram);
   int32_t* ptr() { return &count_; }
   int32_t count() { return count_; }
   int32_t sample_total() { return sample_total_; }
   bool is_histogram() { return is_histogram_; }
   void AddSample(int32_t sample);
@@ skipping 52 matching lines @@
    private:
     i::HashMap* map_;
     i::HashMap::Entry* entry_;
   };
 
  private:
   static int Hash(const char* name);
   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);
     begin_offset_ = offset;
   }
 
   void End(int offset) { end_offset_ = offset; }
 
   void Execute();
 
+#ifndef USING_V8_SHARED
   void StartExecuteInThread();
   void WaitForThread();
 
  private:
   class IsolateThread : public i::Thread {
    public:
     explicit IsolateThread(SourceGroup* group)
         : i::Thread(GetThreadOptions()), group_(group) {}
 
     virtual void Run() {
       group_->ExecuteInThread();
     }
 
    private:
     SourceGroup* group_;
   };
 
   static i::Thread::Options GetThreadOptions();
   void ExecuteInThread();
 
   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);
 
   const char** argv_;
   int begin_offset_;
   int end_offset_;
 };
 
 
 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 {
+class Shell
+#ifndef USING_V8_SHARED
+: public i::AllStatic
+#endif  // USING_V8_SHARED
+{
  public:
   static bool ExecuteString(Handle<String> source,
                             Handle<Value> name,
                             bool print_result,
                             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,
                                int min,
                                int max,
                                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);
 #endif
 
 #ifdef WIN32
 #undef Yield
 #endif
 
   static Handle<Value> Print(const Arguments& args);
@@ skipping 42 matching lines @@
   static Handle<Value> OSObject(const Arguments& args);
   static Handle<Value> System(const Arguments& args);
   static Handle<Value> ChangeDirectory(const Arguments& args);
   static Handle<Value> SetEnvironment(const Arguments& args);
   static Handle<Value> UnsetEnvironment(const Arguments& args);
   static Handle<Value> SetUMask(const Arguments& args);
   static Handle<Value> MakeDirectory(const Arguments& args);
   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> evaluation_context_;
+#ifndef USING_V8_SHARED
   static Persistent<Context> utility_context_;
-  static Persistent<Context> evaluation_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
   static CounterCollection local_counters_;
   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);
   static void ExternalArrayWeakCallback(Persistent<Value> object, void* data);
 };
 
 
+#ifndef USING_V8_SHARED
 class LineEditor {
  public:
   enum Type { DUMB = 0, READLINE = 1 };
   LineEditor(Type type, const char* name);
   virtual ~LineEditor() { }
 
   virtual i::SmartPointer<char> Prompt(const char* prompt) = 0;
   virtual bool Open() { return true; }
   virtual bool Close() { return true; }
   virtual void AddHistory(const char* str) { }
 
   const char* name() { return name_; }
   static LineEditor* Get();
  private:
   Type type_;
   const char* name_;
   LineEditor* next_;
   static LineEditor* first_;
 };
+#endif  // USING_V8_SHARED
 
 
 }  // namespace v8
 
 
 #endif  // V8_D8_H_