mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-12-02 22:34:55 +08:00
Code Issues Packages Projects Releases Wiki Activity
befe10fd21
php-src/Zend/zend_API.h

2064 lines
84 KiB
C
Raw Normal View History

Remove accidently added byte
2017-05-26 23:37:44 +08:00
/*
Zend Library
1999-04-08 02:10:10 +08:00
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
Adios, yearly copyright ranges
2019-01-30 17:23:29 +08:00
| Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
Zend Library
1999-04-08 02:10:10 +08:00
+----------------------------------------------------------------------+
Update headers.
2001-12-11 23:16:21 +08:00
| This source file is subject to version 2.00 of the Zend license, |
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
| that is bundled with this package in the file LICENSE, and is |
updating license information in the headers.
2003-06-11 04:04:29 +08:00
| available through the world-wide-web at the following url: |
Update headers.
2001-12-11 23:16:21 +08:00
| http://www.zend.com/license/2_00.txt. |
License update
1999-07-16 22:58:16 +08:00
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
Zend Library
1999-04-08 02:10:10 +08:00
+----------------------------------------------------------------------+
Update email addresses. We're still @Zend, but future proofing it...
2018-11-01 23:20:07 +08:00
| Authors: Andi Gutmans <andi@php.net> |
| Zeev Suraski <zeev@php.net> |
Adding new parameter parsing API.
2001-07-10 02:51:29 +08:00
| Andrei Zmievski <andrei@php.net> |
Update email addresses. We're still @Zend, but future proofing it...
2018-11-01 23:20:07 +08:00
| Dmitry Stogov <dmitry@php.net> |
Zend Library
1999-04-08 02:10:10 +08:00
+----------------------------------------------------------------------+
*/
Change header protection macros to conform to standard. Draft 3 of IEEE 1003.1 200x, "2.2 The Compilation Environment" All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use by the implementation.
2000-07-03 07:54:19 +08:00
#ifndef ZEND_API_H
#define ZEND_API_H
Zend Library
1999-04-08 02:10:10 +08:00
- Rename modules.h to zend_modules.h
2001-02-27 02:18:34 +08:00
#include "zend_modules.h"
Zend Library
1999-04-08 02:10:10 +08:00
#include "zend_list.h"
- Some header dependencies cleanup - Generalize zval_print() and zval_print_r()
2000-03-26 03:10:07 +08:00
#include "zend_operators.h"
#include "zend_variables.h"
Add optional support for C0x inline semantics. These are enabled by specifying `--enable-c0x-inline' on the command line. We might add an autoconf check for this particular feature later.
2000-06-14 01:58:33 +08:00
#include "zend_execute.h"
Change representation of zend_type from type code to MAY_BE_* mask This switches zend_type from storing a single IS_* type code to storing a MAY_BE_* type mask. Right now most code still assumes that there is only a single type in the mask (or two together with MAY_BE_NULL). But this will make it a lot simpler to introduce union types. An additional advantage (and why I'm doing this separately), is that a number of special cases no longer need to be handled separately: We can do a single mask & (1 << type) check to handle all simple types, booleans (true|false) and null.
2019-09-19 18:11:29 +08:00
#include "zend_type_info.h"
Zend Library
1999-04-08 02:10:10 +08:00
MFZE1 (Expose more C++ APIs)
2002-05-20 15:17:30 +08:00
BEGIN_EXTERN_C()
- Make sure zend_API.h has Zend'ish versions of the ZEND macros so that Zend'ish modules don't need to mix PHP & Zend notation.
2000-03-30 01:13:16 +08:00
ntroduce infrastructure for supplying information about arguments, including: - Whether or not to pass by ref (replaces the old arg_types, with arg_info) - Argument name (for future use, maybe introspection) - Class/Interface name (for type hints) - If a class/interface name is available, whether to allow a null instance Both user and builtin functions share the same data structures. To declare a builtin function that expects its first arg to be an instance of class 'Person', its second argument as a regular arg, and its third by reference, use: ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0) ZEND_ARG_OBJ_INFO(0, someone, Person, 1) ZEND_ARG_PASS_INFO(0) ZEND_ARG_PASS_INFO(1) ZEND_END_ARG_INFO(); and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family of macros. The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref. The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat the arguments for which there's no explicit information as pass by reference or not. The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.
2003-08-04 01:40:44 +08:00
typedef struct _zend_function_entry {
Improved memory usage by movig constants to read only memory. (Dmitry, Pierre)
2007-09-28 02:00:48 +08:00
const char *fname;
Introduced "zif_handler" type (zif = zend internal function).
2017-06-08 21:52:39 +08:00
zif_handler handler;
Use zend_string* for op_array->arg_info[]->name and op_array->arg_info[]->class_name. For internal functions we still use char*.
2014-12-03 21:56:09 +08:00
const struct _zend_internal_arg_info *arg_info;
master renames phase 2
2014-08-26 01:28:33 +08:00
uint32_t num_args;
uint32_t flags;
ntroduce infrastructure for supplying information about arguments, including: - Whether or not to pass by ref (replaces the old arg_types, with arg_info) - Argument name (for future use, maybe introspection) - Class/Interface name (for type hints) - If a class/interface name is available, whether to allow a null instance Both user and builtin functions share the same data structures. To declare a builtin function that expects its first arg to be an instance of class 'Person', its second argument as a regular arg, and its third by reference, use: ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0) ZEND_ARG_OBJ_INFO(0, someone, Person, 1) ZEND_ARG_PASS_INFO(0) ZEND_ARG_PASS_INFO(1) ZEND_END_ARG_INFO(); and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family of macros. The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref. The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat the arguments for which there's no explicit information as pass by reference or not. The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.
2003-08-04 01:40:44 +08:00
} zend_function_entry;
LSB parent/self forwarding
2008-07-24 17:42:18 +08:00
typedef struct _zend_fcall_info {
size_t size;
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
zval function_name;
zval *retval;
zval *params;
Refactored data structures to keep zend_object* instead of a whole zval in some places
2014-03-28 06:11:22 +08:00
zend_object *object;
reduce the struct size by 8 byte on 64 bit
2014-09-12 22:23:24 +08:00
uint32_t param_count;
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
/* This hashtable can also contain positional arguments (with integer keys),
* which will be appended to the normal params[]. This makes it easier to
* integrate APIs like call_user_func_array(). The usual restriction that
* there may not be position arguments after named arguments applies. */
HashTable *named_params;
LSB parent/self forwarding
2008-07-24 17:42:18 +08:00
} zend_fcall_info;
typedef struct _zend_fcall_info_cache {
zend_function *function_handler;
zend_class_entry *calling_scope;
zend_class_entry *called_scope;
Refactored data structures to keep zend_object* instead of a whole zval in some places
2014-03-28 06:11:22 +08:00
zend_object *object;
LSB parent/self forwarding
2008-07-24 17:42:18 +08:00
} zend_fcall_info_cache;
Fix build problem in C++11
2013-01-31 00:08:32 +08:00
#define ZEND_NS_NAME(ns, name) ns "\\" name
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
/* ZEND_FN/ZEND_MN are inlined below to prevent pre-scan macro expansion,
* which causes issues if the function name is also a macro name. */
ntroduce infrastructure for supplying information about arguments, including: - Whether or not to pass by ref (replaces the old arg_types, with arg_info) - Argument name (for future use, maybe introspection) - Class/Interface name (for type hints) - If a class/interface name is available, whether to allow a null instance Both user and builtin functions share the same data structures. To declare a builtin function that expects its first arg to be an instance of class 'Person', its second argument as a regular arg, and its third by reference, use: ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0) ZEND_ARG_OBJ_INFO(0, someone, Person, 1) ZEND_ARG_PASS_INFO(0) ZEND_ARG_PASS_INFO(1) ZEND_END_ARG_INFO(); and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family of macros. The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref. The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat the arguments for which there's no explicit information as pass by reference or not. The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.
2003-08-04 01:40:44 +08:00
#define ZEND_FN(name) zif_##name
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
#define ZEND_MN(name) zim_##name
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
Use "fastcal" calling convention for internal PHP functions on x86
2017-12-11 15:55:15 +08:00
#define ZEND_NAMED_FUNCTION(name) void ZEND_FASTCALL name(INTERNAL_FUNCTION_PARAMETERS)
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
#define ZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(zif_##name)
#define ZEND_METHOD(classname, name) ZEND_NAMED_FUNCTION(zim_##classname##_##name)
ntroduce infrastructure for supplying information about arguments, including: - Whether or not to pass by ref (replaces the old arg_types, with arg_info) - Argument name (for future use, maybe introspection) - Class/Interface name (for type hints) - If a class/interface name is available, whether to allow a null instance Both user and builtin functions share the same data structures. To declare a builtin function that expects its first arg to be an instance of class 'Person', its second argument as a regular arg, and its third by reference, use: ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0) ZEND_ARG_OBJ_INFO(0, someone, Person, 1) ZEND_ARG_PASS_INFO(0) ZEND_ARG_PASS_INFO(1) ZEND_END_ARG_INFO(); and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family of macros. The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref. The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat the arguments for which there's no explicit information as pass by reference or not. The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.
2003-08-04 01:40:44 +08:00
Cache the class_name typehint key in arg_info This leads to up to 2% improvement on one tested real world application by not having to always recalculate the lowercased string and its hash
2015-06-12 23:26:41 +08:00
#define ZEND_FENTRY(zend_name, name, arg_info, flags) { #zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags },
- Add fn_flag ZEND_ACC_ALIAS - Unify way of function_entry generation by new macro ZEND_FENTRY
2003-08-24 19:09:45 +08:00
Cache the class_name typehint key in arg_info This leads to up to 2% improvement on one tested real world application by not having to always recalculate the lowercased string and its hash
2015-06-12 23:26:41 +08:00
#define ZEND_RAW_FENTRY(zend_name, name, arg_info, flags) { zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags },
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
/* Same as ZEND_NAMED_FE */
- Fixed incorrect function names on FreeBSD where inet_pton() was named __inet_pton() and inet_ntop() was named __inet_ntop() - Fixed bug #39685 (iconv() - undefined function) - Fixed bug #38852 (XML-RPC Breaks iconv)
2006-12-20 18:34:36 +08:00
#define ZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0)
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
#define ZEND_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0)
#define ZEND_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, 0)
#define ZEND_DEP_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_DEPRECATED)
#define ZEND_FALIAS(name, alias, arg_info) ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, 0)
#define ZEND_DEP_FALIAS(name, alias, arg_info) ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED)
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
#define ZEND_NAMED_ME(zend_name, name, arg_info, flags) ZEND_FENTRY(zend_name, name, arg_info, flags)
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
#define ZEND_ME(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags)
#define ZEND_DEP_ME(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags | ZEND_ACC_DEPRECATED)
#define ZEND_ABSTRACT_ME(classname, name, arg_info) ZEND_RAW_FENTRY(#name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
Generate method entries from stubs for a couple of extensions Closes GH-5368
2020-04-11 19:27:04 +08:00
#define ZEND_ABSTRACT_ME_WITH_FLAGS(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, NULL, arg_info, flags)
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
#define ZEND_MALIAS(classname, name, alias, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##alias, arg_info, flags)
Add support for generating method entries from stubs Closes GH-5363
2020-04-09 17:27:20 +08:00
#define ZEND_ME_MAPPING(name, func_name, arg_info, flags) ZEND_RAW_FENTRY(#name, zif_##func_name, arg_info, flags)
ntroduce infrastructure for supplying information about arguments, including: - Whether or not to pass by ref (replaces the old arg_types, with arg_info) - Argument name (for future use, maybe introspection) - Class/Interface name (for type hints) - If a class/interface name is available, whether to allow a null instance Both user and builtin functions share the same data structures. To declare a builtin function that expects its first arg to be an instance of class 'Person', its second argument as a regular arg, and its third by reference, use: ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0) ZEND_ARG_OBJ_INFO(0, someone, Person, 1) ZEND_ARG_PASS_INFO(0) ZEND_ARG_PASS_INFO(1) ZEND_END_ARG_INFO(); and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family of macros. The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref. The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat the arguments for which there's no explicit information as pass by reference or not. The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.
2003-08-04 01:40:44 +08:00
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
#define ZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags) ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags)
#define ZEND_NS_RAW_FENTRY(ns, zend_name, name, arg_info, flags) ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, zend_name), name, arg_info, flags)
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
/* Same as ZEND_NS_NAMED_FE */
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
#define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
Fix macro-expansion issues in ZEND_FE and friends I noticed that we have various places where we work around macros conflicting with PHP function names. Rather than require this, fix our ZEND_FE etc macros to avoid pre-scan macro expansion. This requires duplicating the ZEND_FN/ZEND_MN macros in places, but that seems like a reasonable tradeoff.
2020-02-21 22:23:10 +08:00
#define ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
#define ZEND_NS_FE(ns, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##name, arg_info, 0)
#define ZEND_NS_DEP_FE(ns, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##name, arg_info, ZEND_ACC_DEPRECATED)
#define ZEND_NS_FALIAS(ns, name, alias, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##alias, arg_info, 0)
#define ZEND_NS_DEP_FALIAS(ns, name, alias, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED)
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
- Added new macro to be used in the end of zend_function_entry declaration (Gwynne)
2011-07-25 19:30:53 +08:00
#define ZEND_FE_END { NULL, NULL, NULL, 0, 0 }
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
#define _ZEND_ARG_INFO_FLAGS(pass_by_ref, is_variadic) \
(((pass_by_ref) << _ZEND_SEND_MODE_SHIFT) | ((is_variadic) ? _ZEND_IS_VARIADIC_BIT : 0))
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
/* Arginfo structures without type information */
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
#define ZEND_ARG_INFO(pass_by_ref, name) \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ #name, ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), NULL },
#define ZEND_ARG_INFO_WITH_DEFAULT_VALUE(pass_by_ref, name, default_value) \
{ #name, ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), default_value },
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
#define ZEND_ARG_VARIADIC_INFO(pass_by_ref, name) \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ #name, ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(pass_by_ref, 1)), NULL },
/* Arginfo structures with simple type information */
#define ZEND_ARG_TYPE_INFO(pass_by_ref, name, type_hint, allow_null) \
{ #name, ZEND_TYPE_INIT_CODE(type_hint, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), NULL },
#define ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(pass_by_ref, name, type_hint, allow_null, default_value) \
{ #name, ZEND_TYPE_INIT_CODE(type_hint, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), default_value },
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
#define ZEND_ARG_VARIADIC_TYPE_INFO(pass_by_ref, name, type_hint, allow_null) \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ #name, ZEND_TYPE_INIT_CODE(type_hint, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1)), NULL },
/* Arginfo structures with complex type information */
#define ZEND_ARG_TYPE_MASK(pass_by_ref, name, type_mask, default_value) \
{ #name, ZEND_TYPE_INIT_MASK(type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), default_value },
Support class+mask union for internal argument
2020-07-24 22:39:16 +08:00
#define ZEND_ARG_OBJ_TYPE_MASK(pass_by_ref, name, class_name, type_mask, default_value) \
{ #name, ZEND_TYPE_INIT_CLASS_CONST_MASK(#class_name, type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), default_value },
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
/* Arginfo structures with object type information */
#define ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null) \
{ #name, ZEND_TYPE_INIT_CLASS_CONST(#classname, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), NULL },
#define ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(pass_by_ref, name, classname, allow_null, default_value) \
{ #name, ZEND_TYPE_INIT_CLASS_CONST(#classname, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), default_value },
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
#define ZEND_ARG_VARIADIC_OBJ_INFO(pass_by_ref, name, classname, allow_null) \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ #name, ZEND_TYPE_INIT_CLASS_CONST(#classname, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1)), NULL },
/* Legacy arginfo structures */
#define ZEND_ARG_ARRAY_INFO(pass_by_ref, name, allow_null) \
{ #name, ZEND_TYPE_INIT_CODE(IS_ARRAY, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), NULL },
#define ZEND_ARG_CALLABLE_INFO(pass_by_ref, name, allow_null) \
{ #name, ZEND_TYPE_INIT_CODE(IS_CALLABLE, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0)), NULL },
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-27 00:39:17 +08:00
Fixed ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO macro The macro was expanding to a wrong macro and thus leads to compile errors upon usage. Changed it to expand to the correct macro.
2017-05-14 21:43:31 +08:00
#define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(name, return_reference, required_num_args, class_name, allow_null) \
Padding
2015-02-05 16:11:44 +08:00
static const zend_internal_arg_info name[] = { \
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
{ (const char*)(zend_uintptr_t)(required_num_args), \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
ZEND_TYPE_INIT_CLASS_CONST(#class_name, allow_null, _ZEND_ARG_INFO_FLAGS(return_reference, 0)), NULL },
Fixed ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO macro The macro was expanding to a wrong macro and thus leads to compile errors upon usage. Changed it to expand to the correct macro.
2017-05-14 21:43:31 +08:00
Introduced "zend_type" - an abstraction for type-hinting representation.
2017-01-13 16:37:46 +08:00
#define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO(name, class_name, allow_null) \
Fixed ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO macro The macro was expanding to a wrong macro and thus leads to compile errors upon usage. Changed it to expand to the correct macro.
2017-05-14 21:43:31 +08:00
ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(name, 0, -1, class_name, allow_null)
Introduced "zend_type" - an abstraction for type-hinting representation.
2017-01-13 16:37:46 +08:00
Add support for union types in stubs This is the MVP for supporting union types in PHP stubs. Return types with only builtin types work, which is the part we mainly need. Closes GH-4895.
2019-11-08 22:38:00 +08:00
#define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(name, return_reference, required_num_args, type) \
static const zend_internal_arg_info name[] = { \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ (const char*)(zend_uintptr_t)(required_num_args), ZEND_TYPE_INIT_MASK(type | _ZEND_ARG_INFO_FLAGS(return_reference, 0)), NULL },
Add support for union types in stubs This is the MVP for supporting union types in PHP stubs. Return types with only builtin types work, which is the part we mainly need. Closes GH-4895.
2019-11-08 22:38:00 +08:00
Support single class unions in gen stubs
2019-11-15 19:50:44 +08:00
#define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(name, return_reference, required_num_args, class_name, type) \
static const zend_internal_arg_info name[] = { \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ (const char*)(zend_uintptr_t)(required_num_args), ZEND_TYPE_INIT_CLASS_CONST_MASK(#class_name, type | _ZEND_ARG_INFO_FLAGS(return_reference, 0)), NULL },
Support single class unions in gen stubs
2019-11-15 19:50:44 +08:00
Introduced "zend_type" - an abstraction for type-hinting representation.
2017-01-13 16:37:46 +08:00
#define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \
static const zend_internal_arg_info name[] = { \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ (const char*)(zend_uintptr_t)(required_num_args), ZEND_TYPE_INIT_CODE(type, allow_null, _ZEND_ARG_INFO_FLAGS(return_reference, 0)), NULL },
Introduced "zend_type" - an abstraction for type-hinting representation.
2017-01-13 16:37:46 +08:00
#define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO(name, type, allow_null) \
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, 0, -1, type, allow_null)
Implemented internal function return types
2015-02-05 01:04:54 +08:00
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-27 00:39:17 +08:00
#define ZEND_BEGIN_ARG_INFO_EX(name, _unused, return_reference, required_num_args) \
Padding
2015-02-05 16:11:44 +08:00
static const zend_internal_arg_info name[] = { \
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
{ (const char*)(zend_uintptr_t)(required_num_args), ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(return_reference, 0)), NULL },
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-27 00:39:17 +08:00
#define ZEND_BEGIN_ARG_INFO(name, _unused) \
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
ZEND_BEGIN_ARG_INFO_EX(name, {}, ZEND_RETURN_VALUE, -1)
ntroduce infrastructure for supplying information about arguments, including: - Whether or not to pass by ref (replaces the old arg_types, with arg_info) - Argument name (for future use, maybe introspection) - Class/Interface name (for type hints) - If a class/interface name is available, whether to allow a null instance Both user and builtin functions share the same data structures. To declare a builtin function that expects its first arg to be an instance of class 'Person', its second argument as a regular arg, and its third by reference, use: ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0) ZEND_ARG_OBJ_INFO(0, someone, Person, 1) ZEND_ARG_PASS_INFO(0) ZEND_ARG_PASS_INFO(1) ZEND_END_ARG_INFO(); and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family of macros. The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref. The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat the arguments for which there's no explicit information as pass by reference or not. The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.
2003-08-04 01:40:44 +08:00
#define ZEND_END_ARG_INFO() };
Whatnot: * updated alloc_persist to use critical sections * changed extension shutdown to two-phase * updated dependencies * PR support (don't remember if there was any really)
1999-04-18 23:11:52 +08:00
- Merge from Engine 1
2001-08-11 00:19:49 +08:00
/* Name macros */
#define ZEND_MODULE_STARTUP_N(module) zm_startup_##module
#define ZEND_MODULE_SHUTDOWN_N(module) zm_shutdown_##module
#define ZEND_MODULE_ACTIVATE_N(module) zm_activate_##module
#define ZEND_MODULE_DEACTIVATE_N(module) zm_deactivate_##module
- Replaced the exec_finished hook by the zend_post_deactive hook for extensions. The new hook will be run after the symbol table and destructors are run. (Derick)
2004-03-17 06:27:26 +08:00
#define ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module) zm_post_zend_deactivate_##module
- Merge from Engine 1
2001-08-11 00:19:49 +08:00
#define ZEND_MODULE_INFO_N(module) zm_info_##module
MFH: Added automatic module globals management.
2006-06-15 22:03:21 +08:00
#define ZEND_MODULE_GLOBALS_CTOR_N(module) zm_globals_ctor_##module
#define ZEND_MODULE_GLOBALS_DTOR_N(module) zm_globals_dtor_##module
Whatnot: * updated alloc_persist to use critical sections * changed extension shutdown to two-phase * updated dependencies * PR support (don't remember if there was any really)
1999-04-18 23:11:52 +08:00
- Merge from Engine 1
2001-08-11 00:19:49 +08:00
/* Declaration macros */
#define ZEND_MODULE_STARTUP_D(module) int ZEND_MODULE_STARTUP_N(module)(INIT_FUNC_ARGS)
#define ZEND_MODULE_SHUTDOWN_D(module) int ZEND_MODULE_SHUTDOWN_N(module)(SHUTDOWN_FUNC_ARGS)
#define ZEND_MODULE_ACTIVATE_D(module) int ZEND_MODULE_ACTIVATE_N(module)(INIT_FUNC_ARGS)
#define ZEND_MODULE_DEACTIVATE_D(module) int ZEND_MODULE_DEACTIVATE_N(module)(SHUTDOWN_FUNC_ARGS)
- Replaced the exec_finished hook by the zend_post_deactive hook for extensions. The new hook will be run after the symbol table and destructors are run. (Derick)
2004-03-17 06:27:26 +08:00
#define ZEND_MODULE_POST_ZEND_DEACTIVATE_D(module) int ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)(void)
Put phpinfo() related code into cold code segment
2019-05-28 16:04:13 +08:00
#define ZEND_MODULE_INFO_D(module) ZEND_COLD void ZEND_MODULE_INFO_N(module)(ZEND_MODULE_INFO_FUNC_ARGS)
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
#define ZEND_MODULE_GLOBALS_CTOR_D(module) void ZEND_MODULE_GLOBALS_CTOR_N(module)(zend_##module##_globals *module##_globals)
#define ZEND_MODULE_GLOBALS_DTOR_D(module) void ZEND_MODULE_GLOBALS_DTOR_N(module)(zend_##module##_globals *module##_globals)
Whatnot: * updated alloc_persist to use critical sections * changed extension shutdown to two-phase * updated dependencies * PR support (don't remember if there was any really)
1999-04-18 23:11:52 +08:00
Add ZEND_GET_MODULE(name). This is a short-cut for the common get_module function.
2000-05-02 09:33:18 +08:00
#define ZEND_GET_MODULE(name) \
C++ compile fixes
2003-05-20 21:21:26 +08:00
BEGIN_EXTERN_C()\
ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }\
END_EXTERN_C()
Generalize some common thread-safety stuff
2000-04-01 22:15:20 +08:00
#define ZEND_BEGIN_MODULE_GLOBALS(module_name) \
typedef struct _zend_##module_name##_globals {
#define ZEND_END_MODULE_GLOBALS(module_name) \
} zend_##module_name##_globals;
#ifdef ZTS
#define ZEND_DECLARE_MODULE_GLOBALS(module_name) \
- Patch from Jason Greene. - Make it easier to write PHP function definitions in more than just one .c file while accessing the same module globals.
2001-04-20 01:51:23 +08:00
ts_rsrc_id module_name##_globals_id;
#define ZEND_EXTERN_MODULE_GLOBALS(module_name) \
extern ts_rsrc_id module_name##_globals_id;
Generalize some common thread-safety stuff
2000-04-01 22:15:20 +08:00
#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor) \
Get rid of ELS_*(), and use TSRMLS_*() instead. This patch is *bound* to break some files, as I must have had typos somewhere. If you use any uncommon extension, please try to build it...
2001-07-27 18:10:39 +08:00
ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
add unified globals accessor macro
2015-07-29 15:31:10 +08:00
#define ZEND_MODULE_GLOBALS_ACCESSOR(module_name, v) ZEND_TSRMG(module_name##_globals_id, zend_##module_name##_globals *, v)
Fix [-Wundef] warning in Zend folder
2020-05-12 23:52:53 +08:00
#ifdef ZEND_ENABLE_STATIC_TSRMLS_CACHE
improve ZEND_MODULE_GLOBALS_BULK macro, fix data type
2016-06-23 22:47:04 +08:00
#define ZEND_MODULE_GLOBALS_BULK(module_name) TSRMG_BULK_STATIC(module_name##_globals_id, zend_##module_name##_globals *)
#else
add macro to access globals as whole
2015-07-30 14:31:00 +08:00
#define ZEND_MODULE_GLOBALS_BULK(module_name) TSRMG_BULK(module_name##_globals_id, zend_##module_name##_globals *)
improve ZEND_MODULE_GLOBALS_BULK macro, fix data type
2016-06-23 22:47:04 +08:00
#endif
Generalize some common thread-safety stuff
2000-04-01 22:15:20 +08:00
#else
#define ZEND_DECLARE_MODULE_GLOBALS(module_name) \
- Patch from Jason Greene. - Make it easier to write PHP function definitions in more than just one .c file while accessing the same module globals.
2001-04-20 01:51:23 +08:00
zend_##module_name##_globals module_name##_globals;
#define ZEND_EXTERN_MODULE_GLOBALS(module_name) \
extern zend_##module_name##_globals module_name##_globals;
Generalize some common thread-safety stuff
2000-04-01 22:15:20 +08:00
#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor) \
globals_ctor(&module_name##_globals);
add unified globals accessor macro
2015-07-29 15:31:10 +08:00
#define ZEND_MODULE_GLOBALS_ACCESSOR(module_name, v) (module_name##_globals.v)
add macro to access globals as whole
2015-07-30 14:31:00 +08:00
#define ZEND_MODULE_GLOBALS_BULK(module_name) (&module_name##_globals)
Generalize some common thread-safety stuff
2000-04-01 22:15:20 +08:00
#endif
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
#define INIT_CLASS_ENTRY(class_container, class_name, functions) \
Removed INIT_OVERLOADED_CLASS... macros
2018-06-29 19:41:35 +08:00
INIT_CLASS_ENTRY_EX(class_container, class_name, sizeof(class_name)-1, functions)
* Support getThis() for internal functions. * Fix 'new object or die' and AiCount issue thoroughly (earlier fix didn't work with the optimizer). * Add new macros for standardized definition of classes. * Only report AiCount problems if shutdown was not silent.
1999-05-28 20:06:59 +08:00
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
#define INIT_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions) \
* Support getThis() for internal functions. * Fix 'new object or die' and AiCount issue thoroughly (earlier fix didn't work with the optimizer). * Add new macros for standardized definition of classes. * Only report AiCount problems if shutdown was not silent.
1999-05-28 20:06:59 +08:00
{ \
Improved user iterator implementation to reduce zend_class_entry memory consumption and avoid race condition during resolving/caching of user iterator functions of internal classes in ZTS build.
2018-07-12 19:04:14 +08:00
memset(&class_container, 0, sizeof(zend_class_entry)); \
Extend zend_string API to avoid reallocation in zend_string_init_interned()
2017-10-19 05:02:56 +08:00
class_container.name = zend_string_init_interned(class_name, class_name_len, 1); \
Improved user iterator implementation to reduce zend_class_entry memory consumption and avoid race condition during resolving/caching of user iterator functions of internal classes in ZTS build.
2018-07-12 19:04:14 +08:00
class_container.info.internal.builtin_functions = functions; \
Fixed bug #62744 (dangling pointers made by zend_disable_class) the test will be added while commit the fix for #62737
2012-08-04 10:41:26 +08:00
}
Removed INIT_OVERLOADED_CLASS... macros
2018-06-29 19:41:35 +08:00
#define INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions) \
Fixed bug #62744 (dangling pointers made by zend_disable_class) the test will be added while commit the fix for #62737
2012-08-04 10:41:26 +08:00
{ \
- Add some initializations
2001-11-03 20:19:52 +08:00
class_container.constructor = NULL; \
- Experimental support for destructors. We need to see if destructors - will actually work well in the context of PHP so we should consider this - as experimental. Possible problems might be that when the constructor is - run PHP might not be in a stable state.
2001-12-27 22:35:09 +08:00
class_container.destructor = NULL; \
- Pretty much finish _clone() support
2001-12-27 03:54:20 +08:00
class_container.clone = NULL; \
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
class_container.serialize = NULL; \
class_container.unserialize = NULL; \
class_container.create_object = NULL; \
Added support for __callstatic() magic method (missing part). (Sara)
2007-09-29 17:34:24 +08:00
class_container.get_static_method = NULL; \
Removed INIT_OVERLOADED_CLASS... macros
2018-06-29 19:41:35 +08:00
class_container.__call = NULL; \
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
class_container.__callstatic = NULL; \
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
class_container.__tostring = NULL; \
Removed INIT_OVERLOADED_CLASS... macros
2018-06-29 19:41:35 +08:00
class_container.__get = NULL; \
class_container.__set = NULL; \
class_container.__unset = NULL; \
class_container.__isset = NULL; \
class_container.__debugInfo = NULL; \
Cache __unserialize() instead of unserialize() We should use these cache slots for the new object serialization mechanism rather than the old one.
2020-06-26 16:54:40 +08:00
class_container.__serialize = NULL; \
class_container.__unserialize = NULL; \
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
class_container.parent = NULL; \
class_container.num_interfaces = 0; \
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
class_container.trait_names = NULL; \
- Missing traits data initialization for internal classes (causing Reflection to crash)
2010-08-14 09:12:43 +08:00
class_container.num_traits = 0; \
class_container.trait_aliases = NULL; \
class_container.trait_precedences = NULL; \
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
class_container.interfaces = NULL; \
class_container.get_iterator = NULL; \
Improved user iterator implementation to reduce zend_class_entry memory consumption and avoid race condition during resolving/caching of user iterator functions of internal classes in ZTS build.
2018-07-12 19:04:14 +08:00
class_container.iterator_funcs_ptr = NULL; \
- Improved memory usage . zend_function.pass_rest_by_reference is replaced by ZEND_ACC_PASS_REST_BY_REFERENCE in zend_function.fn_flags . zend_function.return_reference is replaced by ZEND_ACC_RETURN_REFERENCE in zend_function.fn_flags . zend_arg_info.required_num_args removed. it was needed only for internal functions. Now the first arg_info for internal function (which has special meaning) is represented by zend_internal_function_info structure. . zend_op_array.size, size_var, size_literal, current_brk_cont, backpatch_count moved into CG(context), because they are used only during compilation. . zend_op_array.start_op is moved into EG(start_op), because it's used only for 'interactive' execution of single top-level op-array. . zend_op_array.done_pass_two is replaced by ZEND_ACC_DONE_PASS_TWO in zend_op_array.fn_flags. . op_array.vars array is trimmed (reallocated) during pass_two. . zend_class_entry.constants_updated is replaced by ZEND_ACC_CONSTANTS_UPDATED in zend_class_entry.ce_flags . the size of zend_class_entry is reduced by sharing the same memory space by different information for internal and user classes. See zend_class_inttry.info union.
2010-09-15 15:38:52 +08:00
class_container.info.internal.module = NULL; \
class_container.info.internal.builtin_functions = functions; \
* Support getThis() for internal functions. * Fix 'new object or die' and AiCount issue thoroughly (earlier fix didn't work with the optimizer). * Add new macros for standardized definition of classes. * Only report AiCount problems if shutdown was not silent.
1999-05-28 20:06:59 +08:00
}
Fixed bug #33512 (Add missing support for isset()/unset() overloading to complement the property get/set methods)
2005-07-08 00:07:09 +08:00
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
#define INIT_NS_CLASS_ENTRY(class_container, ns, class_name, functions) \
INIT_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions)
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
#define CE_STATIC_MEMBERS(ce) \
((zval*)ZEND_MAP_PTR_GET((ce)->static_members_table))
Fixed bug #34729 (Crash in ZTS mode under Apache)
2005-12-01 19:48:17 +08:00
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
#define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0)
DLL export several APIs needed for phpdbg
2014-10-13 01:22:03 +08:00
ZEND_API int zend_next_free_module(void);
Zend Library
1999-04-08 02:10:10 +08:00
more EXTERN_C wrapping of ZEND_API prototypes
2004-02-20 16:03:27 +08:00
BEGIN_EXTERN_C()
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API int _zend_get_parameters_array_ex(uint32_t param_count, zval *argument_array);
Get rid of more TSRMLS_FETCH's
2001-07-30 10:07:52 +08:00
Simplify/Optmize magic method calls (__get/__set/__call/__clone/__destruct)
2004-09-29 06:55:22 +08:00
/* internal function to efficiently copy parameters when executing __call() */
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API int zend_copy_parameters_array(uint32_t param_count, zval *argument_array);
Simplify/Optmize magic method calls (__get/__set/__call/__clone/__destruct)
2004-09-29 06:55:22 +08:00
Short-circuit zend_parse_parameters_none() so that expensive zpp() call never happens in non-exceptional case
2015-09-20 08:43:22 +08:00
#define zend_get_parameters_array(ht, param_count, argument_array) \
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
_zend_get_parameters_array_ex(param_count, argument_array)
Short-circuit zend_parse_parameters_none() so that expensive zpp() call never happens in non-exceptional case
2015-09-20 08:43:22 +08:00
#define zend_get_parameters_array_ex(param_count, argument_array) \
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
_zend_get_parameters_array_ex(param_count, argument_array)
Short-circuit zend_parse_parameters_none() so that expensive zpp() call never happens in non-exceptional case
2015-09-20 08:43:22 +08:00
#define zend_parse_parameters_none() \
Eliminate useless checks
2019-07-05 19:21:18 +08:00
(EXPECTED(ZEND_NUM_ARGS() == 0) ? SUCCESS : (zend_wrong_parameters_none_error(), FAILURE))
Added zend_parse_parameters_none_throw()
2017-05-26 23:29:50 +08:00
#define zend_parse_parameters_none_throw() \
Make zpp failures always throw, independent of strict_types Previously zend_parse_parameters (and FastZPP) would handle invalid arguments depending on strict_types: With strict_types=1, a TypeError is thrown, with strict_types=0 a warning is thrown and (usually) NULL is returned. Additionally, some functions (constructors always and other methods sometimes) opt-it to throwing regardless of strict_types. This commit changes zpp to always generate a TypeError exception in PHP 8.
2019-02-05 17:07:07 +08:00
zend_parse_parameters_none()
Adding new parameter parsing API.
2001-07-10 02:51:29 +08:00
/* Parameter parsing API -- andrei */
Make zpp failures always throw, independent of strict_types Previously zend_parse_parameters (and FastZPP) would handle invalid arguments depending on strict_types: With strict_types=1, a TypeError is thrown, with strict_types=0 a warning is thrown and (usually) NULL is returned. Additionally, some functions (constructors always and other methods sometimes) opt-it to throwing regardless of strict_types. This commit changes zpp to always generate a TypeError exception in PHP 8.
2019-02-05 17:07:07 +08:00
#define ZEND_PARSE_PARAMS_THROW 0 /* No longer used, zpp always uses exceptions */
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
#define ZEND_PARSE_PARAMS_QUIET (1<<1)
Refactor ZPP API to use uint32_t as everywhere else Closes GH-5609
2020-05-21 05:46:09 +08:00
ZEND_API int zend_parse_parameters(uint32_t num_args, const char *type_spec, ...);
ZEND_API int zend_parse_parameters_ex(int flags, uint32_t num_args, const char *type_spec, ...);
Fix compile error using zend_parse_parameters_throw() Fixes a bug introduced in 4008704f62 The trailing comma is followed by `)` when the varargs list is empty in the macro, which is a syntax error in C This fixes compilation of code such as the following PHP_FUNCTION(get_metadata) { if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "") == FAILURE) { return; } Closes GH-4896.
2019-11-08 22:58:05 +08:00
/* NOTE: This must have at least one value in __VA_ARGS__ for the expression to be valid */
#define zend_parse_parameters_throw(num_args, ...) \
zend_parse_parameters(num_args, __VA_ARGS__)
Constify some char* arguments or return values of ZEND_API Closes GH-4247.
2019-05-26 13:53:26 +08:00
ZEND_API const char *zend_zval_type_name(const zval *arg);
Rename zend_zval_get_type() API We have a bunch of APIs for getting type names and it's sometimes hard to keep them apart ... make it clear that this is the one you definitely do not want to use.
2020-05-13 20:46:15 +08:00
ZEND_API zend_string *zend_zval_get_legacy_type(const zval *arg);
Adding new parameter parsing API.
2001-07-10 02:51:29 +08:00
Refactor ZPP API to use uint32_t as everywhere else Closes GH-5609
2020-05-21 05:46:09 +08:00
ZEND_API int zend_parse_method_parameters(uint32_t num_args, zval *this_ptr, const char *type_spec, ...);
ZEND_API int zend_parse_method_parameters_ex(int flags, uint32_t num_args, zval *this_ptr, const char *type_spec, ...);
extend the parameter parsing API by two functions for parsing method parameters with automatic detection if the function was called as such or as a class method (with a valid this ptr). if called as a function the first parameter has to be the object it is operating on, if called as a method this is used. #not yet testet, only commiting so that georg can #continue working on ext/mysqli
2003-02-03 07:30:14 +08:00
Refactor ZPP API to use uint32_t as everywhere else Closes GH-5609
2020-05-21 05:46:09 +08:00
ZEND_API int zend_parse_parameter(int flags, uint32_t arg_num, zval *arg, const char *spec, ...);
Expose zend_parse_arg() as zend_parse_parameter() Sometimes, one wants to accept several types for a given parameter. zpp has special functionality for detecting the NULL type, since the NULL type is frequently used to skip parameters. However, supporting several types is otherwise very tedious. There are many cases where this situation arises -- for instance one may want to accept an arbitrary number of integer and expect them in an array, but allow a bare integer too; one may want to accept something that will be used as an array key (which can be either and int or a string); one may want to accept integer and double numbers. A search for IS_LONG reveals many situations where this need arises. The usual solution is to fetch the argument with 'z'/'Z', check its type, and then convert the argument, e.g. with convert_to_long_ex(). As explain in the last commit, this has different behavior and generates inconsistency. Another -- even more flawed strategy --, is to try zpp with a specific format, forcing it quiet, and if it fails retrying with another form. But because zpp changes the arguments directly in the stack (for instance, using "l" converts the zval in the stack to IS_LONG), the arguments may look different after the first zpp, leaving subtle bugs. This commit also allows more complex scenarios, for instance where the expected type of one parameter depends on other parameters.
2012-07-19 04:05:42 +08:00
More TSRMLS_FETCH work, and get rid of redundant ParametersPassedByRef
2001-07-30 13:34:21 +08:00
/* End of parameter parsing API -- andrei */
-Tiny patches
1999-04-15 03:53:33 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type);
ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table);
ZEND_API int zend_startup_module(zend_module_entry *module_entry);
ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *module_entry);
ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module);
ZEND_API int zend_startup_module_ex(zend_module_entry *module);
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void zend_startup_modules(void);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API void zend_collect_module_handlers(void);
eliminated unnecessary iterations during request startup/shutdown
2010-07-06 19:40:17 +08:00
ZEND_API void zend_destroy_modules(void);
Pass existing lcname to check_magic_method_implementation
2020-04-27 18:33:29 +08:00
ZEND_API void zend_check_magic_method_implementation(
const zend_class_entry *ce, const zend_function *fptr, zend_string *lcname, int error_type);
Add common code for magic method assignment This was repeated three times.
2020-07-20 20:56:48 +08:00
ZEND_API void zend_add_magic_method(zend_class_entry *ce, zend_function *fptr, zend_string *lcname);
- Andrei, this is for you! - Add zend_register_internal_class_ex() which allows you to specify a - parent to inherit from. You can either specify the parent directly or via - its name.
2000-06-09 22:40:14 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry);
ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce);
ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry);
ZEND_API void zend_class_implements(zend_class_entry *class_entry, int num_interfaces, ...);
- Andrei, this is for you! - Add zend_register_internal_class_ex() which allows you to specify a - parent to inherit from. You can either specify the parent directly or via - its name.
2000-06-09 22:40:14 +08:00
Extend zend_register_class_alias_ex() with additional argument to allow creating persistent or per-request aliases
2017-10-27 19:44:21 +08:00
ZEND_API int zend_register_class_alias_ex(const char *name, size_t name_len, zend_class_entry *ce, int persistent);
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
Fixed unintended API break
2018-02-19 18:11:39 +08:00
#define zend_register_class_alias(name, ce) \
zend_register_class_alias_ex(name, sizeof(name)-1, ce, 1)
#define zend_register_ns_class_alias(ns, name, ce) \
zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce, 1)
Added API to use namesapces in internal extensions
2008-05-12 15:11:55 +08:00
Constify char * arguments of APIs Closes GH-5676.
2020-06-07 17:01:19 +08:00
ZEND_API int zend_disable_function(const char *function_name, size_t function_name_length);
ZEND_API int zend_disable_class(const char *class_name, size_t class_name_length);
Zend Library
1999-04-08 02:10:10 +08:00
Mark error and exception functions as "cold" (Matt's idea)
2015-08-19 19:40:56 +08:00
ZEND_API ZEND_COLD void zend_wrong_param_count(void);
Fixed bug #29210 (Function: is_callable - no support for private and protected classes)
2005-04-27 23:45:36 +08:00
#define IS_CALLABLE_CHECK_SYNTAX_ONLY (1<<0)
Fixed is_callable/call_user_func mess that had done different things for very similar arguments e.g. array("A","B") and "A::B"
2008-07-26 21:14:04 +08:00
#define IS_CALLABLE_CHECK_SILENT (1<<3)
Fixed bug #29210 (Function: is_callable - no support for private and protected classes)
2005-04-27 23:45:36 +08:00
Fixed bug #74345 Export zend_release_fcall_info_cache(). It is only necessary to call it if the fcc may not have been used -- if it is passed to zend_call_function() and friends, then they will take care of freeing trampolines.
2019-03-20 19:03:45 +08:00
ZEND_API void zend_release_fcall_info_cache(zend_fcall_info_cache *fcc);
Extract zend_get_callable_name() API Instead of interleaving this inside zend_is_callable(), implement this in a separate function instead. Also add _deref() hash APIs. I've wanted these for a while, and this is another place where they're useful, so finally do it...
2017-06-25 23:55:56 +08:00
ZEND_API zend_string *zend_get_callable_name_ex(zval *callable, zend_object *object);
ZEND_API zend_string *zend_get_callable_name(zval *callable);
further normalizations, uint vs uint32_t fix merge mistake yet one more replacement run
2016-11-26 22:18:42 +08:00
ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint32_t check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error);
ZEND_API zend_bool zend_is_callable(zval *callable, uint32_t check_flags, zend_string **callable_name);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_name);
Improved memory usage by movig constants to read only memory. (Dmitry, Pierre)
2007-09-28 02:00:48 +08:00
ZEND_API const char *zend_get_module_version(const char *module_name);
- MFH: Constness (Added const qualifier to several function parameters)
2008-08-13 01:20:25 +08:00
ZEND_API int zend_get_module_started(const char *module_name);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment);
ZEND_API void zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type);
ZEND_API void zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, int access_type);
ZEND_API void zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type);
ZEND_API void zend_declare_property_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type);
ZEND_API void zend_declare_property_double(zend_class_entry *ce, const char *name, size_t name_length, double value, int access_type);
ZEND_API void zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, int access_type);
ZEND_API void zend_declare_property_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_len, int access_type);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
ZEND_API zend_class_constant *zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment);
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value);
ZEND_API void zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length);
ZEND_API void zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value);
ZEND_API void zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value);
ZEND_API void zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value);
ZEND_API void zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length);
ZEND_API void zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
Convert fatal errors into EngineExceptions Make zval_update_constant_ex(), zval_update_constant(), zend_update_class_constants() and zend_ast_evaluate() return SUCCESS or FAILURE.
2015-04-02 07:05:25 +08:00
ZEND_API int zend_update_class_constants(zend_class_entry *class_type);
Accept zend_object* in zend_update_property
2020-08-07 21:27:57 +08:00
ZEND_API void zend_update_property_ex(zend_class_entry *scope, zend_object *object, zend_string *name, zval *value);
ZEND_API void zend_update_property(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, zval *value);
ZEND_API void zend_update_property_null(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length);
ZEND_API void zend_update_property_bool(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, zend_long value);
ZEND_API void zend_update_property_long(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, zend_long value);
ZEND_API void zend_update_property_double(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, double value);
ZEND_API void zend_update_property_str(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, zend_string *value);
ZEND_API void zend_update_property_string(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, const char *value);
ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, const char *value, size_t value_length);
Accept zend_object* in zend_unset_property
2020-08-07 21:17:59 +08:00
ZEND_API void zend_unset_property(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
Add zend_update_static_property_ex API And cleanup the implementation to perform a normal by-value assignment.
2018-06-30 04:56:47 +08:00
ZEND_API int zend_update_static_property_ex(zend_class_entry *scope, zend_string *name, zval *value);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, size_t name_length, zval *value);
ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, size_t name_length);
ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, size_t name_length, zend_long value);
ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, size_t name_length, zend_long value);
ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, size_t name_length, double value);
ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, size_t name_length, const char *value);
ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const char *name, size_t name_length, const char *value, size_t value_length);
Accept zend_object in zend_read_property
2020-08-07 21:05:24 +08:00
ZEND_API zval *zend_read_property_ex(zend_class_entry *scope, zend_object *object, zend_string *name, zend_bool silent, zval *rv);
ZEND_API zval *zend_read_property(zend_class_entry *scope, zend_object *object, const char *name, size_t name_length, zend_bool silent, zval *rv);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
Add zend_read_static_property_ex API For symmetry with zend_read_property_ex.
2018-06-30 04:49:15 +08:00
ZEND_API zval *zend_read_static_property_ex(zend_class_entry *scope, zend_string *name, zend_bool silent);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, size_t name_length, zend_bool silent);
Support for class constants and static members for internal classes
2005-09-01 18:05:32 +08:00
Constify some char* arguments or return values of ZEND_API Closes GH-4247.
2019-05-26 13:53:26 +08:00
ZEND_API const char *zend_get_type_by_const(int type);
added get_class_entry callback handler to the object handlers structure
2002-04-22 22:22:27 +08:00
Use ZEND_THIS macro to hide implementation details in extensions code.
2018-11-16 00:54:19 +08:00
#define ZEND_THIS (&EX(This))
#define getThis() ((Z_TYPE_P(ZEND_THIS) == IS_OBJECT) ? ZEND_THIS : NULL)
Fix procedural finfo calls in methods getThis() will return the $this of the calling method.
2014-10-16 20:24:23 +08:00
#define ZEND_IS_METHOD_CALL() (EX(func)->common.scope != NULL)
* Support getThis() for internal functions. * Fix 'new object or die' and AiCount issue thoroughly (earlier fix didn't work with the optimizer). * Add new macros for standardized definition of classes. * Only report AiCount problems if shutdown was not silent.
1999-05-28 20:06:59 +08:00
Clean up API renames for zend_wrong_param_count to maintain BC, introducing a zend_wrong_param_count_ex() function when you know strict value
2015-03-19 03:42:49 +08:00
#define WRONG_PARAM_COUNT ZEND_WRONG_PARAM_COUNT()
Style cleanup, as well as fixing bug with missing argument for WRONG_PARAM_COUNT_WITH_RETVAL
2015-03-19 03:45:16 +08:00
#define WRONG_PARAM_COUNT_WITH_RETVAL(ret) ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 15:28:49 +08:00
#define ZEND_NUM_ARGS() EX_NUM_ARGS()
Style cleanup, as well as fixing bug with missing argument for WRONG_PARAM_COUNT_WITH_RETVAL
2015-03-19 03:45:16 +08:00
#define ZEND_WRONG_PARAM_COUNT() { zend_wrong_param_count(); return; }
Clean up API renames for zend_wrong_param_count to maintain BC, introducing a zend_wrong_param_count_ex() function when you know strict value
2015-03-19 03:42:49 +08:00
#define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret) { zend_wrong_param_count(); return ret; }
Zend Library
1999-04-08 02:10:10 +08:00
Fine tune Andi's patch
2000-02-11 23:59:30 +08:00
#ifndef ZEND_WIN32
Zend Library
1999-04-08 02:10:10 +08:00
#define DLEXPORT
#endif
Refactored array creation API. array_init() and array_init_size() are converted into macros calling zend_new_array(). They are not functions anymore and don't return any values.
2017-09-20 07:25:56 +08:00
#define array_init(arg) ZVAL_ARR((arg), zend_new_array(0))
#define array_init_size(arg, size) ZVAL_ARR((arg), zend_new_array(size))
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void object_init(zval *arg);
API cleanup. Removed useless filename and lineno arguments, used in DEBUG build. The patch doesn't break source compatibility of public API (only binary compatibility).
2018-07-23 20:24:07 +08:00
ZEND_API int object_init_ex(zval *arg, zend_class_entry *ce);
ZEND_API int object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 22:11:39 +08:00
ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties);
ZEND_API void object_properties_load(zend_object *object, HashTable *properties);
added add_*_resource() and add_*_bool() functions
1999-10-04 19:42:46 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API void zend_merge_properties(zval *obj, HashTable *properties);
- Add zend_merge_properties() which is designed to serve *_fetch_object(). - Explain drawbacks of object_and_properties_init and zend_merge_properties. # # I guess we can live with the purity problem of potentially calling __set() # of an object which wasn't already ctored. #
2003-08-30 07:27:22 +08:00
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void add_assoc_long_ex(zval *arg, const char *key, size_t key_len, zend_long n);
ZEND_API void add_assoc_null_ex(zval *arg, const char *key, size_t key_len);
ZEND_API void add_assoc_bool_ex(zval *arg, const char *key, size_t key_len, int b);
ZEND_API void add_assoc_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r);
ZEND_API void add_assoc_double_ex(zval *arg, const char *key, size_t key_len, double d);
ZEND_API void add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str);
ZEND_API void add_assoc_string_ex(zval *arg, const char *key, size_t key_len, const char *str);
ZEND_API void add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length);
ZEND_API void add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
move key lengths to use size_t as zend_string is used internally anyway
2014-10-23 14:52:59 +08:00
#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n)
#define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key))
#define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key), __b)
#define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key), __r)
#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key), __d)
#define add_assoc_str(__arg, __key, __str) add_assoc_str_ex(__arg, __key, strlen(__key), __str)
#define add_assoc_string(__arg, __key, __str) add_assoc_string_ex(__arg, __key, strlen(__key), __str)
#define add_assoc_stringl(__arg, __key, __str, __length) add_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key), __value)
added add_*_resource() and add_*_bool() functions
1999-10-04 19:42:46 +08:00
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void add_index_long(zval *arg, zend_ulong index, zend_long n);
ZEND_API void add_index_null(zval *arg, zend_ulong index);
ZEND_API void add_index_bool(zval *arg, zend_ulong index, int b);
ZEND_API void add_index_resource(zval *arg, zend_ulong index, zend_resource *r);
ZEND_API void add_index_double(zval *arg, zend_ulong index, double d);
ZEND_API void add_index_str(zval *arg, zend_ulong index, zend_string *str);
ZEND_API void add_index_string(zval *arg, zend_ulong index, const char *str);
ZEND_API void add_index_stringl(zval *arg, zend_ulong index, const char *str, size_t length);
Turn add_index_zval and add_next_index_zval into inline function Avoids expression warnings and allows explicitly namespaced use in C++. Closes GH-4250.
2019-06-11 22:07:32 +08:00
static zend_always_inline int add_index_zval(zval *arg, zend_ulong index, zval *value)
{
return zend_hash_index_update(Z_ARRVAL_P(arg), index, value) ? SUCCESS : FAILURE;
}
master renames phase 1
2014-08-26 01:24:55 +08:00
ZEND_API int add_next_index_long(zval *arg, zend_long n);
- Change unset() functions to null(). unset() is legacy
2001-02-01 05:53:30 +08:00
ZEND_API int add_next_index_null(zval *arg);
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API int add_next_index_bool(zval *arg, zend_bool b);
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
ZEND_API int add_next_index_resource(zval *arg, zend_resource *r);
Zend Library
1999-04-08 02:10:10 +08:00
ZEND_API int add_next_index_double(zval *arg, double d);
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
ZEND_API int add_next_index_str(zval *arg, zend_string *str);
Cleanup (1-st round)
2014-04-15 19:40:40 +08:00
ZEND_API int add_next_index_string(zval *arg, const char *str);
make array/object APIs accept large strings as values of elements/props
2014-08-29 01:17:47 +08:00
ZEND_API int add_next_index_stringl(zval *arg, const char *str, size_t length);
Replace add_index_zval() and add_next_index_zval() functions by macros
2018-12-19 21:43:38 +08:00
Turn add_index_zval and add_next_index_zval into inline function Avoids expression warnings and allows explicitly namespaced use in C++. Closes GH-4250.
2019-06-11 22:07:32 +08:00
static zend_always_inline int add_next_index_zval(zval *arg, zval *value)
{
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), value) ? SUCCESS : FAILURE;
}
- Patch from Sterling. Add API calls to add zval's as array indeces/ object properties. Add _ex functions which take the string length as an argument for better performance.
2001-01-21 03:16:38 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
Add support for non-scalar Iterator keys in foreach RFC: https://wiki.php.net/rfc/foreach-non-scalar-keys
2013-02-17 02:13:36 +08:00
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API void add_property_long_ex(zval *arg, const char *key, size_t key_len, zend_long l);
ZEND_API void add_property_null_ex(zval *arg, const char *key, size_t key_len);
ZEND_API void add_property_bool_ex(zval *arg, const char *key, size_t key_len, zend_long b);
ZEND_API void add_property_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r);
ZEND_API void add_property_double_ex(zval *arg, const char *key, size_t key_len, double d);
ZEND_API void add_property_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str);
ZEND_API void add_property_string_ex(zval *arg, const char *key, size_t key_len, const char *str);
ZEND_API void add_property_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length);
ZEND_API void add_property_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
move key lengths to use size_t as zend_string is used internally anyway
2014-10-23 14:52:59 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key), __n)
#define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key))
#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b)
#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r)
#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key), __d)
#define add_property_str(__arg, __key, __str) add_property_str_ex(__arg, __key, strlen(__key), __str)
#define add_property_string(__arg, __key, __str) add_property_string_ex(__arg, __key, strlen(__key), __str)
#define add_property_stringl(__arg, __key, __str, __length) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length)
#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value)
- Patch from Sterling. Add API calls to add zval's as array indeces/ object properties. Add _ex functions which take the string length as an argument for better performance.
2001-01-21 03:16:38 +08:00
Try to put an end to the endless number of call_user_function variants. zend_call_function() now takes a structure that should contain all of the necessary information. If further information is necessary in the future, then we'll be able to add it without having to introduce a new function. As for caching - the 2nd, optional argument is a struct that can hold all of the information that's necessary to invoke the function, including its handler, scope and object it operates on (if any). Note that you may only use a cache if the arguments you provide to zend_call_function() are identical to the ones of the last call, except for the argument and return value information. The recently introduced fast_call_user_function() was removed I fixed most of the places that used fast_call_user_function() to use caching but there are still some that need to be fixed (XML and reflection)
2003-08-05 18:24:40 +08:00
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
ZEND_API int _call_user_function_impl(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], HashTable *named_params);
Removed zend_fcall_info.symbol_table
2016-03-02 22:50:55 +08:00
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
#define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \
_call_user_function_impl(object, function_name, retval_ptr, param_count, params, NULL)
#define call_user_function_named(function_table, object, function_name, retval_ptr, param_count, params, named_params) \
_call_user_function_impl(object, function_name, retval_ptr, param_count, params, named_params)
Try to put an end to the endless number of call_user_function variants. zend_call_function() now takes a structure that should contain all of the necessary information. If further information is necessary in the future, then we'll be able to add it without having to introduce a new function. As for caching - the 2nd, optional argument is a struct that can hold all of the information that's necessary to invoke the function, including its handler, scope and object it operates on (if any). Note that you may only use a cache if the arguments you provide to zend_call_function() are identical to the ones of the last call, except for the argument and return value information. The recently introduced fast_call_user_function() was removed I fixed most of the places that used fast_call_user_function() to use caching but there are still some that need to be fixed (XML and reflection)
2003-08-05 18:24:40 +08:00
mark empty_fcall_info and empty_fcall_info_cache as constant. a few less bytes in the dirty page :P
2008-08-13 05:45:52 +08:00
ZEND_API extern const zend_fcall_info empty_fcall_info;
ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache;
Try to put an end to the endless number of call_user_function variants. zend_call_function() now takes a structure that should contain all of the necessary information. If further information is necessary in the future, then we'll be able to add it without having to introduce a new function. As for caching - the 2nd, optional argument is a struct that can hold all of the information that's necessary to invoke the function, including its handler, scope and object it operates on (if any). Note that you may only use a cache if the arguments you provide to zend_call_function() are identical to the ones of the last call, except for the argument and return value information. The recently introduced fast_call_user_function() was removed I fixed most of the places that used fast_call_user_function() to use caching but there are still some that need to be fixed (XML and reflection)
2003-08-05 18:24:40 +08:00
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
/** Build zend_call_info/cache from a zval*
*
correct wording
2016-05-05 00:04:38 +08:00
* Caller is responsible to provide a return value (fci->retval), otherwise the we will crash.
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
* In order to pass parameters the following members need to be set:
* fci->param_count = 0;
* fci->params = NULL;
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
* The callable_name argument may be NULL.
*/
further normalizations, uint vs uint32_t fix merge mistake yet one more replacement run
2016-11-26 22:18:42 +08:00
ZEND_API int zend_fcall_info_init(zval *callable, uint32_t check_flags, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_string **callable_name, char **error);
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
typo fixes (argument)
2013-04-22 21:05:24 +08:00
/** Clear arguments connected with zend_fcall_info *fci
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
* If free_mem is not zero then the params array gets free'd as well
*/
ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);
/** Save current arguments from zend_fcall_info *fci
* params array will be set to NULL
*/
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, uint32_t *param_count, zval **params);
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
/** Free arguments connected with zend_fcall_info *fci andset back saved ones.
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
*/
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, uint32_t param_count, zval *params);
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
/** Set or clear the arguments in the zend_call_info struct taking care of
* refcount. If args is NULL and arguments are set then those are cleared.
*/
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args);
ZEND_API int zend_fcall_info_args_ex(zend_fcall_info *fci, zend_function *func, zval *args);
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
/** Set arguments in the zend_fcall_info struct taking care of refcount.
* If argc is 0 the arguments which are set will be cleared, else pass
* a variable amount of zval** arguments.
*/
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API void zend_fcall_info_argp(zend_fcall_info *fci, uint32_t argc, zval *argv);
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
/** Set arguments in the zend_fcall_info struct taking care of refcount.
* If argc is 0 the arguments which are set will be cleared, else pass
* a variable amount of zval** arguments.
*/
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API void zend_fcall_info_argv(zend_fcall_info *fci, uint32_t argc, va_list *argv);
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
/** Set arguments in the zend_fcall_info struct taking care of refcount.
* If argc is 0 the arguments which are set will be cleared, else pass
* a variable amount of zval** arguments.
*/
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API void zend_fcall_info_argn(zend_fcall_info *fci, uint32_t argc, ...);
- MFH from HEAD: . Folding tags . Parameter parsing . SPL debug info . array function improvements (not all yet) . Improvements to function calling with call_user_* functions . Improvements to debugging info in var_dump/print_r # I propably forgot already something but this all was pretty close tied # to each other so it wasn't possible to do it in parts.
2007-11-03 03:40:39 +08:00
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
/** Call a function using information created by zend_fcall_info_init()/args().
typo fixes (argument)
2013-04-22 21:05:24 +08:00
* If args is given then those replace the argument info in fci is temporarily.
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
*/
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval *retval, zval *args);
- MFH zend_fcall_info_*() and parameter parsing option 'f' # Right now i see this as the best option but we might shuffle code around # later if someone comes up with a better solution.
2006-06-07 17:43:54 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache);
Try to put an end to the endless number of call_user_function variants. zend_call_function() now takes a structure that should contain all of the necessary information. If further information is necessary in the future, then we'll be able to add it without having to introduce a new function. As for caching - the 2nd, optional argument is a struct that can hold all of the information that's necessary to invoke the function, including its handler, scope and object it operates on (if any). Note that you may only use a cache if the arguments you provide to zend_call_function() are identical to the ones of the last call, except for the argument and return value information. The recently introduced fast_call_user_function() was removed I fixed most of the places that used fast_call_user_function() to use caching but there are still some that need to be fixed (XML and reflection)
2003-08-05 18:24:40 +08:00
Add zend_call_known_function() API family This adds the following APIs: void zend_call_known_function( zend_function *fn, zend_object *object, zend_class_entry *called_scope, zval *retval_ptr, int param_count, zval *params); void zend_call_known_instance_method( zend_function *fn, zend_object *object, zval *retval_ptr, int param_count, zval *params); void zend_call_known_instance_method_with_0_params( zend_function *fn, zend_object *object, zval *retval_ptr); void zend_call_known_instance_method_with_1_params( zend_function *fn, zend_object *object, zval *retval_ptr, zval *param); void zend_call_known_instance_method_with_2_params( zend_function *fn, zend_object *object, zval *retval_ptr, zval *param1, zval *param2); These are used to perform a call if you already have the zend_function you want to call. zend_call_known_function() is the base API, the rest are just really thin wrappers around it for the common case of instance method calls. Closes GH-5692.
2020-06-08 23:10:24 +08:00
/* Call the provided zend_function with the given params.
* If retval_ptr is NULL, the return value is discarded.
* If object is NULL, this must be a free function or static call.
* called_scope must be provided for instance and static method calls. */
ZEND_API void zend_call_known_function(
zend_function *fn, zend_object *object, zend_class_entry *called_scope, zval *retval_ptr,
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
uint32_t param_count, zval *params, HashTable *named_params);
Add zend_call_known_function() API family This adds the following APIs: void zend_call_known_function( zend_function *fn, zend_object *object, zend_class_entry *called_scope, zval *retval_ptr, int param_count, zval *params); void zend_call_known_instance_method( zend_function *fn, zend_object *object, zval *retval_ptr, int param_count, zval *params); void zend_call_known_instance_method_with_0_params( zend_function *fn, zend_object *object, zval *retval_ptr); void zend_call_known_instance_method_with_1_params( zend_function *fn, zend_object *object, zval *retval_ptr, zval *param); void zend_call_known_instance_method_with_2_params( zend_function *fn, zend_object *object, zval *retval_ptr, zval *param1, zval *param2); These are used to perform a call if you already have the zend_function you want to call. zend_call_known_function() is the base API, the rest are just really thin wrappers around it for the common case of instance method calls. Closes GH-5692.
2020-06-08 23:10:24 +08:00
/* Call the provided zend_function instance method on an object. */
static zend_always_inline void zend_call_known_instance_method(
zend_function *fn, zend_object *object, zval *retval_ptr,
uint32_t param_count, zval *params)
{
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
zend_call_known_function(fn, object, object->ce, retval_ptr, param_count, params, NULL);
Add zend_call_known_function() API family This adds the following APIs: void zend_call_known_function( zend_function *fn, zend_object *object, zend_class_entry *called_scope, zval *retval_ptr, int param_count, zval *params); void zend_call_known_instance_method( zend_function *fn, zend_object *object, zval *retval_ptr, int param_count, zval *params); void zend_call_known_instance_method_with_0_params( zend_function *fn, zend_object *object, zval *retval_ptr); void zend_call_known_instance_method_with_1_params( zend_function *fn, zend_object *object, zval *retval_ptr, zval *param); void zend_call_known_instance_method_with_2_params( zend_function *fn, zend_object *object, zval *retval_ptr, zval *param1, zval *param2); These are used to perform a call if you already have the zend_function you want to call. zend_call_known_function() is the base API, the rest are just really thin wrappers around it for the common case of instance method calls. Closes GH-5692.
2020-06-08 23:10:24 +08:00
}
static zend_always_inline void zend_call_known_instance_method_with_0_params(
zend_function *fn, zend_object *object, zval *retval_ptr)
{
zend_call_known_instance_method(fn, object, retval_ptr, 0, NULL);
}
static zend_always_inline void zend_call_known_instance_method_with_1_params(
zend_function *fn, zend_object *object, zval *retval_ptr, zval *param)
{
zend_call_known_instance_method(fn, object, retval_ptr, 1, param);
}
ZEND_API void zend_call_known_instance_method_with_2_params(
zend_function *fn, zend_object *object, zval *retval_ptr, zval *param1, zval *param2);
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, size_t name_length, zend_bool is_ref, int num_symbol_tables, ...);
Added zend_set_hash_symbol() function.
1999-12-05 00:50:18 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_delete_global_variable(zend_string *name);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 19:16:39 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API zend_array *zend_rebuild_symbol_table(void);
Optimized zend_leave_helper()
2014-04-18 17:46:36 +08:00
ZEND_API void zend_attach_symbol_table(zend_execute_data *execute_data);
ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data);
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force);
ZEND_API int zend_set_local_var_str(const char *name, size_t len, zval *value, int force);
Better hot/cold code splitting
2019-05-31 17:09:06 +08:00
static zend_always_inline int zend_forbid_dynamic_call(const char *func_name)
{
zend_execute_data *ex = EG(current_execute_data);
ZEND_ASSERT(ex != NULL && ex->func != NULL);
if (ZEND_CALL_INFO(ex) & ZEND_CALL_DYNAMIC) {
Promote warning to error in zend_forbid_dynamic_call()
2019-08-22 01:35:35 +08:00
zend_throw_error(NULL, "Cannot call %s dynamically", func_name);
Better hot/cold code splitting
2019-05-31 17:09:06 +08:00
return FAILURE;
}
return SUCCESS;
}
Lazy EG(active_symbol_table) initialization
2008-04-29 16:15:20 +08:00
Better hot/cold code splitting
2019-05-31 17:09:06 +08:00
ZEND_API ZEND_COLD const char *zend_get_object_type(const zend_class_entry *ce);
Change "Cannot redeclare class X" into "Cannot redeclare class/interface/trait X", meaning that the following: C:\> php -r "trait A { } trait A { }" Will now properly print "Cannot redeclare trait A" instead of "Cannot redeclare class A" to make error messages a tiny bit clearer. Admittedly, a better solution can most likely be made by actually telling what the colliding object is a type of. Internally this adds a new function: zend_get_object_type()
2015-03-25 13:31:11 +08:00
Add iterable pseudo-type
2016-06-04 06:42:04 +08:00
ZEND_API zend_bool zend_is_iterable(zval *iterable);
Add is_countable function RFC: https://wiki.php.net/rfc/is-countable
2018-01-20 06:01:40 +08:00
ZEND_API zend_bool zend_is_countable(zval *countable);
Export API for fetching internal func default Make this functionality available outside reflection.
2020-04-09 20:55:55 +08:00
ZEND_API int zend_get_default_from_internal_arg_info(
zval *default_value_zval, zend_internal_arg_info *arg_info);
more EXTERN_C wrapping of ZEND_API prototypes
2004-02-20 16:03:27 +08:00
END_EXTERN_C()
MFZE1
2002-09-16 09:36:48 +08:00
cleaned up the RETVAL_ RETURN_ and ZVAL_ macros added check for \0 at end-of-string at some places. all strings in PHP have to be terminated with \0 because 3th party libraries might not be binary-safe.
2001-07-10 16:20:20 +08:00
#if ZEND_DEBUG
Cleanup (1-st round)
2014-04-15 19:40:40 +08:00
#define CHECK_ZVAL_STRING(str) \
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 09:05:24 +08:00
if (ZSTR_VAL(str)[ZSTR_LEN(str)] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", ZSTR_VAL(str)); }
Cleanup (1-st round)
2014-04-15 19:40:40 +08:00
#define CHECK_ZVAL_STRING_REL(str) \
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 09:05:24 +08:00
if (ZSTR_VAL(str)[ZSTR_LEN(str)] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", ZSTR_VAL(str) ZEND_FILE_LINE_RELAY_CC); }
cleaned up the RETVAL_ RETURN_ and ZVAL_ macros added check for \0 at end-of-string at some places. all strings in PHP have to be terminated with \0 because 3th party libraries might not be binary-safe.
2001-07-10 16:20:20 +08:00
#else
#define CHECK_ZVAL_STRING(z)
Fix bug #10287 - avoid crashing under a bogus usage of list()
2001-07-16 23:48:31 +08:00
#define CHECK_ZVAL_STRING_REL(z)
cleaned up the RETVAL_ RETURN_ and ZVAL_ macros added check for \0 at end-of-string at some places. all strings in PHP have to be terminated with \0 because 3th party libraries might not be binary-safe.
2001-07-10 16:20:20 +08:00
#endif
master renames phase 1
2014-08-26 01:24:55 +08:00
#define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p)))
Fixed compilation warnings
2016-06-22 01:12:29 +08:00
#define CHECK_NULL_PATH(p, l) (strlen(p) != (size_t)(l))
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-07 05:28:16 +08:00
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
#define ZVAL_STRINGL(z, s, l) do { \
master renames phase 1
2014-08-26 01:24:55 +08:00
ZVAL_NEW_STR(z, zend_string_init(s, l, 0)); \
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 19:16:39 +08:00
} while (0)
cleaned up the RETVAL_ RETURN_ and ZVAL_ macros added check for \0 at end-of-string at some places. all strings in PHP have to be terminated with \0 because 3th party libraries might not be binary-safe.
2001-07-10 16:20:20 +08:00
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
#define ZVAL_STRING(z, s) do { \
const char *_s = (s); \
Use better data structures (incomplete)
2014-02-18 05:41:23 +08:00
ZVAL_STRINGL(z, _s, strlen(_s)); \
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 19:16:39 +08:00
} while (0)
cleaned up the RETVAL_ RETURN_ and ZVAL_ macros added check for \0 at end-of-string at some places. all strings in PHP have to be terminated with \0 because 3th party libraries might not be binary-safe.
2001-07-10 16:20:20 +08:00
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
#define ZVAL_EMPTY_STRING(z) do { \
Improved zend_string API (Francois Laupretre) Squashed commit of the following: commit d96eab8d79b75ac83d49d49ae4665f948d15a804 Author: Francois Laupretre <francois@tekwire.net> Date: Fri Jun 26 01:23:31 2015 +0200 Use the new 'ZSTR' macros in the rest of the code. Does not change anything to the generated code (thanks to compat macros) but cleaner. commit b3526439104ac7a89a8e0c79dbebf33b22bd01b8 Author: Francois Laupretre <francois@tekwire.net> Date: Thu Jun 25 13:45:06 2015 +0200 Improve zend_string API Add missing methods
2015-06-29 21:44:54 +08:00
ZVAL_INTERNED_STR(z, ZSTR_EMPTY_ALLOC()); \
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 19:16:39 +08:00
} while (0)
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
#define ZVAL_PSTRINGL(z, s, l) do { \
master renames phase 1
2014-08-26 01:24:55 +08:00
ZVAL_NEW_STR(z, zend_string_init(s, l, 1)); \
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 19:16:39 +08:00
} while (0)
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
#define ZVAL_PSTRING(z, s) do { \
const char *_s = (s); \
Use better data structures (incomplete)
2014-02-18 05:41:23 +08:00
ZVAL_PSTRINGL(z, _s, strlen(_s)); \
Use better data structures (incomplete)
2014-02-10 14:04:30 +08:00
} while (0)
#define ZVAL_EMPTY_PSTRING(z) do { \
Use better data structures (incomplete)
2014-02-17 15:50:32 +08:00
ZVAL_PSTRINGL(z, "", 0); \
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 19:16:39 +08:00
} while (0)
added ZVAL_*() macros.
2000-01-04 21:56:17 +08:00
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define ZVAL_CHAR(z, c) do { \
char _c = (c); \
ZVAL_INTERNED_STR(z, ZSTR_CHAR((zend_uchar) _c)); \
} while (0)
#define ZVAL_STRINGL_FAST(z, s, l) do { \
ZVAL_STR(z, zend_string_init_fast(s, l)); \
} while (0)
#define ZVAL_STRING_FAST(z, s) do { \
const char *_s = (s); \
ZVAL_STRINGL_FAST(z, _s, strlen(_s)); \
} while (0)
Evaluate ZVAL_ZVAL arguments only once Also remove some isref/refcount assignments, which are no longer necessary (as ZVAL_COPY_VALUE is used now).
2013-08-27 01:57:14 +08:00
#define ZVAL_ZVAL(z, zv, copy, dtor) do { \
zval *__z = (z); \
zval *__zv = (zv); \
Fixed reference support
2014-03-13 21:59:50 +08:00
if (EXPECTED(!Z_ISREF_P(__zv))) { \
Avoid zval duplication in ZVAL_ZVAL() macro (it was necessary only in few places). Switch from ZVAL_ZVAL() to simpler macros where possible (it makes sense to review remaining places)
2015-06-12 17:33:23 +08:00
if (copy && !dtor) { \
ZVAL_COPY(__z, __zv); \
} else { \
ZVAL_COPY_VALUE(__z, __zv); \
} \
} else { \
ZVAL_COPY(__z, Z_REFVAL_P(__zv)); \
if (dtor || !copy) { \
zval_ptr_dtor(__zv); \
Fixed comilation warnings
2008-01-25 02:07:45 +08:00
} \
Avoid zval duplication in ZVAL_ZVAL() macro (it was necessary only in few places). Switch from ZVAL_ZVAL() to simpler macros where possible (it makes sense to review remaining places)
2015-06-12 17:33:23 +08:00
} \
Evaluate ZVAL_ZVAL arguments only once Also remove some isref/refcount assignments, which are no longer necessary (as ZVAL_COPY_VALUE is used now).
2013-08-27 01:57:14 +08:00
} while (0)
Add macros to return values of other zvals. This is needed because one cannot use REPLACE_ZVAL_VALUE with return_value.
2003-11-30 02:15:11 +08:00
Whitespace
2001-08-11 23:56:40 +08:00
#define RETVAL_BOOL(b) ZVAL_BOOL(return_value, b)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETVAL_NULL() ZVAL_NULL(return_value)
#define RETVAL_LONG(l) ZVAL_LONG(return_value, l)
#define RETVAL_DOUBLE(d) ZVAL_DOUBLE(return_value, d)
#define RETVAL_STR(s) ZVAL_STR(return_value, s)
#define RETVAL_INTERNED_STR(s) ZVAL_INTERNED_STR(return_value, s)
#define RETVAL_NEW_STR(s) ZVAL_NEW_STR(return_value, s)
#define RETVAL_STR_COPY(s) ZVAL_STR_COPY(return_value, s)
#define RETVAL_STRING(s) ZVAL_STRING(return_value, s)
#define RETVAL_STRINGL(s, l) ZVAL_STRINGL(return_value, s, l)
#define RETVAL_STRING_FAST(s) ZVAL_STRING_FAST(return_value, s)
#define RETVAL_STRINGL_FAST(s, l) ZVAL_STRINGL_FAST(return_value, s, l)
#define RETVAL_EMPTY_STRING() ZVAL_EMPTY_STRING(return_value)
#define RETVAL_CHAR(c) ZVAL_CHAR(return_value, c)
#define RETVAL_RES(r) ZVAL_RES(return_value, r)
#define RETVAL_ARR(r) ZVAL_ARR(return_value, r)
These macros should not expect any argument
2019-05-29 08:29:02 +08:00
#define RETVAL_EMPTY_ARRAY() ZVAL_EMPTY_ARRAY(return_value)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETVAL_OBJ(r) ZVAL_OBJ(return_value, r)
Add ZVAL_OBJ_COPY macro For the common ZVAL_OBJ + GC_ADDREF pattern. This mirrors the existing ZVAL_STR_COPY API.
2020-06-17 18:34:04 +08:00
#define RETVAL_OBJ_COPY(r) ZVAL_OBJ_COPY(return_value, r)
Eliminate uses of ZVAL_ZVAL and friends Instead add RETURN_COPY(_VALUE) macros will the expected behavior. RETURN_ZVAL doesn't make any sense since PHP 7, but has stuck around, probably because the alternative was to write directly to the return_value variable.
2020-01-20 17:34:17 +08:00
#define RETVAL_COPY(zv) ZVAL_COPY(return_value, zv)
#define RETVAL_COPY_VALUE(zv) ZVAL_COPY_VALUE(return_value, zv)
Add macros to return values of other zvals. This is needed because one cannot use REPLACE_ZVAL_VALUE with return_value.
2003-11-30 02:15:11 +08:00
#define RETVAL_ZVAL(zv, copy, dtor) ZVAL_ZVAL(return_value, zv, copy, dtor)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETVAL_FALSE ZVAL_FALSE(return_value)
#define RETVAL_TRUE ZVAL_TRUE(return_value)
cleaned up the RETVAL_ RETURN_ and ZVAL_ macros added check for \0 at end-of-string at some places. all strings in PHP have to be terminated with \0 because 3th party libraries might not be binary-safe.
2001-07-10 16:20:20 +08:00
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETURN_BOOL(b) do { RETVAL_BOOL(b); return; } while (0)
#define RETURN_NULL() do { RETVAL_NULL(); return;} while (0)
#define RETURN_LONG(l) do { RETVAL_LONG(l); return; } while (0)
#define RETURN_DOUBLE(d) do { RETVAL_DOUBLE(d); return; } while (0)
Add do...while(0) for RETURN_* and ZVAL_* APIs Closes GH-4255.
2019-06-12 18:49:33 +08:00
#define RETURN_STR(s) do { RETVAL_STR(s); return; } while (0)
#define RETURN_INTERNED_STR(s) do { RETVAL_INTERNED_STR(s); return; } while (0)
#define RETURN_NEW_STR(s) do { RETVAL_NEW_STR(s); return; } while (0)
#define RETURN_STR_COPY(s) do { RETVAL_STR_COPY(s); return; } while (0)
#define RETURN_STRING(s) do { RETVAL_STRING(s); return; } while (0)
#define RETURN_STRINGL(s, l) do { RETVAL_STRINGL(s, l); return; } while (0)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETURN_STRING_FAST(s) do { RETVAL_STRING_FAST(s); return; } while (0)
#define RETURN_STRINGL_FAST(s, l) do { RETVAL_STRINGL_FAST(s, l); return; } while (0)
Add do...while(0) for RETURN_* and ZVAL_* APIs Closes GH-4255.
2019-06-12 18:49:33 +08:00
#define RETURN_EMPTY_STRING() do { RETVAL_EMPTY_STRING(); return; } while (0)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETURN_CHAR(c) do { RETVAL_CHAR(c); return; } while (0)
#define RETURN_RES(r) do { RETVAL_RES(r); return; } while (0)
#define RETURN_ARR(r) do { RETVAL_ARR(r); return; } while (0)
Add do...while(0) for RETURN_* and ZVAL_* APIs Closes GH-4255.
2019-06-12 18:49:33 +08:00
#define RETURN_EMPTY_ARRAY() do { RETVAL_EMPTY_ARRAY(); return; } while (0)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETURN_OBJ(r) do { RETVAL_OBJ(r); return; } while (0)
Add ZVAL_OBJ_COPY macro For the common ZVAL_OBJ + GC_ADDREF pattern. This mirrors the existing ZVAL_STR_COPY API.
2020-06-17 18:34:04 +08:00
#define RETURN_OBJ_COPY(r) do { RETVAL_OBJ_COPY(r); return; } while (0)
Eliminate uses of ZVAL_ZVAL and friends Instead add RETURN_COPY(_VALUE) macros will the expected behavior. RETURN_ZVAL doesn't make any sense since PHP 7, but has stuck around, probably because the alternative was to write directly to the return_value variable.
2020-01-20 17:34:17 +08:00
#define RETURN_COPY(zv) do { RETVAL_COPY(zv); return; } while (0)
#define RETURN_COPY_VALUE(zv) do { RETVAL_COPY_VALUE(zv); return; } while (0)
Add do...while(0) for RETURN_* and ZVAL_* APIs Closes GH-4255.
2019-06-12 18:49:33 +08:00
#define RETURN_ZVAL(zv, copy, dtor) do { RETVAL_ZVAL(zv, copy, dtor); return; } while (0)
Add helper APIs for maybe-interned string creation Add ZVAL_CHAR/RETVAL_CHAR/RETURN_CHAR as a shortcut for using ZVAL_INTERNED_STRING and ZSTR_CHAR. Add zend_string_init_fast() as a helper for the empty string / one char interned string / zend_string_init() pattern. Also add corresponding ZVAL_STRINGL_FAST etc macros. Closes GH-5684.
2020-06-08 18:45:01 +08:00
#define RETURN_FALSE do { RETVAL_FALSE; return; } while (0)
#define RETURN_TRUE do { RETVAL_TRUE; return; } while (0)
Use RETURN_THROWS() when an exception is thrown Closes GH-5036
2019-12-30 03:54:57 +08:00
#define RETURN_THROWS() do { ZEND_ASSERT(EG(exception)); (void) return_value; return; } while (0)
Moved all #define's for SET_ and RETURN_ to zend_API.h
1999-05-27 09:44:17 +08:00
Refactor zend_object_handlers API to pass zend_object* and zend_string* insted of zval(s).
2019-01-31 23:47:58 +08:00
#define HASH_OF(p) (Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties(Z_OBJ_P(p)) : NULL)))
Use better data structures (incomplete)
2014-02-14 17:05:04 +08:00
#define ZVAL_IS_NULL(z) (Z_TYPE_P(z) == IS_NULL)
- Add some internal functions to Zend
1999-09-21 00:56:09 +08:00
- Merge from Engine 1
2001-08-11 00:19:49 +08:00
/* For compatibility */
#define ZEND_MINIT ZEND_MODULE_STARTUP_N
#define ZEND_MSHUTDOWN ZEND_MODULE_SHUTDOWN_N
#define ZEND_RINIT ZEND_MODULE_ACTIVATE_N
#define ZEND_RSHUTDOWN ZEND_MODULE_DEACTIVATE_N
#define ZEND_MINFO ZEND_MODULE_INFO_N
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
#define ZEND_GINIT(module) ((void (*)(void*))(ZEND_MODULE_GLOBALS_CTOR_N(module)))
#define ZEND_GSHUTDOWN(module) ((void (*)(void*))(ZEND_MODULE_GLOBALS_DTOR_N(module)))
- Merge from Engine 1
2001-08-11 00:19:49 +08:00
#define ZEND_MINIT_FUNCTION ZEND_MODULE_STARTUP_D
_FUNCTION is used in definition, so use _D
2001-08-12 22:58:57 +08:00
#define ZEND_MSHUTDOWN_FUNCTION ZEND_MODULE_SHUTDOWN_D
#define ZEND_RINIT_FUNCTION ZEND_MODULE_ACTIVATE_D
#define ZEND_RSHUTDOWN_FUNCTION ZEND_MODULE_DEACTIVATE_D
#define ZEND_MINFO_FUNCTION ZEND_MODULE_INFO_D
MFH: Added automatic module globals management.
2006-06-15 22:03:21 +08:00
#define ZEND_GINIT_FUNCTION ZEND_MODULE_GLOBALS_CTOR_D
#define ZEND_GSHUTDOWN_FUNCTION ZEND_MODULE_GLOBALS_DTOR_D
- Merge from Engine 1
2001-08-11 00:19:49 +08:00
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
/* May modify arg in-place. Will free arg in failure case (and take ownership in success case).
* Prefer using the ZEND_TRY_ASSIGN_* macros over these APIs. */
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
ZEND_API int zend_try_assign_typed_ref_ex(zend_reference *ref, zval *zv, zend_bool strict);
ZEND_API int zend_try_assign_typed_ref(zend_reference *ref, zval *zv);
ZEND_API int zend_try_assign_typed_ref_null(zend_reference *ref);
ZEND_API int zend_try_assign_typed_ref_bool(zend_reference *ref, zend_bool val);
ZEND_API int zend_try_assign_typed_ref_long(zend_reference *ref, zend_long lval);
ZEND_API int zend_try_assign_typed_ref_double(zend_reference *ref, double dval);
ZEND_API int zend_try_assign_typed_ref_empty_string(zend_reference *ref);
ZEND_API int zend_try_assign_typed_ref_str(zend_reference *ref, zend_string *str);
ZEND_API int zend_try_assign_typed_ref_string(zend_reference *ref, const char *string);
ZEND_API int zend_try_assign_typed_ref_stringl(zend_reference *ref, const char *string, size_t len);
ZEND_API int zend_try_assign_typed_ref_arr(zend_reference *ref, zend_array *arr);
ZEND_API int zend_try_assign_typed_ref_res(zend_reference *ref, zend_resource *res);
ZEND_API int zend_try_assign_typed_ref_zval(zend_reference *ref, zval *zv);
ZEND_API int zend_try_assign_typed_ref_zval_ex(zend_reference *ref, zval *zv, zend_bool strict);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define _ZEND_TRY_ASSIGN_NULL(zv, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_null(ref); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_NULL(_zv); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_NULL(zv) \
_ZEND_TRY_ASSIGN_NULL(zv, 0)
#define ZEND_TRY_ASSIGN_REF_NULL(zv) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_NULL(zv, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_FALSE(zv, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_bool(ref, 0); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_FALSE(_zv); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Fix typo in TRY_ASSIGN macro name
2019-04-29 15:58:45 +08:00
#define ZEND_TRY_ASSIGN_FALSE(zv) \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
_ZEND_TRY_ASSIGN_FALSE(zv, 0)
#define ZEND_TRY_ASSIGN_REF_FALSE(zv) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_FALSE(zv, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_TRUE(zv, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_bool(ref, 1); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_TRUE(_zv); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_TRUE(zv) \
_ZEND_TRY_ASSIGN_TRUE(zv, 0)
#define ZEND_TRY_ASSIGN_REF_TRUE(zv) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_TRUE(zv, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_BOOL(zv, bval, is_ref) do { \
Add ZEND_TRY_ASSIGN_BOOL API
2019-02-08 18:06:50 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Add ZEND_TRY_ASSIGN_BOOL API
2019-02-08 18:06:50 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_bool(ref, 1); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_BOOL(_zv, bval); \
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_BOOL(zv, bval) \
_ZEND_TRY_ASSIGN_BOOL(zv, bval, 0)
#define ZEND_TRY_ASSIGN_REF_BOOL(zv, bval) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_BOOL(zv, bval, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_LONG(zv, lval, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_long(ref, lval); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_LONG(_zv, lval); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_LONG(zv, lval) \
_ZEND_TRY_ASSIGN_LONG(zv, lval, 0)
#define ZEND_TRY_ASSIGN_REF_LONG(zv, lval) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_LONG(zv, lval, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_DOUBLE(zv, dval, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_double(ref, dval); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_DOUBLE(_zv, dval); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_DOUBLE(zv, dval) \
_ZEND_TRY_ASSIGN_DOUBLE(zv, dval, 0)
#define ZEND_TRY_ASSIGN_REF_DOUBLE(zv, dval) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_DOUBLE(zv, dval, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_EMPTY_STRING(zv, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_empty_string(ref); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_EMPTY_STRING(_zv); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_EMPTY_STRING(zv) \
_ZEND_TRY_ASSIGN_EMPTY_STRING(zv, 0)
#define ZEND_TRY_ASSIGN_REF_EMPTY_STRING(zv) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_EMPTY_STRING(zv, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_STR(zv, str, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_str(ref, str); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_STR(_zv, str); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_STR(zv, str) \
_ZEND_TRY_ASSIGN_STR(zv, str, 0)
#define ZEND_TRY_ASSIGN_REF_STR(zv, str) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_STR(zv, str, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_NEW_STR(zv, str, is_str) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_str || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_str(ref, str); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_NEW_STR(_zv, str); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_NEW_STR(zv, str) \
_ZEND_TRY_ASSIGN_NEW_STR(zv, str, 0)
#define ZEND_TRY_ASSIGN_REF_NEW_STR(zv, str) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_NEW_STR(zv, str, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_STRING(zv, string, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_string(ref, string); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_STRING(_zv, string); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_STRING(zv, string) \
_ZEND_TRY_ASSIGN_STRING(zv, string, 0)
#define ZEND_TRY_ASSIGN_REF_STRING(zv, string) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_STRING(zv, string, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_STRINGL(zv, string, len, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_stringl(ref, string, len); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_STRINGL(_zv, string, len); \
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_STRINGL(zv, string, len) \
_ZEND_TRY_ASSIGN_STRINGL(zv, string, len, 0)
#define ZEND_TRY_ASSIGN_REF_STRINGL(zv, string, len) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_STRINGL(zv, string, len, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_ARR(zv, arr, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_arr(ref, arr); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_ARR(_zv, arr); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_ARR(zv, arr) \
_ZEND_TRY_ASSIGN_ARR(zv, arr, 0)
#define ZEND_TRY_ASSIGN_REF_ARR(zv, arr) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_ARR(zv, arr, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_RES(zv, res, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_res(ref, res); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_RES(_zv, res); \
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_RES(zv, res) \
_ZEND_TRY_ASSIGN_RES(zv, res, 0)
#define ZEND_TRY_ASSIGN_REF_RES(zv, res) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_RES(zv, res, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_TMP(zv, other_zv, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref(ref, other_zv); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_COPY_VALUE(_zv, other_zv); \
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_TMP(zv, other_zv) \
_ZEND_TRY_ASSIGN_TMP(zv, other_zv, 0)
#define ZEND_TRY_ASSIGN_REF_TMP(zv, other_zv) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_TMP(zv, other_zv, 1); \
} while (0)
#define _ZEND_TRY_ASSIGN_VALUE(zv, other_zv, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_zval(ref, other_zv); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_COPY_VALUE(_zv, other_zv); \
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_VALUE(zv, other_zv) \
_ZEND_TRY_ASSIGN_VALUE(zv, other_zv, 0)
#define ZEND_TRY_ASSIGN_REF_VALUE(zv, other_zv) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_VALUE(zv, other_zv, 1); \
} while (0)
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
#define ZEND_TRY_ASSIGN_COPY(zv, other_zv) do { \
Z_TRY_ADDREF_P(other_zv); \
ZEND_TRY_ASSIGN_VALUE(zv, other_zv); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_REF_COPY(zv, other_zv) do { \
Z_TRY_ADDREF_P(other_zv); \
ZEND_TRY_ASSIGN_REF_VALUE(zv, other_zv); \
} while (0)
#define _ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict, is_ref) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval *_zv = zv; \
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zend_reference *ref = Z_REF_P(_zv); \
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
zend_try_assign_typed_ref_zval_ex(ref, other_zv, strict); \
break; \
} \
_zv = &ref->val; \
} \
zval_ptr_dtor(_zv); \
ZVAL_COPY_VALUE(_zv, other_zv); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict) \
_ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict, 0)
#define ZEND_TRY_ASSIGN_REF_VALUE_EX(zv, other_zv, strict) do { \
ZEND_ASSERT(Z_ISREF_P(zv)); \
_ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict, 1); \
} while (0)
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
#define ZEND_TRY_ASSIGN_COPY_EX(zv, other_zv, strict) do { \
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
Z_TRY_ADDREF_P(other_zv); \
ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
Use ZEND_TRA_ASSIGN_REF_... macros for by reference arguments of internal functions.
2019-04-24 21:14:48 +08:00
#define ZEND_TRY_ASSIGN_REF_COPY_EX(zv, other_zv, strict) do { \
Z_TRY_ADDREF_P(other_zv); \
ZEND_TRY_ASSIGN_REF_VALUE_EX(zv, other_zv, strict); \
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} while (0)
/* Initializes a reference to an empty array and returns dereferenced zval,
* or NULL if the initialization failed. */
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
static zend_always_inline zval *zend_try_array_init_size(zval *zv, uint32_t size)
{
zend_array *arr = zend_new_array(size);
if (EXPECTED(Z_ISREF_P(zv))) {
zend_reference *ref = Z_REF_P(zv);
if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
if (zend_try_assign_typed_ref_arr(ref, arr) != SUCCESS) {
return NULL;
}
return &ref->val;
}
zv = &ref->val;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
zval_ptr_dtor(zv);
ZVAL_ARR(zv, arr);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
return zv;
}
Improved ZEND_TRY_ASSIGN... API to avoid unnecessary double copying and reduce code bloat.
2019-01-18 05:53:48 +08:00
static zend_always_inline zval *zend_try_array_init(zval *zv)
{
return zend_try_array_init_size(zv, 0);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* Fast parameter parsing API */
Remove zpp fallback code (always use Fast ZPP) Squashed commit of the following: commit 3e27fbb3d22b42d181e15c345f1c59a007b6b58c Author: Andrea Faulds <ajf@ajf.me> Date: Sun Sep 11 19:14:37 2016 +0100 Keep dummy FAST_ZPP macro for compatibility commit 8a7cfd00deaa4a3c5026c97580c49c886c72a5b4 Author: Andrea Faulds <ajf@ajf.me> Date: Mon Sep 5 22:36:03 2016 +0100 Remove FAST_ZPP macro and plain zpp fallback code
2016-09-12 05:44:46 +08:00
/* Fast ZPP is always enabled now; this define is left in for compatibility
* with any existing conditional compilation blocks.
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
*/
#define FAST_ZPP 1
#define Z_EXPECTED_TYPES(_) \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_(Z_EXPECTED_LONG, "of type int") \
_(Z_EXPECTED_LONG_OR_NULL, "of type ?int") \
_(Z_EXPECTED_BOOL, "of type bool") \
_(Z_EXPECTED_BOOL_OR_NULL, "of type ?bool") \
_(Z_EXPECTED_STRING, "of type string") \
_(Z_EXPECTED_STRING_OR_NULL, "of type ?string") \
_(Z_EXPECTED_ARRAY, "of type array") \
_(Z_EXPECTED_ARRAY_OR_NULL, "of type ?array") \
_(Z_EXPECTED_FUNC, "a valid callback") \
_(Z_EXPECTED_FUNC_OR_NULL, "a valid callback or null") \
_(Z_EXPECTED_RESOURCE, "of type resource") \
_(Z_EXPECTED_RESOURCE_OR_NULL, "of type resource or null") \
_(Z_EXPECTED_PATH, "a valid path") \
_(Z_EXPECTED_PATH_OR_NULL, "a valid path or null") \
_(Z_EXPECTED_OBJECT, "of type object") \
_(Z_EXPECTED_OBJECT_OR_NULL, "of type ?object") \
_(Z_EXPECTED_DOUBLE, "of type float") \
_(Z_EXPECTED_DOUBLE_OR_NULL, "of type ?float") \
_(Z_EXPECTED_NUMBER, "of type int|float") \
_(Z_EXPECTED_NUMBER_OR_NULL, "of type int|float|null") \
_(Z_EXPECTED_STRING_OR_ARRAY, "of type string|array") \
_(Z_EXPECTED_STRING_OR_ARRAY_OR_NULL, "of type string|array|null") \
Add Fast ZPP string|int type check
2020-04-24 21:35:03 +08:00
_(Z_EXPECTED_STRING_OR_LONG, "of type string|int") \
_(Z_EXPECTED_STRING_OR_LONG_OR_NULL, "of type string|int|null") \
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
_(Z_EXPECTED_CLASS_NAME_OR_OBJECT, "a valid class name or object") \
_(Z_EXPECTED_CLASS_NAME_OR_OBJECT_OR_NULL, "a valid class name, object, or null") \
Add string or object ZPP macros Closes GH-5788
2020-06-30 21:04:54 +08:00
_(Z_EXPECTED_STRING_OR_OBJECT, "of type object|string") \
_(Z_EXPECTED_STRING_OR_OBJECT_OR_NULL, "of type object|string|null") \
Make type error messages more consistent Closes GH-5092
2020-01-30 03:06:13 +08:00
#define Z_EXPECTED_TYPE
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_EXPECTED_TYPE_ENUM(id, str) id,
#define Z_EXPECTED_TYPE_STR(id, str) str,
typedef enum _zend_expected_type {
Z_EXPECTED_TYPES(Z_EXPECTED_TYPE_ENUM)
Z_EXPECTED_LAST
} zend_expected_type;
Voidify some ZEND_API functions Closes GH-5805
2020-07-03 23:43:06 +08:00
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_none_error(void);
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_count_error(uint32_t min_num_args, uint32_t max_num_args);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_error(int error_code, uint32_t num, char *name, zend_expected_type expected_type, zval *arg);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_error(uint32_t num, zend_expected_type expected_type, zval *arg);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_error(uint32_t num, const char *name, zval *arg);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_or_null_error(uint32_t num, const char *name, zval *arg);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_string_or_class_error(uint32_t num, const char *name, zval *arg);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_string_or_class_or_null_error(uint32_t num, const char *name, zval *arg);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(uint32_t num, char *error);
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_unexpected_extra_named_error(void);
Make type error messages more consistent Closes GH-5092
2020-01-30 03:06:13 +08:00
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_error(zend_class_entry *error_ce, uint32_t arg_num, const char *format, ...);
Improve argument error messages in ext/standard Closes GH-5198
2020-02-25 03:19:20 +08:00
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_type_error(uint32_t arg_num, const char *format, ...);
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_value_error(uint32_t arg_num, const char *format, ...);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Add string or object ZPP macros Closes GH-5788
2020-06-30 21:04:54 +08:00
#define ZPP_ERROR_OK 0
#define ZPP_ERROR_FAILURE 1
#define ZPP_ERROR_WRONG_CALLBACK 2
#define ZPP_ERROR_WRONG_CLASS 3
#define ZPP_ERROR_WRONG_CLASS_OR_NULL 4
#define ZPP_ERROR_WRONG_ARG 5
#define ZPP_ERROR_WRONG_COUNT 6
#define ZPP_ERROR_WRONG_STRING_OR_CLASS 7
#define ZPP_ERROR_WRONG_STRING_OR_CLASS_OR_NULL 8
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
#define ZPP_ERROR_UNEXPECTED_EXTRA_NAMED 9
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define ZEND_PARSE_PARAMETERS_START_EX(flags, min_num_args, max_num_args) do { \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
const int _flags = (flags); \
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
uint32_t _min_num_args = (min_num_args); \
Change type of max_num_args to uint32_t Closes GH-5885.
2020-07-22 22:29:30 +08:00
uint32_t _max_num_args = (uint32_t) (max_num_args); \
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
uint32_t _num_args = EX_NUM_ARGS(); \
uint32_t _i = 0; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
zval *_real_arg, *_arg = NULL; \
Use Z_EXPECTED_LONG to initialize FAST_ZPP parsing loop
2018-01-23 22:10:36 +08:00
zend_expected_type _expected_type = Z_EXPECTED_LONG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
char *_error = NULL; \
Use unused attribute for _dummy The (void)_dummy is apparently considered a read of an uninitialized variable. As it is a _Bool now, which has trap representations, this is no longer considered legal and results in somewhat odd ubsan warnings of the form: runtime error: load of value 0, which is not a valid value for type 'zend_bool' (aka 'bool')
2020-06-12 16:18:19 +08:00
ZEND_ATTRIBUTE_UNUSED zend_bool _dummy; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
zend_bool _optional = 0; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
int _error_code = ZPP_ERROR_OK; \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
((void)_i); \
((void)_real_arg); \
((void)_arg); \
((void)_expected_type); \
((void)_error); \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
((void)_optional); \
\
do { \
if (UNEXPECTED(_num_args < _min_num_args) || \
Change type of max_num_args to uint32_t Closes GH-5885.
2020-07-22 22:29:30 +08:00
UNEXPECTED(_num_args > _max_num_args)) { \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
if (!(_flags & ZEND_PARSE_PARAMS_QUIET)) { \
Make zpp failures always throw, independent of strict_types Previously zend_parse_parameters (and FastZPP) would handle invalid arguments depending on strict_types: With strict_types=1, a TypeError is thrown, with strict_types=0 a warning is thrown and (usually) NULL is returned. Additionally, some functions (constructors always and other methods sometimes) opt-it to throwing regardless of strict_types. This commit changes zpp to always generate a TypeError exception in PHP 8.
2019-02-05 17:07:07 +08:00
zend_wrong_parameters_count_error(_min_num_args, _max_num_args); \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
} \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_FAILURE; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} \
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 23:32:46 +08:00
_real_arg = ZEND_CALL_ARG(execute_data, 0);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define ZEND_PARSE_PARAMETERS_START(min_num_args, max_num_args) \
ZEND_PARSE_PARAMETERS_START_EX(0, min_num_args, max_num_args)
Improved ZPP to reduce amount of generated code.
2018-02-16 16:37:20 +08:00
#define ZEND_PARSE_PARAMETERS_NONE() do { \
if (UNEXPECTED(ZEND_NUM_ARGS() != 0)) { \
zend_wrong_parameters_none_error(); \
Added missed "return"
2018-02-16 19:13:52 +08:00
return; \
Improved ZPP to reduce amount of generated code.
2018-02-16 16:37:20 +08:00
} \
} while (0)
FAST_ZPP variant of zend_parse_parameters_none(), ZEND_PARSE_PARAMETERS_NONE()
2017-07-23 14:48:06 +08:00
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define ZEND_PARSE_PARAMETERS_END_EX(failure) \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
} while (0); \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
if (UNEXPECTED(_error_code != ZPP_ERROR_OK)) { \
Delay EG(exception) check on slow path
2019-07-08 18:56:34 +08:00
if (!(_flags & ZEND_PARSE_PARAMS_QUIET)) { \
Add zend_wrong_parameter_error to reduce the size of ZPP macro Closes GH-5831.
2020-07-10 13:18:00 +08:00
zend_wrong_parameter_error(_error_code, _i, _error, _expected_type, _arg); \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} \
failure; \
} \
} while (0)
#define ZEND_PARSE_PARAMETERS_END() \
ZEND_PARSE_PARAMETERS_END_EX(return)
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_PROLOGUE(deref, separate) \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
++_i; \
Add consistency check in FAST_ZPP call So ensure Z_PARAM_OPTIONAL is correctly call at the right place Only in DEBUG build Will raise 'Assertion `_i > _min_num_args || _optional==0' failed.' or 'Assertion `_i <= _min_num_args || _optional==1' failed.' Thus will allow to detect bad code early.
2015-05-19 16:54:10 +08:00
ZEND_ASSERT(_i <= _min_num_args || _optional==1); \
ZEND_ASSERT(_i > _min_num_args || _optional==0); \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
if (_optional) { \
if (UNEXPECTED(_i >_num_args)) break; \
} \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
_real_arg++; \
_arg = _real_arg; \
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
if (deref) { \
Fixed expectation
2018-12-17 20:59:16 +08:00
if (EXPECTED(Z_ISREF_P(_arg))) { \
_arg = Z_REFVAL_P(_arg); \
} \
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
} \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
if (separate) { \
SEPARATE_ZVAL_NOREF(_arg); \
}
/* old "|" */
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
#define Z_PARAM_OPTIONAL \
_optional = 1;
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "a" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
if (UNEXPECTED(!zend_parse_arg_array(_arg, &dest, check_null, 0))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_ARRAY_OR_NULL : Z_EXPECTED_ARRAY; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_EX(dest, check_null, separate) \
Z_PARAM_ARRAY_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_ARRAY(dest) \
Z_PARAM_ARRAY_EX(dest, 0, 0)
Add Z_PARAM_STRING/ARRAY_OR_NULL convenience macros
2019-10-29 20:29:52 +08:00
#define Z_PARAM_ARRAY_OR_NULL(dest) \
Z_PARAM_ARRAY_EX(dest, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "A" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_OR_OBJECT_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
if (UNEXPECTED(!zend_parse_arg_array(_arg, &dest, check_null, 1))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_ARRAY_OR_NULL : Z_EXPECTED_ARRAY; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_OR_OBJECT_EX(dest, check_null, separate) \
Z_PARAM_ARRAY_OR_OBJECT_EX2(dest, check_null, separate, separate)
Fix fast ZPP macro definition
2017-08-15 17:43:09 +08:00
#define Z_PARAM_ARRAY_OR_OBJECT(dest) \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Z_PARAM_ARRAY_OR_OBJECT_EX(dest, 0, 0)
/* old "b" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_BOOL_EX2(dest, is_null, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_bool(_arg, &dest, &is_null, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_BOOL_OR_NULL : Z_EXPECTED_BOOL; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_BOOL_EX(dest, is_null, check_null, separate) \
Z_PARAM_BOOL_EX2(dest, is_null, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_BOOL(dest) \
Z_PARAM_BOOL_EX(dest, _dummy, 0, 0)
Fix UNKNOWN default values in various extensions Closes GH-5514
2020-05-02 21:25:25 +08:00
#define Z_PARAM_BOOL_OR_NULL(dest, is_null) \
Z_PARAM_BOOL_EX(dest, is_null, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "C" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_CLASS_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_class(_arg, &dest, _i, check_null))) { \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_FAILURE; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_CLASS_EX(dest, check_null, separate) \
Z_PARAM_CLASS_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_CLASS(dest) \
Z_PARAM_CLASS_EX(dest, 0, 0)
Use Z_PARAM_CLASS in PDOStatement::fetchObject() Instead of implementing custom logic.
2020-08-13 22:20:29 +08:00
#define Z_PARAM_CLASS_OR_NULL(dest) \
Z_PARAM_CLASS_EX(dest, 1, 0)
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
#define Z_PARAM_CLASS_NAME_OR_OBJ_EX(dest, allow_null) \
Z_PARAM_PROLOGUE(0, 0); \
Drop unused param in zend_parse_arg_class_name_or_obj()
2020-07-17 03:00:28 +08:00
if (UNEXPECTED(!zend_parse_arg_class_name_or_obj(_arg, &dest, allow_null))) { \
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
_expected_type = allow_null ? Z_EXPECTED_CLASS_NAME_OR_OBJECT_OR_NULL : Z_EXPECTED_CLASS_NAME_OR_OBJECT; \
_error_code = ZPP_ERROR_WRONG_ARG; \
break; \
}
#define Z_PARAM_CLASS_NAME_OR_OBJ(dest) \
Z_PARAM_CLASS_NAME_OR_OBJ_EX(dest, 0);
#define Z_PARAM_CLASS_NAME_OR_OBJ_OR_NULL(dest) \
Z_PARAM_CLASS_NAME_OR_OBJ_EX(dest, 1);
Add string or object ZPP macros Closes GH-5788
2020-06-30 21:04:54 +08:00
#define Z_PARAM_STR_OR_OBJ_EX(destination_string, destination_object, allow_null) \
Z_PARAM_PROLOGUE(0, 0); \
if (UNEXPECTED(!zend_parse_arg_str_or_obj(_arg, &destination_string, &destination_object, NULL, allow_null))) { \
_expected_type = allow_null ? Z_EXPECTED_STRING_OR_OBJECT_OR_NULL : Z_EXPECTED_STRING_OR_OBJECT; \
_error_code = ZPP_ERROR_WRONG_ARG; \
break; \
}
#define Z_PARAM_STR_OR_OBJ(destination_string, destination_object) \
Z_PARAM_STR_OR_OBJ_EX(destination_string, destination_object, 0);
#define Z_PARAM_STR_OR_OBJ_OR_NULL(destination_string, destination_object) \
Z_PARAM_STR_OR_OBJ_EX(destination_string, destination_object, 1);
#define Z_PARAM_STR_OR_OBJ_OF_CLASS_EX(destination_string, destination_object, base_ce, allow_null) \
Z_PARAM_PROLOGUE(0, 0); \
if (UNEXPECTED(!zend_parse_arg_str_or_obj(_arg, &destination_string, &destination_object, base_ce, allow_null))) { \
if (base_ce) { \
_error = ZSTR_VAL((base_ce)->name); \
_error_code = allow_null ? ZPP_ERROR_WRONG_STRING_OR_CLASS_OR_NULL : ZPP_ERROR_WRONG_STRING_OR_CLASS; \
break; \
} else { \
_expected_type = allow_null ? Z_EXPECTED_STRING_OR_OBJECT_OR_NULL : Z_EXPECTED_STRING_OR_OBJECT; \
_error_code = ZPP_ERROR_WRONG_ARG; \
break; \
} \
}
#define Z_PARAM_STR_OR_OBJ_OF_CLASS(destination_string, destination_object, base_ce) \
Z_PARAM_STR_OR_OBJ_OF_CLASS_EX(destination_string, destination_object, base_ce, 0);
#define Z_PARAM_STR_OR_OBJ_OF_CLASS_OR_NULL(destination_string, destination_object, base_ce) \
Z_PARAM_STR_OR_OBJ_OF_CLASS_EX(destination_string, destination_object, base_ce, 1);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "d" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_DOUBLE_EX2(dest, is_null, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_double(_arg, &dest, &is_null, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_DOUBLE_OR_NULL : Z_EXPECTED_DOUBLE; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_DOUBLE_EX(dest, is_null, check_null, separate) \
Z_PARAM_DOUBLE_EX2(dest, is_null, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_DOUBLE(dest) \
Z_PARAM_DOUBLE_EX(dest, _dummy, 0, 0)
Convert UNKNOWN default values to null in ext/date Closes GH-5509
2020-05-02 03:45:30 +08:00
#define Z_PARAM_DOUBLE_OR_NULL(dest, is_null) \
Z_PARAM_DOUBLE_EX(dest, is_null, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "f" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_FUNC_EX2(dest_fci, dest_fcc, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
if (UNEXPECTED(!zend_parse_arg_func(_arg, &dest_fci, &dest_fcc, check_null, &_error))) { \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
if (!_error) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_FUNC_OR_NULL : Z_EXPECTED_FUNC; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} else { \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_CALLBACK; \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} \
Remove more leftovers from invalid static calls Callbacks are now always valid or not valid, there is no in-between.
2019-01-30 20:08:35 +08:00
break; \
} \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_FUNC_EX(dest_fci, dest_fcc, check_null, separate) \
Z_PARAM_FUNC_EX2(dest_fci, dest_fcc, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_FUNC(dest_fci, dest_fcc) \
Z_PARAM_FUNC_EX(dest_fci, dest_fcc, 0, 0)
Allow null callback to array_filter() With same behavior as not passing it.
2020-05-13 23:24:13 +08:00
#define Z_PARAM_FUNC_OR_NULL(dest_fci, dest_fcc) \
Z_PARAM_FUNC_EX(dest_fci, dest_fcc, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "h" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_HT_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Fixed bug #71266 (Missing separation of properties HT in foreach etc).
2016-06-08 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_array_ht(_arg, &dest, check_null, 0, separate))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_ARRAY_OR_NULL : Z_EXPECTED_ARRAY; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_HT_EX(dest, check_null, separate) \
Z_PARAM_ARRAY_HT_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_ARRAY_HT(dest) \
Z_PARAM_ARRAY_HT_EX(dest, 0, 0)
/* old "H" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_OR_OBJECT_HT_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Fixed bug #71266 (Missing separation of properties HT in foreach etc).
2016-06-08 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_array_ht(_arg, &dest, check_null, 1, separate))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_ARRAY_OR_NULL : Z_EXPECTED_ARRAY; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ARRAY_OR_OBJECT_HT_EX(dest, check_null, separate) \
Z_PARAM_ARRAY_OR_OBJECT_HT_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_ARRAY_OR_OBJECT_HT(dest) \
Z_PARAM_ARRAY_OR_OBJECT_HT_EX(dest, 0, 0)
/* old "l" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_LONG_EX2(dest, is_null, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Remove zpp L specifier We don't use this internally anymore, and external usages should be encouraged to move towards 'l'.
2019-06-03 15:39:17 +08:00
if (UNEXPECTED(!zend_parse_arg_long(_arg, &dest, &is_null, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_LONG_OR_NULL : Z_EXPECTED_LONG; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_LONG_EX(dest, is_null, check_null, separate) \
Z_PARAM_LONG_EX2(dest, is_null, check_null, separate, separate)
master renames phase 1
2014-08-26 01:24:55 +08:00
#define Z_PARAM_LONG(dest) \
Z_PARAM_LONG_EX(dest, _dummy, 0, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Add Z_PARAM_LONG_OR_NULL macro
2019-10-22 04:04:57 +08:00
#define Z_PARAM_LONG_OR_NULL(dest, is_null) \
Z_PARAM_LONG_EX(dest, is_null, 1, 0)
Add Z_PARAM_NUMBER and use it for some functions
2019-06-03 16:12:21 +08:00
Constrain number parameter of numfmt_format to int|float This is inline with similar changes to the math functions. Especially, array to number conversion makes no sense here, and is likely to hide a programming error. To make that feasible, we introduce the `n` specifier for classic ZPP so we can stick with `zend_parse_method_parameters()`. We also remove a test case, which has been degenerated to a ZPP test.
2020-02-16 23:41:43 +08:00
/* old "n" */
Add Z_PARAM_NUMBER and use it for some functions
2019-06-03 16:12:21 +08:00
#define Z_PARAM_NUMBER_EX(dest, check_null) \
Z_PARAM_PROLOGUE(0, 0); \
if (UNEXPECTED(!zend_parse_arg_number(_arg, &dest, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_NUMBER_OR_NULL : Z_EXPECTED_NUMBER; \
Add Z_PARAM_NUMBER and use it for some functions
2019-06-03 16:12:21 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
break; \
}
#define Z_PARAM_NUMBER_OR_NULL(dest) \
Z_PARAM_NUMBER_EX(dest, 1)
#define Z_PARAM_NUMBER(dest) \
Z_PARAM_NUMBER_EX(dest, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "o" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_OBJECT_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
if (UNEXPECTED(!zend_parse_arg_object(_arg, &dest, NULL, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_OBJECT_OR_NULL : Z_EXPECTED_OBJECT; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_OBJECT_EX(dest, check_null, separate) \
Z_PARAM_OBJECT_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_OBJECT(dest) \
Z_PARAM_OBJECT_EX(dest, 0, 0)
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
#define Z_PARAM_OBJECT_OR_NULL(dest) \
Z_PARAM_OBJECT_EX(dest, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "O" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_OBJECT_OF_CLASS_EX2(dest, _ce, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
if (UNEXPECTED(!zend_parse_arg_object(_arg, &dest, _ce, check_null))) { \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
if (_ce) { \
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 09:05:24 +08:00
_error = ZSTR_VAL((_ce)->name); \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_error_code = check_null ? ZPP_ERROR_WRONG_CLASS_OR_NULL : ZPP_ERROR_WRONG_CLASS; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} else { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_OBJECT_OR_NULL : Z_EXPECTED_OBJECT; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_OBJECT_OF_CLASS_EX(dest, _ce, check_null, separate) \
Z_PARAM_OBJECT_OF_CLASS_EX2(dest, _ce, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_OBJECT_OF_CLASS(dest, _ce) \
Z_PARAM_OBJECT_OF_CLASS_EX(dest, _ce, 0, 0)
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
#define Z_PARAM_OBJECT_OF_CLASS_OR_NULL(dest, _ce) \
Z_PARAM_OBJECT_OF_CLASS_EX(dest, _ce, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "p" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_PATH_EX2(dest, dest_len, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_path(_arg, &dest, &dest_len, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_PATH_OR_NULL : Z_EXPECTED_PATH; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_PATH_EX(dest, dest_len, check_null, separate) \
Z_PARAM_PATH_EX2(dest, dest_len, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_PATH(dest, dest_len) \
Z_PARAM_PATH_EX(dest, dest_len, 0, 0)
Add the Z_PARAM_PATH_OR_NULL() and Z_PARAM_ZVAL_OR_NULL() macros
2020-07-24 16:06:45 +08:00
#define Z_PARAM_PATH_OR_NULL(dest, dest_len) \
Z_PARAM_PATH_EX(dest, dest_len, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "P" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_PATH_STR_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_path_str(_arg, &dest, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_PATH_OR_NULL : Z_EXPECTED_PATH; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_PATH_STR_EX(dest, check_null, separate) \
Z_PARAM_PATH_STR_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_PATH_STR(dest) \
Z_PARAM_PATH_STR_EX(dest, 0, 0)
/* old "r" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_RESOURCE_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
if (UNEXPECTED(!zend_parse_arg_resource(_arg, &dest, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_RESOURCE_OR_NULL : Z_EXPECTED_RESOURCE; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_RESOURCE_EX(dest, check_null, separate) \
Z_PARAM_RESOURCE_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_RESOURCE(dest) \
Z_PARAM_RESOURCE_EX(dest, 0, 0)
Add Z_PARAM_RESOURCE_OR_NULL() As a more explicit alternative to Z_PARAM_RESOURCE_EX(, 1, 0).
2020-04-09 21:39:11 +08:00
#define Z_PARAM_RESOURCE_OR_NULL(dest) \
Z_PARAM_RESOURCE_EX(dest, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "s" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_STRING_EX2(dest, dest_len, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_string(_arg, &dest, &dest_len, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_STRING_OR_NULL : Z_EXPECTED_STRING; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_STRING_EX(dest, dest_len, check_null, separate) \
Z_PARAM_STRING_EX2(dest, dest_len, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_STRING(dest, dest_len) \
Z_PARAM_STRING_EX(dest, dest_len, 0, 0)
Add Z_PARAM_STRING/ARRAY_OR_NULL convenience macros
2019-10-29 20:29:52 +08:00
#define Z_PARAM_STRING_OR_NULL(dest, dest_len) \
Z_PARAM_STRING_EX(dest, dest_len, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "S" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_STR_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (UNEXPECTED(!zend_parse_arg_str(_arg, &dest, check_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = check_null ? Z_EXPECTED_STRING_OR_NULL : Z_EXPECTED_STRING; \
Prefix error_code with underscore in FastZPP implementation To avoid conflicts with parameter names.
2019-01-08 16:24:51 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
break; \
}
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_STR_EX(dest, check_null, separate) \
Z_PARAM_STR_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_STR(dest) \
Z_PARAM_STR_EX(dest, 0, 0)
Fix UNKNOWN default values in various extensions Closes GH-5514
2020-05-02 21:25:25 +08:00
#define Z_PARAM_STR_OR_NULL(dest) \
Z_PARAM_STR_EX(dest, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "z" */
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
#define Z_PARAM_ZVAL_EX2(dest, check_null, deref, separate) \
Z_PARAM_PROLOGUE(deref, separate); \
zend_parse_arg_zval_deref(_arg, &dest, check_null);
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
#define Z_PARAM_ZVAL_EX(dest, check_null, separate) \
Improved new Zend Parameter Parsing API to avoid useless dereferences. This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7. The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).
2017-06-08 18:03:24 +08:00
Z_PARAM_ZVAL_EX2(dest, check_null, separate, separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
#define Z_PARAM_ZVAL(dest) \
Z_PARAM_ZVAL_EX(dest, 0, 0)
Add the Z_PARAM_PATH_OR_NULL() and Z_PARAM_ZVAL_OR_NULL() macros
2020-07-24 16:06:45 +08:00
#define Z_PARAM_ZVAL_OR_NULL(dest) \
Z_PARAM_ZVAL_EX(dest, 1, 0)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
/* old "+" and "*" */
#define Z_PARAM_VARIADIC_EX(spec, dest, dest_num, post_varargs) do { \
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
uint32_t _num_varargs = _num_args - _i - (post_varargs); \
Fixed compilation warnings about unused labels
2014-08-11 14:17:06 +08:00
if (EXPECTED(_num_varargs > 0)) { \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
dest = _real_arg + 1; \
dest_num = _num_varargs; \
_i += _num_varargs; \
_real_arg += _num_varargs; \
} else { \
dest = NULL; \
dest_num = 0; \
} \
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
if (UNEXPECTED(ZEND_CALL_INFO(execute_data) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { \
_error_code = ZPP_ERROR_UNEXPECTED_EXTRA_NAMED; \
break; \
} \
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} while (0);
#define Z_PARAM_VARIADIC(spec, dest, dest_num) \
Z_PARAM_VARIADIC_EX(spec, dest, dest_num, 0)
Implement named parameters From an engine perspective, named parameters mainly add three concepts: * The SEND_* opcodes now accept a CONST op2, which is the argument name. For now, it is looked up by linear scan and runtime cached. * This may leave UNDEF arguments on the stack. To avoid having to deal with them in other places, a CHECK_UNDEF_ARGS opcode is used to either replace them with defaults, or error. * For variadic functions, EX(extra_named_params) are collected and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS. RFC: https://wiki.php.net/rfc/named_params Closes GH-5357.
2020-04-06 18:46:52 +08:00
#define Z_PARAM_VARIADIC_WITH_NAMED(dest, dest_num, dest_named) do { \
int _num_varargs = _num_args - _i; \
if (EXPECTED(_num_varargs > 0)) { \
dest = _real_arg + 1; \
dest_num = _num_varargs; \
} else { \
dest = NULL; \
dest_num = 0; \
} \
if (ZEND_CALL_INFO(execute_data) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { \
dest_named = execute_data->extra_named_params; \
} else { \
dest_named = NULL; \
} \
} while (0);
mb_detect_encoding(): Use proper array|string parameter Needed to add support for nullabiltiy in some places.
2020-03-30 22:06:41 +08:00
#define Z_PARAM_STR_OR_ARRAY_HT_EX(dest_str, dest_ht, allow_null) \
Support "string or array" in zpp This is one of our more common argument unions. Usage is just prototyped in a few places, certainly not a full conversion. I'm removing the str_replace.phpt test, because aparently it was split up into smaller tests at some point, but the original has not been removed. Closes GH-4970.
2019-12-05 17:28:41 +08:00
Z_PARAM_PROLOGUE(0, 0); \
mb_detect_encoding(): Use proper array|string parameter Needed to add support for nullabiltiy in some places.
2020-03-30 22:06:41 +08:00
if (UNEXPECTED(!zend_parse_arg_str_or_array_ht(_arg, &dest_str, &dest_ht, allow_null))) { \
Display nullability in type error messages for internal functions Closes GH-5327
2020-03-31 04:49:55 +08:00
_expected_type = allow_null ? Z_EXPECTED_STRING_OR_ARRAY_OR_NULL : Z_EXPECTED_STRING_OR_ARRAY; \
Support "string or array" in zpp This is one of our more common argument unions. Usage is just prototyped in a few places, certainly not a full conversion. I'm removing the str_replace.phpt test, because aparently it was split up into smaller tests at some point, but the original has not been removed. Closes GH-4970.
2019-12-05 17:28:41 +08:00
_error_code = ZPP_ERROR_WRONG_ARG; \
break; \
}
mb_detect_encoding(): Use proper array|string parameter Needed to add support for nullabiltiy in some places.
2020-03-30 22:06:41 +08:00
#define Z_PARAM_STR_OR_ARRAY_HT(dest_str, dest_ht) \
Z_PARAM_STR_OR_ARRAY_HT_EX(dest_str, dest_ht, 0);
#define Z_PARAM_STR_OR_ARRAY_HT_OR_NULL(dest_str, dest_ht) \
Z_PARAM_STR_OR_ARRAY_HT_EX(dest_str, dest_ht, 1);
Add Fast ZPP string|int type check
2020-04-24 21:35:03 +08:00
#define Z_PARAM_STR_OR_LONG_EX(dest_str, dest_long, is_null, allow_null) \
Z_PARAM_PROLOGUE(0, 0); \
if (UNEXPECTED(!zend_parse_arg_str_or_long(_arg, &dest_str, &dest_long, &is_null, allow_null))) { \
_expected_type = allow_null ? Z_EXPECTED_STRING_OR_LONG_OR_NULL : Z_EXPECTED_STRING_OR_LONG; \
_error_code = ZPP_ERROR_WRONG_ARG; \
break; \
}
#define Z_PARAM_STR_OR_LONG(dest_str, dest_long) \
Z_PARAM_STR_OR_LONG_EX(dest_str, dest_long, _dummy, 0);
#define Z_PARAM_STR_OR_LONG_OR_NULL(dest_str, dest_long, is_null) \
Z_PARAM_STR_OR_LONG_EX(dest_str, dest_long, is_null, 1);
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
/* End of new parameter parsing API */
/* Inlined implementations shared by new and old parameter parsing APIs */
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
Use consistent types uint32_t type for argument count size_t for length of char* zend_bool for a zval bool arg Closes GH-5845
2020-07-12 06:16:29 +08:00
ZEND_API int ZEND_FASTCALL zend_parse_arg_class(zval *arg, zend_class_entry **pce, uint32_t num, int check_null);
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
ZEND_API int ZEND_FASTCALL zend_parse_arg_bool_slow(zval *arg, zend_bool *dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_bool_weak(zval *arg, zend_bool *dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_long_slow(zval *arg, zend_long *dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_long_weak(zval *arg, zend_long *dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_double_slow(zval *arg, double *dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_double_weak(zval *arg, double *dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_str_slow(zval *arg, zend_string **dest);
ZEND_API int ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, zend_string **dest);
Add Z_PARAM_NUMBER and use it for some functions
2019-06-03 16:12:21 +08:00
ZEND_API int ZEND_FASTCALL zend_parse_arg_number_slow(zval *arg, zval **dest);
Add Fast ZPP string|int type check
2020-04-24 21:35:03 +08:00
ZEND_API int ZEND_FASTCALL zend_parse_arg_str_or_long_slow(zval *arg, zend_string **dest_str, zend_long *dest_long);
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_bool(zval *arg, zend_bool *dest, zend_bool *is_null, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (check_null) {
*is_null = 0;
}
if (EXPECTED(Z_TYPE_P(arg) == IS_TRUE)) {
*dest = 1;
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
} else if (EXPECTED(Z_TYPE_P(arg) == IS_FALSE)) {
*dest = 0;
} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
*is_null = 1;
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
*dest = 0;
} else {
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
return zend_parse_arg_bool_slow(arg, dest);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
}
return 1;
}
Remove zpp L specifier We don't use this internally anymore, and external usages should be encouraged to move towards 'l'.
2019-06-03 15:39:17 +08:00
static zend_always_inline int zend_parse_arg_long(zval *arg, zend_long *dest, zend_bool *is_null, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (check_null) {
*is_null = 0;
}
master renames phase 1
2014-08-26 01:24:55 +08:00
if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
*dest = Z_LVAL_P(arg);
Imroved ZPP rules (condititins reoredered to prevent duplicate checks)
2015-03-20 22:27:03 +08:00
} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
*is_null = 1;
*dest = 0;
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} else {
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
return zend_parse_arg_long_slow(arg, dest);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
}
return 1;
}
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_double(zval *arg, double *dest, zend_bool *is_null, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (check_null) {
*is_null = 0;
}
if (EXPECTED(Z_TYPE_P(arg) == IS_DOUBLE)) {
*dest = Z_DVAL_P(arg);
Imroved ZPP rules (condititins reoredered to prevent duplicate checks)
2015-03-20 22:27:03 +08:00
} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
*is_null = 1;
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
*dest = 0.0;
} else {
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
return zend_parse_arg_double_slow(arg, dest);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
}
return 1;
}
Add Z_PARAM_NUMBER and use it for some functions
2019-06-03 16:12:21 +08:00
static zend_always_inline int zend_parse_arg_number(zval *arg, zval **dest, int check_null)
{
if (EXPECTED(Z_TYPE_P(arg) == IS_LONG || Z_TYPE_P(arg) == IS_DOUBLE)) {
*dest = arg;
} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest = NULL;
} else {
return zend_parse_arg_number_slow(arg, dest);
}
return 1;
}
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_str(zval *arg, zend_string **dest, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {
*dest = Z_STR_P(arg);
Imroved ZPP rules (condititins reoredered to prevent duplicate checks)
2015-03-20 22:27:03 +08:00
} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
*dest = NULL;
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
} else {
return zend_parse_arg_str_slow(arg, dest);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
}
return 1;
}
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_string(zval *arg, char **dest, size_t *dest_len, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
zend_string *str;
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (!zend_parse_arg_str(arg, &str, check_null)) {
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
return 0;
}
if (check_null && UNEXPECTED(!str)) {
*dest = NULL;
*dest_len = 0;
} else {
Improved zend_string API (Francois Laupretre) Squashed commit of the following: commit d96eab8d79b75ac83d49d49ae4665f948d15a804 Author: Francois Laupretre <francois@tekwire.net> Date: Fri Jun 26 01:23:31 2015 +0200 Use the new 'ZSTR' macros in the rest of the code. Does not change anything to the generated code (thanks to compat macros) but cleaner. commit b3526439104ac7a89a8e0c79dbebf33b22bd01b8 Author: Francois Laupretre <francois@tekwire.net> Date: Thu Jun 25 13:45:06 2015 +0200 Improve zend_string API Add missing methods
2015-06-29 21:44:54 +08:00
*dest = ZSTR_VAL(str);
*dest_len = ZSTR_LEN(str);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
}
return 1;
}
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_path_str(zval *arg, zend_string **dest, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (!zend_parse_arg_str(arg, dest, check_null) ||
Improved zend_string API (Francois Laupretre) Squashed commit of the following: commit d96eab8d79b75ac83d49d49ae4665f948d15a804 Author: Francois Laupretre <francois@tekwire.net> Date: Fri Jun 26 01:23:31 2015 +0200 Use the new 'ZSTR' macros in the rest of the code. Does not change anything to the generated code (thanks to compat macros) but cleaner. commit b3526439104ac7a89a8e0c79dbebf33b22bd01b8 Author: Francois Laupretre <francois@tekwire.net> Date: Thu Jun 25 13:45:06 2015 +0200 Improve zend_string API Add missing methods
2015-06-29 21:44:54 +08:00
(*dest && UNEXPECTED(CHECK_NULL_PATH(ZSTR_VAL(*dest), ZSTR_LEN(*dest))))) {
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
return 0;
}
return 1;
}
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_path(zval *arg, char **dest, size_t *dest_len, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
zend_string *str;
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-21 04:18:52 +08:00
if (!zend_parse_arg_path_str(arg, &str, check_null)) {
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
return 0;
}
if (check_null && UNEXPECTED(!str)) {
*dest = NULL;
*dest_len = 0;
} else {
Improved zend_string API (Francois Laupretre) Squashed commit of the following: commit d96eab8d79b75ac83d49d49ae4665f948d15a804 Author: Francois Laupretre <francois@tekwire.net> Date: Fri Jun 26 01:23:31 2015 +0200 Use the new 'ZSTR' macros in the rest of the code. Does not change anything to the generated code (thanks to compat macros) but cleaner. commit b3526439104ac7a89a8e0c79dbebf33b22bd01b8 Author: Francois Laupretre <francois@tekwire.net> Date: Thu Jun 25 13:45:06 2015 +0200 Improve zend_string API Add missing methods
2015-06-29 21:44:54 +08:00
*dest = ZSTR_VAL(str);
*dest_len = ZSTR_LEN(str);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
}
return 1;
}
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
static zend_always_inline int zend_parse_arg_array(zval *arg, zval **dest, int check_null, int or_object)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (EXPECTED(Z_TYPE_P(arg) == IS_ARRAY) ||
(or_object && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT))) {
*dest = arg;
} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest = NULL;
} else {
return 0;
}
return 1;
}
Fixed bug #71266 (Missing separation of properties HT in foreach etc).
2016-06-08 04:18:52 +08:00
static zend_always_inline int zend_parse_arg_array_ht(zval *arg, HashTable **dest, int check_null, int or_object, int separate)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (EXPECTED(Z_TYPE_P(arg) == IS_ARRAY)) {
*dest = Z_ARRVAL_P(arg);
} else if (or_object && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
Refactor zend_object_handlers API to pass zend_object* and zend_string* insted of zval(s).
2019-01-31 23:47:58 +08:00
zend_object *zobj = Z_OBJ_P(arg);
Fixed bug #71266 (Missing separation of properties HT in foreach etc).
2016-06-08 04:18:52 +08:00
if (separate
Refactor zend_object_handlers API to pass zend_object* and zend_string* insted of zval(s).
2019-01-31 23:47:58 +08:00
&& zobj->properties
&& UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
GC_DELREF(zobj->properties);
Fixed bug #71266 (Missing separation of properties HT in foreach etc).
2016-06-08 04:18:52 +08:00
}
Refactor zend_object_handlers API to pass zend_object* and zend_string* insted of zval(s).
2019-01-31 23:47:58 +08:00
zobj->properties = zend_array_dup(zobj->properties);
Fixed bug #71266 (Missing separation of properties HT in foreach etc).
2016-06-08 04:18:52 +08:00
}
Refactor zend_object_handlers API to pass zend_object* and zend_string* insted of zval(s).
2019-01-31 23:47:58 +08:00
*dest = zobj->handlers->get_properties(zobj);
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest = NULL;
} else {
return 0;
}
return 1;
}
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
static zend_always_inline int zend_parse_arg_object(zval *arg, zval **dest, zend_class_entry *ce, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (EXPECTED(Z_TYPE_P(arg) == IS_OBJECT) &&
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
(!ce || EXPECTED(instanceof_function(Z_OBJCE_P(arg), ce) != 0))) {
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
*dest = arg;
} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest = NULL;
} else {
return 0;
}
return 1;
}
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
static zend_always_inline int zend_parse_arg_resource(zval *arg, zval **dest, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (EXPECTED(Z_TYPE_P(arg) == IS_RESOURCE)) {
*dest = arg;
} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest = NULL;
} else {
return 0;
}
return 1;
}
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
static zend_always_inline int zend_parse_arg_func(zval *arg, zend_fcall_info *dest_fci, zend_fcall_info_cache *dest_fcc, int check_null, char **error)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
if (check_null && UNEXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
dest_fci->size = 0;
zend_fcall_info_cache.initialized is removed (zend_fcall_info_cache is initialized if zend_fcall_info_cache.function_handler is set).
2017-12-27 20:15:03 +08:00
dest_fcc->function_handler = NULL;
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
*error = NULL;
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
} else if (UNEXPECTED(zend_fcall_info_init(arg, 0, dest_fci, dest_fcc, NULL, error) != SUCCESS)) {
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
return 0;
}
return 1;
}
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
static zend_always_inline void zend_parse_arg_zval(zval *arg, zval **dest, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
*dest = (check_null &&
(UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) ||
(UNEXPECTED(Z_ISREF_P(arg)) &&
UNEXPECTED(Z_TYPE_P(Z_REFVAL_P(arg)) == IS_NULL)))) ? NULL : arg;
}
Make zend_parse_parameters share fast zpp implementation where possible Rename shared implementation functions and build them unconditionally Don't fail on empty path for zend_parse_arg_path Update type names Fix behaviour of by-reference "z" Make 'o' use zend_parse_arg_object Fix NULL string check in zend_parse_arg_path(_str)
2014-12-15 08:51:41 +08:00
static zend_always_inline void zend_parse_arg_zval_deref(zval *arg, zval **dest, int check_null)
Fast parameter parsing API This API is experemental. It may be changed or removed. It should be used only for really often used functions. (Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)
2014-07-11 20:32:20 +08:00
{
*dest = (check_null && UNEXPECTED(Z_TYPE_P(arg) == IS_NULL)) ? NULL : arg;
}
Support "string or array" in zpp This is one of our more common argument unions. Usage is just prototyped in a few places, certainly not a full conversion. I'm removing the str_replace.phpt test, because aparently it was split up into smaller tests at some point, but the original has not been removed. Closes GH-4970.
2019-12-05 17:28:41 +08:00
static zend_always_inline int zend_parse_arg_str_or_array_ht(
mb_detect_encoding(): Use proper array|string parameter Needed to add support for nullabiltiy in some places.
2020-03-30 22:06:41 +08:00
zval *arg, zend_string **dest_str, HashTable **dest_ht, int allow_null)
Support "string or array" in zpp This is one of our more common argument unions. Usage is just prototyped in a few places, certainly not a full conversion. I'm removing the str_replace.phpt test, because aparently it was split up into smaller tests at some point, but the original has not been removed. Closes GH-4970.
2019-12-05 17:28:41 +08:00
{
if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {
*dest_str = Z_STR_P(arg);
*dest_ht = NULL;
} else if (EXPECTED(Z_TYPE_P(arg) == IS_ARRAY)) {
*dest_ht = Z_ARRVAL_P(arg);
*dest_str = NULL;
mb_detect_encoding(): Use proper array|string parameter Needed to add support for nullabiltiy in some places.
2020-03-30 22:06:41 +08:00
} else if (allow_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest_ht = NULL;
*dest_str = NULL;
Support "string or array" in zpp This is one of our more common argument unions. Usage is just prototyped in a few places, certainly not a full conversion. I'm removing the str_replace.phpt test, because aparently it was split up into smaller tests at some point, but the original has not been removed. Closes GH-4970.
2019-12-05 17:28:41 +08:00
} else {
*dest_ht = NULL;
return zend_parse_arg_str_slow(arg, dest_str);
}
return 1;
}
Add Fast ZPP string|int type check
2020-04-24 21:35:03 +08:00
static zend_always_inline int zend_parse_arg_str_or_long(zval *arg, zend_string **dest_str, zend_long *dest_long,
zend_bool *is_null, int allow_null)
{
if (allow_null) {
*is_null = 0;
}
if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {
*dest_str = Z_STR_P(arg);
} else if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
*dest_str = NULL;
*dest_long = Z_LVAL_P(arg);
} else if (allow_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*dest_str = NULL;
*is_null = 1;
} else {
return zend_parse_arg_str_or_long_slow(arg, dest_str, dest_long);
}
return 1;
}
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
static zend_always_inline int zend_parse_arg_class_name_or_obj(
Drop unused param in zend_parse_arg_class_name_or_obj()
2020-07-17 03:00:28 +08:00
zval *arg, zend_class_entry **destination, int allow_null
Add ZPP macros for class name or object parameters Closes GH-5647
2020-06-30 17:14:58 +08:00
) {
if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {
*destination = zend_lookup_class(Z_STR_P(arg));
return *destination != NULL;
} else if (EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
*destination = Z_OBJ_P(arg)->ce;
} else if (allow_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
*destination = NULL;
} else {
return 0;
}
return 1;
}
Add string or object ZPP macros Closes GH-5788
2020-06-30 21:04:54 +08:00
static zend_always_inline int zend_parse_arg_str_or_obj(
zval *arg, zend_string **destination_string, zend_object **destination_object, zend_class_entry *base_ce, int allow_null
) {
if (EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
Fix STR_OR_OBJ_OF_TYPE stringable handling
2020-07-29 17:29:24 +08:00
if (!base_ce || EXPECTED(instanceof_function(Z_OBJCE_P(arg), base_ce))) {
*destination_string = NULL;
*destination_object = Z_OBJ_P(arg);
return 1;
Add string or object ZPP macros Closes GH-5788
2020-06-30 21:04:54 +08:00
}
}
Fix STR_OR_OBJ_OF_TYPE stringable handling
2020-07-29 17:29:24 +08:00
*destination_object = NULL;
return zend_parse_arg_str(arg, destination_string, allow_null);
Add string or object ZPP macros Closes GH-5788
2020-06-30 21:04:54 +08:00
}
MFZE1 (Expose more C++ APIs)
2002-05-20 15:17:30 +08:00
END_EXTERN_C()
- MFH as discussed . zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D) . zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D) . added E_RECOVERABLE_ERROR . added ZEND_TOSTRING_FUNC_NAME . added __tostring function cache to zend_class_entry . added ZEND_NAMED_ME . modified ZEND_ME_MAPPING to support method flags . added ZEND_MN . method entries now use prefix "zim_" instead of "zif_" . drop EG(ze1_compatibility_mode) . changed cast handler, now without (int should_free): typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC); . changed get_iterator, now receives whether value is by ref: zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC); . added zend_objects_store_add_ref_by_handle . added zend_objects_store_del_ref_by_handle . convert_to_explicit_type(pzv, type)
2006-05-10 07:53:23 +08:00
Change header protection macros to conform to standard. Draft 3 of IEEE 1003.1 200x, "2.2 The Compilation Environment" All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use by the implementation.
2000-07-03 07:54:19 +08:00
#endif /* ZEND_API_H */
Reference in New Issue Copy Permalink