api-arguments.h 7.38 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2016 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_API_ARGUMENTS_H_
#define V8_API_ARGUMENTS_H_

8
#include "src/api.h"
9
#include "src/debug/debug.h"
10
#include "src/isolate.h"
11
#include "src/visitors.h"
12 13 14 15 16 17 18 19 20

namespace v8 {
namespace internal {

// Custom arguments replicate a small segment of stack that can be
// accessed through an Arguments object the same way the actual stack
// can.
class CustomArgumentsBase : public Relocatable {
 protected:
21
  explicit inline CustomArgumentsBase(Isolate* isolate);
22 23 24
};

template <typename T>
25
class CustomArguments : public CustomArgumentsBase {
26 27 28 29 30 31 32 33
 public:
  static const int kReturnValueOffset = T::kReturnValueIndex;

  ~CustomArguments() {
    this->begin()[kReturnValueOffset] =
        reinterpret_cast<Object*>(kHandleZapValue);
  }

34 35 36 37 38
  virtual inline void IterateInstance(RootVisitor* v) {
    v->VisitRootPointers(Root::kRelocatable, nullptr, values_,
                         values_ + T::kArgsLength);
  }

39
 protected:
40 41
  explicit inline CustomArguments(Isolate* isolate)
      : CustomArgumentsBase(isolate) {}
42 43

  template <typename V>
44
  Handle<V> GetReturnValue(Isolate* isolate);
45 46 47 48

  inline Isolate* isolate() {
    return reinterpret_cast<Isolate*>(this->begin()[T::kIsolateIndex]);
  }
49 50 51

  inline Object** begin() { return values_; }
  Object* values_[T::kArgsLength];
52 53
};

54 55
// Note: Calling args.Call() sets the return value on args. For multiple
// Call()'s, a new args should be used every time.
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
class PropertyCallbackArguments
    : public CustomArguments<PropertyCallbackInfo<Value> > {
 public:
  typedef PropertyCallbackInfo<Value> T;
  typedef CustomArguments<T> Super;
  static const int kArgsLength = T::kArgsLength;
  static const int kThisIndex = T::kThisIndex;
  static const int kHolderIndex = T::kHolderIndex;
  static const int kDataIndex = T::kDataIndex;
  static const int kReturnValueDefaultValueIndex =
      T::kReturnValueDefaultValueIndex;
  static const int kIsolateIndex = T::kIsolateIndex;
  static const int kShouldThrowOnErrorIndex = T::kShouldThrowOnErrorIndex;

  PropertyCallbackArguments(Isolate* isolate, Object* data, Object* self,
71
                            JSObject* holder, ShouldThrow should_throw);
72

73 74 75
  // -------------------------------------------------------------------------
  // Accessor Callbacks
  // Also used for AccessorSetterCallback.
76 77 78
  inline Handle<Object> CallAccessorSetter(Handle<AccessorInfo> info,
                                           Handle<Name> name,
                                           Handle<Object> value);
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
  // Also used for AccessorGetterCallback, AccessorNameGetterCallback.
  inline Handle<Object> CallAccessorGetter(Handle<AccessorInfo> info,
                                           Handle<Name> name);

  // -------------------------------------------------------------------------
  // Named Interceptor Callbacks
  inline Handle<Object> CallNamedQuery(Handle<InterceptorInfo> interceptor,
                                       Handle<Name> name);
  inline Handle<Object> CallNamedGetter(Handle<InterceptorInfo> interceptor,
                                        Handle<Name> name);
  inline Handle<Object> CallNamedSetter(Handle<InterceptorInfo> interceptor,
                                        Handle<Name> name,
                                        Handle<Object> value);
  inline Handle<Object> CallNamedDefiner(Handle<InterceptorInfo> interceptor,
                                         Handle<Name> name,
                                         const v8::PropertyDescriptor& desc);
  inline Handle<Object> CallNamedDeleter(Handle<InterceptorInfo> interceptor,
                                         Handle<Name> name);
  inline Handle<Object> CallNamedDescriptor(Handle<InterceptorInfo> interceptor,
                                            Handle<Name> name);
99 100
  inline Handle<JSObject> CallNamedEnumerator(
      Handle<InterceptorInfo> interceptor);
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116

  // -------------------------------------------------------------------------
  // Indexed Interceptor Callbacks
  inline Handle<Object> CallIndexedQuery(Handle<InterceptorInfo> interceptor,
                                         uint32_t index);
  inline Handle<Object> CallIndexedGetter(Handle<InterceptorInfo> interceptor,
                                          uint32_t index);
  inline Handle<Object> CallIndexedSetter(Handle<InterceptorInfo> interceptor,
                                          uint32_t index, Handle<Object> value);
  inline Handle<Object> CallIndexedDefiner(Handle<InterceptorInfo> interceptor,
                                           uint32_t index,
                                           const v8::PropertyDescriptor& desc);
  inline Handle<Object> CallIndexedDeleter(Handle<InterceptorInfo> interceptor,
                                           uint32_t index);
  inline Handle<Object> CallIndexedDescriptor(
      Handle<InterceptorInfo> interceptor, uint32_t index);
117 118
  inline Handle<JSObject> CallIndexedEnumerator(
      Handle<InterceptorInfo> interceptor);
119 120

 private:
121 122 123 124 125 126 127 128
  /*
   * The following Call functions wrap the calling of all callbacks to handle
   * calling either the old or the new style callbacks depending on which one
   * has been registered.
   * For old callbacks which return an empty handle, the ReturnValue is checked
   * and used if it's been set to anything inside the callback.
   * New style callbacks always use the return value.
   */
129 130
  inline Handle<JSObject> CallPropertyEnumerator(
      Handle<InterceptorInfo> interceptor);
131

132
  inline Handle<Object> BasicCallIndexedGetterCallback(
133
      IndexedPropertyGetterCallback f, uint32_t index, Handle<Object> info);
134
  inline Handle<Object> BasicCallNamedGetterCallback(
135 136
      GenericNamedPropertyGetterCallback f, Handle<Name> name,
      Handle<Object> info);
137

138
  inline JSObject* holder();
139

140 141 142
  // Don't copy PropertyCallbackArguments, because they would both have the
  // same prev_ pointer.
  DISALLOW_COPY_AND_ASSIGN(PropertyCallbackArguments);
143 144 145 146 147 148 149 150 151 152 153 154 155
};

class FunctionCallbackArguments
    : public CustomArguments<FunctionCallbackInfo<Value> > {
 public:
  typedef FunctionCallbackInfo<Value> T;
  typedef CustomArguments<T> Super;
  static const int kArgsLength = T::kArgsLength;
  static const int kHolderIndex = T::kHolderIndex;
  static const int kDataIndex = T::kDataIndex;
  static const int kReturnValueDefaultValueIndex =
      T::kReturnValueDefaultValueIndex;
  static const int kIsolateIndex = T::kIsolateIndex;
156
  static const int kNewTargetIndex = T::kNewTargetIndex;
157 158 159

  FunctionCallbackArguments(internal::Isolate* isolate, internal::Object* data,
                            internal::HeapObject* callee,
160 161
                            internal::Object* holder,
                            internal::HeapObject* new_target,
162
                            internal::Object** argv, int argc);
163 164 165 166 167 168 169 170 171

  /*
   * The following Call function wraps the calling of all callbacks to handle
   * calling either the old or the new style callbacks depending on which one
   * has been registered.
   * For old callbacks which return an empty handle, the ReturnValue is checked
   * and used if it's been set to anything inside the callback.
   * New style callbacks always use the return value.
   */
172
  inline Handle<Object> Call(CallHandlerInfo* handler);
173 174

 private:
175
  inline JSObject* holder();
176

177 178 179 180 181 182 183 184
  internal::Object** argv_;
  int argc_;
};

}  // namespace internal
}  // namespace v8

#endif  // V8_API_ARGUMENTS_H_