Lines Matching defs:Function
76 class Function;
550 * A related function Isolate::NumberOfPhantomHandleResetsSinceLastCall
702 * exactly as the Persistent constructor, but the Copy function from the
1232 * function will be called on a background thread, so it's OK to block and
1341 * Owned by caller, no references are kept when this function returns.
1343 * when this function was called. When run it will always use this
1419 * Compile a function for a given context. This is equivalent to running
1422 * return function(args) { ... }
1429 Local<Function> CompileFunctionInContext(
1435 static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInContext(
1458 * Returns the origin for the script from where the function causing the
1464 * Returns the resource name for the script from where the function causing
1589 * Returns the number, 1-based, of the line for the associate function call.
1597 * Returns the 1-based column offset on the line for the associated function
1606 * Returns the id of the script for the function for this StackFrame.
1615 * function for this StackFrame.
1621 * function for this StackFrame or sourceURL value if the script name
1628 * Returns the name of the function associated with this stack frame.
1633 * Returns whether or not the associated function is compiled via a call to
1639 * Returns whether or not the associated function is called as a
1658 // The output structure filled up by GetStackSample API function.
1985 * Returns true if this value is a function.
2066 * Returns true if this value is an async function.
2071 * Returns true if this value is a Generator function.
2588 * this function should not otherwise delete or modify the resource. Neither
2613 * this function should not otherwise delete or modify the resource. Neither
2943 // The defineProperty function is used to add an own property or
3051 void SetAccessorProperty(Local<Name> name, Local<Function> getter,
3052 Local<Function> setter = Local<Function>(),
3082 * This function has the same functionality as GetPropertyNames but
3116 * Finds an instance of the given function template in the prototype
3124 * user-defined toString function. This one does not.
3131 * Returns the name of the function invoked as a constructor for this object.
3195 * This function is similar to v8::Object::HasOwnProperty(), but it does not
3305 * Call an Object as a function if a callback is set by the
3319 * Note: This method behaves like the Function::NewInstance method.
3491 * The argument information given to function call callbacks. This
3494 * the holder of the function.
3502 Local<Function> Callee() const);
3555 * `Reflect.get`, `Function.prototype.call`, or similar functions, it is the
3617 * \return True if the intercepted function should throw if an error occurs.
3650 * A JavaScript function object (ECMA-262, 15.3).
3652 class V8_EXPORT Function : public Object {
3655 * Create a function in the current execution context
3658 static MaybeLocal<Function> New(
3664 Local<Function> New(Isolate* isolate, FunctionCallback callback,
3689 * Name inferred from variable or property assignment of this function.
3698 * function name, otherwise inferred name.
3703 * User-defined name assigned to the "displayName" property of this function.
3709 * Returns zero based line number of function body and
3714 * Returns zero based column number of function body and
3720 * Tells whether this function is builtin.
3730 * Returns the original function if this function is bound, else returns
3736 V8_INLINE static Function* Cast(Value* obj);
3740 Function();
3797 Local<Promise> Catch(Local<Function> handler));
3799 Local<Function> handler);
3802 Local<Promise> Then(Local<Function> handler));
3804 Local<Function> handler);
4642 * The superclass of object and function templates.
5015 * can only be one function created from a FunctionTemplate in a
5016 * context. The lifetime of the created function is equal to the
5025 * function object when it is created.
5028 * used to create object instances when the function is used as a
5033 * is used to create the prototype object of the function.
5054 * v8::Local<v8::Function> function = t->GetFunction();
5055 * v8::Local<v8::Object> instance = function->NewInstance();
5058 * Let's use "function" as the JS variable name of the function object
5059 * and "instance" for the instance object created above. The function
5063 * func_property in function == true;
5064 * function.func_property == 1;
5066 * function.prototype.proto_method() invokes 'InvokeCallback'
5067 * function.prototype.proto_const == 2;
5069 * instance instanceof function == true;
5087 * object of the Child() function has __proto__ pointing to the
5088 * Parent() function's prototype object. An instance of the Child
5089 * function has all properties on Parent's instance templates.
5099 * Local<Function> child_function = child->GetFunction();
5103 * The Child function and Child instance will have the following
5107 * child_func.prototype.__proto__ == function.prototype;
5114 /** Creates a function template.*/
5126 * Creates a function template with a fast handler. If a fast handler is set,
5136 * Creates a function template backed/cached by a private property.
5143 /** Returns the unique function instance in the current execution context.*/
5144 V8_DEPRECATE_SOON("Use maybe version", Local<Function> GetFunction());
5145 V8_WARN_UNUSED_RESULT MaybeLocal<Function> GetFunction(
5159 * callback is called whenever the function created from this
5173 * Causes the function template to inherit from a parent function template.
5174 * This means the the function's prototype.__proto__ is set to the parent
5175 * function's prototype.
5181 * of the function created by this template.
5186 * A PrototypeProviderTemplate is another function template whose prototype
5195 * printing objects created with the function created from the
5203 * function call. Currently defaults to true, but this is subject to change.
5209 * the function template. If instances of the function template are
5214 * instances of the function template. Call with a value of false
5216 * function template. By default, instances of a function template
5234 * Returns true if the given object is an instance of this function
5522 * this template as a function. If no callback is set, instances
5524 * function.
5594 * A Signature specifies which receiver is valid for a function.
5835 * resolve or reject function defined by CreateResolvingFunctions.
6099 * any generated function when function-level profiling is enabled.
6101 * \param function the address of the function that's being entered.
6104 * \p function, and/or modified to divert execution when \p function exits.
6108 typedef void (*FunctionEntryHook)(uintptr_t function,
6176 * Option flags passed to the SetRAILMode function.
6198 * Option flags passed to the SetJitCodeEventHandler function.
6208 * Callback function passed to SetJitCodeEventHandler.
6252 * Before the first call to the TraceWrappersFrom function TracePrologue will be
6331 SerializeInternalFieldsCallback(CallbackFunction function = nullptr,
6333 : callback(function), data(data_arg) {}
6345 DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
6347 : callback(function), data(data_arg) {}
6380 * address of a function that's invoked on entry to every V8-generated
6381 * function. Note that entry_hook is invoked at the very start of each
6382 * generated function. Furthermore, if an entry_hook is given, V8 will
6388 * Allows the host application to provide the address of a function that is
6412 * histograms. The CreateHistogram function returns a
6414 * function.
6434 * Whether calling Atomics.wait (a function that may block) is allowed in
6631 * It is allowed to call this function from another thread while
6744 * \param sample_info The sample info is filled up by the function
6771 * by the garbage collector since the last call to this function.
6832 * function, for instance to simulate DOM tree connections among JS
6848 * callback function.
6859 * is intended to be used in the before-garbage-collection callback function.
6871 * garbage collection. Allocations are allowed in the callback function,
6875 * not possible to register the same callback function two times with
6882 * This function removes callback which was installed by
6883 * AddGCPrologueCallback function.
6894 * garbage collection. Allocations are allowed in the callback function,
6898 * not possible to register the same callback function two times with
6905 * This function removes callback which was installed by
6906 * AddGCEpilogueCallback function.
6957 * function if --expose_gc was specified.
7027 void EnqueueMicrotask(Local<Function> microtask);
7081 * histograms. The CreateHistogram function returns a
7083 * function.
7099 * that function. There is no guarantee that the actual work will be done
7163 * Allows the host application to provide the address of a function that is
7179 * new members. The \p event_handler function must ignore event codes
7201 * On Win64, embedders are advised to install function table callbacks for
7270 * Remove all message listeners from the specified callback function.
7274 /** Callback function for reporting failed access checks.*/
7345 * EntropySource is used as a callback function when v8 needs a source
7351 * ReturnAddressLocationResolver is used as a callback function when v8 is
7361 * \note The resolver function
7397 * case this function is not meaningful.
7443 * Remove all message listeners from the specified callback function.
7473 /** Callback function for reporting failed access checks.*/
7481 * callback function, you therefore cannot manipulate objects (set
7485 * register the same callback function two times with different
7494 * This function removes callback which was installed by
7495 * AddGCPrologueCallback function.
7504 * callback function, you therefore cannot manipulate objects (set
7508 * register the same callback function two times with different
7517 * This function removes callback which was installed by
7518 * AddGCEpilogueCallback function.
7525 * Initializes V8. This function needs to be called before the first Isolate
7792 * \param function_code_handling whether to include compiled function code
8222 * this method with false will disable 'eval' and the 'Function'
8224 * 'Function' constructor are used an exception will be thrown.
8228 * set before blocking the call to 'eval' or the 'Function'
8243 * code generation from strings is not allowed and 'eval' or the 'Function'
8272 friend class Function;
8996 Local<Function> FunctionCallbackInfo<T>::Callee() const {
8997 return Local<Function>(reinterpret_cast<Function*>(
9622 Function* Function::Cast(v8::Value* value) {
9626 return static_cast<Function*>(value);
