CSE2410 Fall 2014 Bounce

class ObjectOperationDescriptor;

class RawOperationDescriptor;

class CallHandlerHelper;

namespace internal {

class Arguments;

   * The referee is kept alive by the local handle even when

   * the original handle is destroyed/disposed.

   */

  V8_INLINE static Local<T> New(Isolate* isolate, Handle<T> that);

  template<class M>

  V8_INLINE static Local<T> New(Isolate* isolate,

  friend class Context;

  template<class F> friend class internal::CustomArguments;

  friend class HandleScope;

  V8_INLINE static Local<T> New(Isolate* isolate, T* that);

};

/**

 * An object reference that is independent of any handle scope.  Where

 * a Local handle only lives as long as the HandleScope in which it was

 * allocated, a Persistent handle remains valid until it is explicitly

   */

  template <class S, class M2>

  V8_INLINE void Reset(Isolate* isolate, const Persistent<S, M2>& other);

  V8_INLINE bool IsEmpty() const { return val_ == 0; }

      P* parameter,

      typename WeakCallbackData<S, P>::Callback callback);

  template<typename S, typename P>

  template<typename P>

  V8_INLINE void ClearWeak();

  /**

   * Marks the reference to this object independent. Garbage collector is free

   * to ignore any object groups containing this object. Weak callback for an

   */

  V8_INLINE void MarkIndependent();

  /**

   * Marks the reference to this object partially dependent. Partially dependent

   * handles only depend on other partially dependent handles and these

   */

  V8_INLINE void MarkPartiallyDependent();

  V8_INLINE bool IsIndependent() const;

  /** Checks if the handle holds the only reference to an object. */

  V8_INLINE bool IsNearDeath() const;

  /** Returns true if the handle's reference is weak.  */

  V8_INLINE bool IsWeak() const;

  /**

   * Assigns a wrapper class ID to the handle. See RetainedObjectInfo interface

   * description in v8-profiler.h for details.

   */

  V8_INLINE void SetWrapperClassId(uint16_t class_id);

  /**

   * Returns the class ID previously assigned to this handle or 0 if no class ID

   * was previously assigned.

   */

  V8_INLINE uint16_t WrapperClassId() const;

  // TODO(dcarney): remove

#ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR

  V8_INLINE T* operator*() const { return val_; }

 private:

  friend class Utils;

  template<class F> friend class Handle;

  template<class F> friend class Local;

  ~HandleScope();

  /**

   * Counts the number of allocated handles.

   */

  static int NumberOfHandles();

  /**

   * Creates a new handle with the given value.

   */

  static internal::Object** CreateHandle(internal::Isolate* isolate,

                                         internal::Object* value);

  // Make it hard to create heap-allocated or illegal handle scopes by

  // disallowing certain operations.

  HandleScope(const HandleScope&);

    }

  };

  void Leave();

  internal::Isolate* isolate_;

  internal::Object** prev_next_;

  internal::Object** prev_limit_;

  // Allow for the active closing of HandleScopes which allows to pass a handle

  // from the HandleScope being closed to the next top most HandleScope.

  bool is_closed_;

  internal::Object** RawClose(internal::Object** value);

  friend class ImplementationUtilities;

};

   * \param input Pointer to UTF-8 script source code.

   * \param length Length of UTF-8 script source code.

   */

  /**

   * Pre-compiles the specified script (context-independent).

  /**

   * Returns the script id value.

   */

  /**

   * Returns the script id.

  /** JS == */

  bool Equals(Handle<Value> that) const;

  bool StrictEquals(Handle<Value> that) const;

  template <class T> V8_INLINE static Value* Cast(T* value);

  int Utf8Length() const;

  /**

   * Returns whether this string is known to contain only one byte data.

   * Does not read the string.

   * False negatives are possible.

            int start = 0,

            int length = -1,

            int options = NO_OPTIONS) const;

  // One byte characters.

  int WriteOneByte(uint8_t* buffer,

                   int start = 0,

  V8_INLINE static String* Cast(v8::Value* obj);

  /**

   * Allocates a new string from either UTF-8 encoded or ASCII data.

   * The second parameter 'length' gives the buffer length. If omitted,

   * the function calls 'strlen' to determine the buffer length.

   */

  /** Allocates a new string from 16-bit character codes.*/

  /**

   * Creates an internalized string (historically called a "symbol",

   * not to be confused with ES6 symbols). Returns one if it exists already.

   */

  enum NewStringType {

    kNormalString, kInternalizedString, kUndetectableString

   */

  bool CanMakeExternal();

  /** Creates an undetectable string from the supplied ASCII or UTF-8 data.*/

  /** Creates an undetectable string from the supplied 16-bit character codes.*/

  /**

   * Converts an object to a UTF-8-encoded character array.  Useful if

   */

  class V8_EXPORT AsciiValue {

   public:

    ~AsciiValue();

    char* operator*() { return str_; }

    const char* operator*() const { return str_; }

   * Call an Object as a function if a callback is set by the

   * ObjectTemplate::SetCallAsFunctionHandler method.

   */

                              int argc,

                              Handle<Value> argv[]);

  V8_INLINE Isolate* GetIsolate() const;

  V8_INLINE ReturnValue<T> GetReturnValue() const;

  // This shouldn't be public, but the arm compiler needs it.

 protected:

  friend class internal::FunctionCallbackArguments;

  friend class internal::CustomArguments<FunctionCallbackInfo>;

  V8_INLINE FunctionCallbackInfo(internal::Object** implicit_args,

                   internal::Object** values,

  friend class MacroAssembler;

  friend class internal::PropertyCallbackArguments;

  friend class internal::CustomArguments<PropertyCallbackInfo>;

  V8_INLINE PropertyCallbackInfo(internal::Object** args) : args_(args) {}

  internal::Object** args_;

  Local<Object> NewInstance() const;

  Local<Object> NewInstance(int argc, Handle<Value> argv[]) const;

  void SetName(Handle<String> name);

  Handle<Value> GetName() const;

  Handle<Value> GetInferredName() const;

  /**

   * Returns zero based line number of function body and

   * kLineOffsetNotFound if no information available.

   */

  int GetScriptColumnNumber() const;

  /**

   * Returns scriptId object.

   */

  /**

   * Returns scriptId.

   * Size of a view in bytes.

   */

  size_t ByteLength();

  V8_INLINE static ArrayBufferView* Cast(Value* obj);

 public:

  static Local<Value> New(double time);

  /**

   * A specialization of Value::NumberValue that is more efficient

 public:

  static Local<Value> New(double value);

  /**

   * Returns the Number held by the object.

 public:

  static Local<Value> New(bool value);

  /**

   * Returns the Boolean held by the object.

 public:

  static Local<Value> New(Handle<String> value);

  /**

   * Returns the String held by the object.

 public:

  static Local<Value> New(Isolate* isolate, Handle<Symbol> value);

  /**

   * Returns the Symbol held by the object.

  uint32_t* stack_limit() const { return stack_limit_; }

  // Sets an address beyond which the VM's stack may not grow.

  void set_stack_limit(uint32_t* value) { stack_limit_ = value; }

 private:

  int max_young_space_size_;

  int max_old_space_size_;

  int max_executable_size_;

  uint32_t* stack_limit_;

};

bool V8_EXPORT SetResourceConstraints(ResourceConstraints* constraints);

typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> error);

/**

 * Create new error objects by calling the corresponding error object

typedef void (*GCPrologueCallback)(GCType type, GCCallbackFlags flags);

typedef void (*GCEpilogueCallback)(GCType type, GCCallbackFlags flags);

/**

 * Collection of V8 heap information.

   */

  CpuProfiler* GetCpuProfiler();

  /** Returns the context that is on the top of the stack. */

  Local<Context> GetCurrentContext();

  /**

   * Allows the host application to group objects together. If one

   * object in the group is alive, all objects in the group are alive.

   * After each garbage collection, object groups are removed. It is

   * garbage collection types it is sufficient to provide object groups

   * for partially dependent handles only.

   */

  /**

   * Allows the host application to declare implicit references from an object

   * are removed. It is intended to be used in the before-garbage-collection

   * callback function.

   */

  /**

   * Allows the host application to declare implicit references from an object

   * too. After each garbage collection, all implicit references are removed. It

   * is intended to be used in the before-garbage-collection callback function.

   */

 private:

  Isolate();

  Isolate& operator=(const Isolate&);

  void* operator new(size_t size);

  void operator delete(void*, size_t);

class V8_EXPORT StartupData {

 public:

  static void RemoveGCPrologueCallback(GCPrologueCallback callback);

  /**

   * Enables the host application to receive a notification after a

   * garbage collection.  Allocations are not allowed in the

   * callback function, you therefore cannot manipulate objects (set

  static void RemoveGCEpilogueCallback(GCEpilogueCallback callback);

  /**

   * Enables the host application to provide a mechanism to be notified

   * and perform custom logging when V8 Allocates Executable Memory.

   */

      ReturnAddressLocationResolver return_address_resolver);

  /**

   * Allows the host application to provide the address of a function that's

   * invoked on entry to every V8-generated function.

   * Note that \p entry_hook is invoked at the very start of each

  static void SetJitCodeEventHandler(JitCodeEventOptions options,

                                     JitCodeEventHandler event_handler);

  /**

   * Forcefully terminate the current thread of JavaScript execution

   */

  static bool Dispose();

  /**

   * Iterates through all external resources referenced from current isolate

   * heap.  GC is not invoked prior to iterating, therefore there is no

      Handle<ObjectTemplate> global_template = Handle<ObjectTemplate>(),

      Handle<Value> global_object = Handle<Value>());

  /**

   * Sets the security token for the context.  To access an object in

  /** Returns true if the context has experienced an out of memory situation. */

  bool HasOutOfMemoryException();

  /** Returns an isolate associated with a current context. */

  v8::Isolate* GetIsolate();

    explicit V8_INLINE Scope(Handle<Context> context) : context_(context) {

      context_->Enter();

    }

    : context_(Handle<Context>::New(isolate, context)) {

      context_->Enter();

    }

   */

  V8_INLINE explicit Unlocker(Isolate* isolate) { Initialize(isolate); }

  ~Unlocker();

 private:

  void Initialize(Isolate* isolate);

   */

  V8_INLINE explicit Locker(Isolate* isolate) { Initialize(isolate); }

  ~Locker();

  /**

   * that will switch between multiple threads that are in contention

   * for the V8 lock.

   */

  /**

   * Stop preemption.

   */

  /**

   * Returns whether or not the locker for a given isolate, is locked by the

  static const int kNullValueRootIndex = 7;

  static const int kTrueValueRootIndex = 8;

  static const int kFalseValueRootIndex = 9;

  static const int kNodeClassIdOffset = 1 * kApiPointerSize;

  static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;

  static const int kNodeIsIndependentShift = 4;

  static const int kNodeIsPartiallyDependentShift = 5;

  static const int kFirstNonstringType = 0x80;

  static const int kOddballType = 0x83;

  static const int kForeignType = 0x87;

  static const int kUndefinedOddballKind = 5;

  static const int kNullOddballKind = 3;

  V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {

#ifdef V8_ENABLE_CHECKS

    CheckInitializedImpl(isolate);

template <class T>

Local<T> Local<T>::New(Isolate* isolate, Handle<T> that) {

  return New(isolate, that.val_);

}

template<typename T>

Local<Value> FunctionCallbackInfo<T>::operator[](int i) const {

  return Local<Value>(reinterpret_cast<Value*>(values_ - i));

}

Handle<Boolean> Boolean::New(bool value) {

}

Local<Value> Object::GetInternalField(int index) {

#ifndef V8_ENABLE_CHECKS

  typedef internal::Object O;

  typedef internal::Internals I;

  O* obj = *reinterpret_cast<O**>(this);

  // Fast path: If the object is a plain JSObject, which is the common case, we

  if (I::GetInstanceType(obj) == I::kJSObjectType) {

    int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);

    O* value = I::ReadField<O*>(obj, offset);

    return Local<Value>(reinterpret_cast<Value*>(result));

  }

#endif

}

Local<Value> Context::GetEmbedderData(int index) {

#ifndef V8_ENABLE_CHECKS

  typedef internal::Object O;

  typedef internal::Internals I;

  return Local<Value>(reinterpret_cast<Value*>(result));

#else

  return SlowGetEmbedderData(index);