libv8 5.3.332.38.3-universal-darwin-16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7868e0fece5a3744791df1bdc064f3d7aae174f
+  data.tar.gz: 0cd5d16f0558cb19ca860c9702c77deb0c992f4e
+SHA512:
+  metadata.gz: 166bdb1f37665ce644fd2cf0f59e366deecaa152269a5d98d3cf4e1d7744ae622f333f6858805f93e5852d1c36416ce300a99dea768cfcca9f6ec5a7a28fe94f
+  data.tar.gz: 50af4512bbb5dd81c739ab77caaf9a4b542a2e758676ff513f879ca735745b4fdd14cfe36325fed091e7c70318ab56349ea522998230fd655a29a783afe7bc16

data/ext/libv8/.location.yml

@@ -0,0 +1 @@
+--- !ruby/object:Libv8::Location::Vendor {}

data/ext/libv8/arch.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+module Libv8
+  module Arch
+    module_function
+
+    def libv8_arch
+      case Gem::Platform.local.cpu
+      when /^arm(v7.*)*$/     then 'arm'
+      when /^a(rm|arch)64$/   then 'arm64'
+      when /^x86$/            then 'ia32'
+      when /^(x86_64|amd64)$/ then 'x64'
+      when /^universal$/      then 'x64' # OS X
+      else
+        warn "Unsupported target: #{Gem::Platform.local.cpu}"
+        Gem::Platform.local.cpu
+      end
+    end
+  end
+end

data/ext/libv8/location.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'pathname'
+require File.expand_path '../paths', __FILE__
+
+module Libv8
+  class Location
+    def install!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml'), "w") do |f|
+        f.write self.to_yaml
+      end
+      return 0
+    end
+
+    def self.load!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml')) do |f|
+        YAML.load f
+      end
+    end
+
+    class Vendor < Location
+      def install!
+        require File.expand_path '../builder', __FILE__
+        builder = Libv8::Builder.new
+        exit_status = builder.build_libv8!
+        super if exit_status == 0
+        verify_installation!
+        return exit_status
+      end
+
+      def configure(context = MkmfContext.new)
+        context.incflags.insert 0, Libv8::Paths.include_paths.map{ |p| "-I#{p}" }.join(" ")  + " "
+        context.ldflags.insert 0, Libv8::Paths.object_paths.join(" ") + " "
+      end
+
+      def verify_installation!
+        include_paths = Libv8::Paths.include_paths
+        unless include_paths.detect { |p| Pathname(p).join('v8.h').exist? }
+          fail HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}"
+        end
+        Libv8::Paths.object_paths.each do |p|
+          fail ArchiveNotFound, p unless File.exist? p
+        end
+      end
+
+      class HeaderNotFound < StandardError; end
+
+      class ArchiveNotFound < StandardError
+        def initialize(filename)
+          super "libv8 did not install properly, expected binary v8 archive '#{filename}'to exist, but it was not found"
+        end
+      end
+    end
+
+    class System < Location
+      def configure(context = MkmfContext.new)
+        context.send(:dir_config, 'v8')
+        context.send(:find_header, 'v8.h') or fail NotFoundError
+        context.send(:find_header, 'libplatform/libplatform.h') or fail NotFoundError
+        context.send(:have_library, 'v8') or fail NotFoundError
+      end
+
+      class NotFoundError < StandardError
+        def initialize(*args)
+          super(<<-EOS)
+By using --with-system-v8, you have chosen to use the version
+of V8 found on your system and *not* the one that is bundled with
+the libv8 rubygem.
+
+However, your system version of v8 could not be located.
+
+Please make sure your system version of v8 that is compatible
+with #{Libv8::VERSION} installed. You may need to use the
+--with-v8-dir option if it is installed in a non-standard location
+EOS
+        end
+      end
+    end
+
+    class MkmfContext
+      def incflags
+        $INCFLAGS
+      end
+
+      def ldflags
+        $LDFLAGS
+      end
+    end
+  end
+end

data/ext/libv8/paths.rb

@@ -0,0 +1,41 @@
+require 'rbconfig'
+require 'shellwords'
+require File.expand_path '../arch', __FILE__
+
+module Libv8
+  module Paths
+    module_function
+
+    def include_paths
+      [Shellwords.escape(File.join(vendored_source_path, 'include'))]
+    end
+
+    def object_paths
+      [:base, :libplatform, :libsampler, :libbase, :snapshot].map do |name|
+        Shellwords.escape libv8_object(name)
+      end
+    end
+
+    def config
+      RbConfig::MAKEFILE_CONFIG
+    end
+
+    def libv8_object(name)
+      filename = "#{libv8_profile}/libv8_#{name}.#{config['LIBEXT']}"
+      unless File.exist? filename
+        filename = "#{libv8_profile}/obj.target/tools/gyp/libv8_#{name}.#{config['LIBEXT']}"
+      end
+      return filename
+    end
+
+    def libv8_profile
+      base = "#{vendored_source_path}/out/#{Libv8::Arch.libv8_arch}"
+      debug = "#{base}.debug"
+      File.exist?(debug) ? debug : "#{base}.release"
+    end
+
+    def vendored_source_path
+      File.expand_path "../../../vendor/v8", __FILE__
+    end
+  end
+end

data/lib/libv8.rb

@@ -0,0 +1,9 @@
+require 'libv8/version'
+require 'libv8/location'
+
+module Libv8
+  def self.configure_makefile
+    location = Location.load!
+    location.configure
+  end
+end

data/lib/libv8/version.rb

@@ -0,0 +1,3 @@
+module Libv8
+  VERSION = "5.3.332.38.3"
+end

data/vendor/v8/include/libplatform/libplatform.h

@@ -0,0 +1,38 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_LIBPLATFORM_LIBPLATFORM_H_
+#define V8_LIBPLATFORM_LIBPLATFORM_H_
+
+#include "v8-platform.h"  // NOLINT(build/include)
+
+namespace v8 {
+namespace platform {
+
+/**
+ * Returns a new instance of the default v8::Platform implementation.
+ *
+ * The caller will take ownership of the returned pointer. |thread_pool_size|
+ * is the number of worker threads to allocate for background jobs. If a value
+ * of zero is passed, a suitable default based on the current number of
+ * processors online will be chosen.
+ */
+v8::Platform* CreateDefaultPlatform(int thread_pool_size = 0);
+
+
+/**
+ * Pumps the message loop for the given isolate.
+ *
+ * The caller has to make sure that this is called from the right thread.
+ * Returns true if a task was executed, and false otherwise. This call does
+ * not block if no task is pending. The |platform| has to be created using
+ * |CreateDefaultPlatform|.
+ */
+bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate);
+
+
+}  // namespace platform
+}  // namespace v8
+
+#endif  // V8_LIBPLATFORM_LIBPLATFORM_H_

data/vendor/v8/include/v8-debug.h

@@ -0,0 +1,301 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_V8_DEBUG_H_
+#define V8_V8_DEBUG_H_
+
+#include "v8.h"  // NOLINT(build/include)
+
+/**
+ * Debugger support for the V8 JavaScript engine.
+ */
+namespace v8 {
+
+// Debug events which can occur in the V8 JavaScript engine.
+enum DebugEvent {
+  Break = 1,
+  Exception = 2,
+  NewFunction = 3,
+  BeforeCompile = 4,
+  AfterCompile = 5,
+  CompileError = 6,
+  AsyncTaskEvent = 7,
+};
+
+class V8_EXPORT Debug {
+ public:
+  /**
+   * A client object passed to the v8 debugger whose ownership will be taken by
+   * it. v8 is always responsible for deleting the object.
+   */
+  class ClientData {
+   public:
+    virtual ~ClientData() {}
+  };
+
+
+  /**
+   * A message object passed to the debug message handler.
+   */
+  class Message {
+   public:
+    /**
+     * Check type of message.
+     */
+    virtual bool IsEvent() const = 0;
+    virtual bool IsResponse() const = 0;
+    virtual DebugEvent GetEvent() const = 0;
+
+    /**
+     * Indicate whether this is a response to a continue command which will
+     * start the VM running after this is processed.
+     */
+    virtual bool WillStartRunning() const = 0;
+
+    /**
+     * Access to execution state and event data. Don't store these cross
+     * callbacks as their content becomes invalid. These objects are from the
+     * debugger event that started the debug message loop.
+     */
+    virtual Local<Object> GetExecutionState() const = 0;
+    virtual Local<Object> GetEventData() const = 0;
+
+    /**
+     * Get the debugger protocol JSON.
+     */
+    virtual Local<String> GetJSON() const = 0;
+
+    /**
+     * Get the context active when the debug event happened. Note this is not
+     * the current active context as the JavaScript part of the debugger is
+     * running in its own context which is entered at this point.
+     */
+    virtual Local<Context> GetEventContext() const = 0;
+
+    /**
+     * Client data passed with the corresponding request if any. This is the
+     * client_data data value passed into Debug::SendCommand along with the
+     * request that led to the message or NULL if the message is an event. The
+     * debugger takes ownership of the data and will delete it even if there is
+     * no message handler.
+     */
+    virtual ClientData* GetClientData() const = 0;
+
+    virtual Isolate* GetIsolate() const = 0;
+
+    virtual ~Message() {}
+  };
+
+
+  /**
+   * An event details object passed to the debug event listener.
+   */
+  class EventDetails {
+   public:
+    /**
+     * Event type.
+     */
+    virtual DebugEvent GetEvent() const = 0;
+
+    /**
+     * Access to execution state and event data of the debug event. Don't store
+     * these cross callbacks as their content becomes invalid.
+     */
+    virtual Local<Object> GetExecutionState() const = 0;
+    virtual Local<Object> GetEventData() const = 0;
+
+    /**
+     * Get the context active when the debug event happened. Note this is not
+     * the current active context as the JavaScript part of the debugger is
+     * running in its own context which is entered at this point.
+     */
+    virtual Local<Context> GetEventContext() const = 0;
+
+    /**
+     * Client data passed with the corresponding callback when it was
+     * registered.
+     */
+    virtual Local<Value> GetCallbackData() const = 0;
+
+    /**
+     * Client data passed to DebugBreakForCommand function. The
+     * debugger takes ownership of the data and will delete it even if
+     * there is no message handler.
+     */
+    virtual ClientData* GetClientData() const = 0;
+
+    virtual Isolate* GetIsolate() const = 0;
+
+    virtual ~EventDetails() {}
+  };
+
+  /**
+   * Debug event callback function.
+   *
+   * \param event_details object providing information about the debug event
+   *
+   * A EventCallback2 does not take possession of the event data,
+   * and must not rely on the data persisting after the handler returns.
+   */
+  typedef void (*EventCallback)(const EventDetails& event_details);
+
+  /**
+   * Debug message callback function.
+   *
+   * \param message the debug message handler message object
+   *
+   * A MessageHandler2 does not take possession of the message data,
+   * and must not rely on the data persisting after the handler returns.
+   */
+  typedef void (*MessageHandler)(const Message& message);
+
+  /**
+   * Callback function for the host to ensure debug messages are processed.
+   */
+  typedef void (*DebugMessageDispatchHandler)();
+
+  static bool SetDebugEventListener(Isolate* isolate, EventCallback that,
+                                    Local<Value> data = Local<Value>());
+  V8_DEPRECATED("Use version with an Isolate",
+                static bool SetDebugEventListener(
+                    EventCallback that, Local<Value> data = Local<Value>()));
+
+  // Schedule a debugger break to happen when JavaScript code is run
+  // in the given isolate.
+  static void DebugBreak(Isolate* isolate);
+
+  // Remove scheduled debugger break in given isolate if it has not
+  // happened yet.
+  static void CancelDebugBreak(Isolate* isolate);
+
+  // Check if a debugger break is scheduled in the given isolate.
+  static bool CheckDebugBreak(Isolate* isolate);
+
+  // Message based interface. The message protocol is JSON.
+  static void SetMessageHandler(Isolate* isolate, MessageHandler handler);
+  V8_DEPRECATED("Use version with an Isolate",
+                static void SetMessageHandler(MessageHandler handler));
+
+  static void SendCommand(Isolate* isolate,
+                          const uint16_t* command, int length,
+                          ClientData* client_data = NULL);
+
+ /**
+  * Run a JavaScript function in the debugger.
+  * \param fun the function to call
+  * \param data passed as second argument to the function
+  * With this call the debugger is entered and the function specified is called
+  * with the execution state as the first argument. This makes it possible to
+  * get access to information otherwise not available during normal JavaScript
+  * execution e.g. details on stack frames. Receiver of the function call will
+  * be the debugger context global object, however this is a subject to change.
+  * The following example shows a JavaScript function which when passed to
+  * v8::Debug::Call will return the current line of JavaScript execution.
+  *
+  * \code
+  *   function frame_source_line(exec_state) {
+  *     return exec_state.frame(0).sourceLine();
+  *   }
+  * \endcode
+  */
+  static V8_DEPRECATED("Use maybe version",
+                       Local<Value> Call(v8::Local<v8::Function> fun,
+                                         Local<Value> data = Local<Value>()));
+  // TODO(dcarney): data arg should be a MaybeLocal
+  static MaybeLocal<Value> Call(Local<Context> context,
+                                v8::Local<v8::Function> fun,
+                                Local<Value> data = Local<Value>());
+
+  /**
+   * Returns a mirror object for the given object.
+   */
+  static V8_DEPRECATED("Use maybe version",
+                       Local<Value> GetMirror(v8::Local<v8::Value> obj));
+  static MaybeLocal<Value> GetMirror(Local<Context> context,
+                                     v8::Local<v8::Value> obj);
+
+  /**
+   * Makes V8 process all pending debug messages.
+   *
+   * From V8 point of view all debug messages come asynchronously (e.g. from
+   * remote debugger) but they all must be handled synchronously: V8 cannot
+   * do 2 things at one time so normal script execution must be interrupted
+   * for a while.
+   *
+   * Generally when message arrives V8 may be in one of 3 states:
+   * 1. V8 is running script; V8 will automatically interrupt and process all
+   * pending messages;
+   * 2. V8 is suspended on debug breakpoint; in this state V8 is dedicated
+   * to reading and processing debug messages;
+   * 3. V8 is not running at all or has called some long-working C++ function;
+   * by default it means that processing of all debug messages will be deferred
+   * until V8 gets control again; however, embedding application may improve
+   * this by manually calling this method.
+   *
+   * Technically this method in many senses is equivalent to executing empty
+   * script:
+   * 1. It does nothing except for processing all pending debug messages.
+   * 2. It should be invoked with the same precautions and from the same context
+   * as V8 script would be invoked from, because:
+   *   a. with "evaluate" command it can do whatever normal script can do,
+   *   including all native calls;
+   *   b. no other thread should call V8 while this method is running
+   *   (v8::Locker may be used here).
+   *
+   * "Evaluate" debug command behavior currently is not specified in scope
+   * of this method.
+   */
+  static void ProcessDebugMessages(Isolate* isolate);
+  V8_DEPRECATED("Use version with an Isolate",
+                static void ProcessDebugMessages());
+
+  /**
+   * Debugger is running in its own context which is entered while debugger
+   * messages are being dispatched. This is an explicit getter for this
+   * debugger context. Note that the content of the debugger context is subject
+   * to change. The Context exists only when the debugger is active, i.e. at
+   * least one DebugEventListener or MessageHandler is set.
+   */
+  static Local<Context> GetDebugContext(Isolate* isolate);
+  V8_DEPRECATED("Use version with an Isolate",
+                static Local<Context> GetDebugContext());
+
+  /**
+   * While in the debug context, this method returns the top-most non-debug
+   * context, if it exists.
+   */
+  static MaybeLocal<Context> GetDebuggedContext(Isolate* isolate);
+
+  /**
+   * Enable/disable LiveEdit functionality for the given Isolate
+   * (default Isolate if not provided). V8 will abort if LiveEdit is
+   * unexpectedly used. LiveEdit is enabled by default.
+   */
+  static void SetLiveEditEnabled(Isolate* isolate, bool enable);
+
+  /**
+   * Returns array of internal properties specific to the value type. Result has
+   * the following format: [<name>, <value>,...,<name>, <value>]. Result array
+   * will be allocated in the current context.
+   */
+  static MaybeLocal<Array> GetInternalProperties(Isolate* isolate,
+                                                 Local<Value> value);
+
+  /**
+   * Defines if the ES2015 tail call elimination feature is enabled or not.
+   * The change of this flag triggers deoptimization of all functions that
+   * contain calls at tail position.
+   */
+  static bool IsTailCallEliminationEnabled(Isolate* isolate);
+  static void SetTailCallEliminationEnabled(Isolate* isolate, bool enabled);
+};
+
+
+}  // namespace v8
+
+
+#undef EXPORT
+
+
+#endif  // V8_V8_DEBUG_H_